Java для цикла против цикла while. Разница в производительности?

Предположим, у меня есть следующий код, для цикла есть три цикла. Будет ли он работать быстро, если я изменил самый внешний для цикла цикл while? спасибо ~~

int length = 200;
int test = 0;
int[] input = new int[10];

for(int i = 1; i <= length; i++) {
    for (int j = 0; j <=length - i; j++) {
        for (int k = 0; k < length - 1; k++) {
            test = test + input[j + k];
        }
    }
}

Ответы

Ответ 1

Нет, изменение типа цикла не имеет значения.

Единственное, что может сделать это быстрее, - это иметь меньше вложенных циклов и зацикливаться на меньших значениях.

Единственное различие между циклом for и циклом while - это синтаксис для их определения. Разница в производительности не существует.

int i = 0;
while (i < 20){
    // do stuff
    i++;
}

То же, что и:

for (int i = 0; i < 20; i++){
    // do Stuff
}

(На самом деле for-loop немного лучше, потому что i будет недоступен после цикла, в то время как i останется в цикле while.)

А для цикла является просто синтаксически более красивым способом цикла.

Ответ 2

Такая микро-оптимизация бессмысленна.

  • Контур while не будет быстрее.
  • Структура цикла не является вашим узким местом.
  • Сначала оптимизируйте свой алгоритм.
  • Еще лучше, сначала не оптимизируйте. Оптимизируйте только после того, как узнаете, что у вас действительно есть узкое место в вашем алгоритме, который не зависит от ввода/вывода.

Ответ 3

вы не можете его оптимизировать, изменив его на время.

вы можете просто увеличить скорость очень очень очень мало, изменив строку

for (int k = 0; k < length - 1; k++) {

по

for (int k = 0; k < lengthMinusOne; k++) {

где lengthMinusOne вычисляется до

это вычитание вычисляется почти (200x201/2) x (200-1) раз, и для компьютера очень мало:)

Ответ 4

Кто-то предложил протестировать циклы while vs for, поэтому я создал некоторый код для проверки того, были ли циклы или циклы быстрее; в среднем более 100 000 тестов, цикл while был быстрее ~ 95% времени. Возможно, я неправильно его закодировал, но я совсем не привык к кодированию, также учитывая, что, если я запускал всего 10 000 циклов, они оказались довольно даже в режиме запуска.

edit Я не сдвигал все значения массива, когда я пошел на тестирование для большего количества проб. Исправлено так, что вам было легче изменить количество проб, которые вы запускали.

import java.util.Arrays;

class WhilevsForLoops {

 public static void main(String[] args) {

final int trials = 100; //change number of trials
final int trialsrun = trials - 1;

boolean[] fscount = new boolean[trials]; //faster / slower boolean
int p = 0; // while counter variable for for/while timers



while (p <= trialsrun) {
     long[] forloop = new long[trials];
     long[] whileloop = new long[trials];

     long systimeaverage; 
     long systimenow = System.nanoTime();
     long systimethen = System.nanoTime();

     System.out.println("For loop time array : ");
     for (int counter=0;counter <= trialsrun; counter++) {
         systimenow = System.nanoTime();
         System.out.print(" #" + counter + " @");
         systimethen = System.nanoTime();
         systimeaverage = (systimethen - systimenow);
         System.out.print( systimeaverage + "ns |");

         forloop[counter] = systimeaverage; 
     }

     int count = 0;
     System.out.println(" ");
     System.out.println("While loop time array: ");
     while (count <= trialsrun) {
         systimenow = System.nanoTime();
         System.out.print(" #" + count + " @");
         systimethen = System.nanoTime();
         systimeaverage = (systimethen - systimenow);
         System.out.print( systimeaverage + "ns |");

         whileloop[count] = systimeaverage;
         count++;
     }


     System.out.println("===============================================");
     int sum = 0;

     for (int i = 0; i <= trialsrun; i++) {
        sum += forloop[i];
     }

     System.out.println("for loop time average: " + (sum / trials) + "ns");

     int sum1 = 0;

     for (int i = 0; i <= trialsrun; i++) {
         sum1 += whileloop[i];
     }
     System.out.println("while loop time average: " + (sum1 / trials) + "ns");



     int longer = 0;
     int shorter = 0;
     int gap = 0;

     sum = sum / trials;
     sum1 = sum1 / trials; 

     if (sum1 > sum) {
        longer = sum1;
        shorter = sum;
     }
     else {
        longer = sum;
        shorter = sum1;
     }

     String longa;

     if (sum1 > sum) {
        longa = "~while loop~";
     }
     else {
         longa = "~for loop~";
     }

     gap = longer - shorter; 
     System.out.println("The " + longa + " is the slower loop by: " + gap + "ns");
     if (sum1 > sum) {
     fscount[p] = true; }
     else {
         fscount[p] = false;
     }
     p++;
}

    int forloopfc=0;
    int whileloopfc=0;

    System.out.println(Arrays.toString(fscount));

    for(int k=0; k <= trialsrun; k++) {
        if (fscount[k] == true) {
            forloopfc++; }
            else {
                whileloopfc++;}

    }

    System.out.println("--------------------------------------------------");

    System.out.println("The FOR loop was faster: " + forloopfc + " times.");
    System.out.println("The WHILE loop was faster: " + whileloopfc + " times.");
 }

}

Ответ 5

Даже если гипотеза о том, что цикл while был быстрее, чем цикл for, был истинным (и это не так), петли, которые вы должны были изменить/оптимизировать, не были бы внешними, а внутренними, потому что это выполняется больше раз.

Ответ 6

Разница между символами for и while семантической:

  • В цикле while вы будете зацикливаться до тех пор, пока условие будет истинным, что может сильно варьироваться, потому что вы можете в своем цикле модифицировать переменные, используя для определения условия while.
  • Обычно в цикле for вы выполняете цикл N времени. Этот N может быть переменным, но не перемещается до конца вашего цикла N, поскольку обычно разработчики не изменяют переменные, оцененные в состоянии цикла.

Это способ помочь другим понять ваш код. Вы не обязаны изменять переменные цикла, но это обычная (и хорошая) практика.

Ответ 7

здесь полезная ссылка в статью по этому вопросу

в соответствии с ним, "Вниз" и "В" почти в два раза быстрее, но оба они одинаковы.

НО эта статья была написана в 2009 году, поэтому я попробовал ее на своей машине и вот результаты:

  • с использованием java 1.7: Итератор был примерно на 20% -30% быстрее, чем "И" и "Пока" (которые были все те же)
  • с использованием java 1.6: Iterator был примерно на 5% быстрее, чем For и While (которые были все те же)

поэтому я думаю, что самое лучшее - просто время на вашей собственной версии и машине и сделать вывод из этого

Ответ 8

Нет, вы все равно повторяете то же самое количество раз. Совсем неважно.

Ответ 9

Посмотрите на свой алгоритм! Знаете ли вы заранее, какие значения из вашего массива добавляются более одного раза?

Если вы знаете, что можете уменьшить количество циклов, и это приведет к повышению производительности.

Ответ 10

Было бы важно, только если вы используете многопоточное или многопроцессорное программирование. Тогда это также зависит от того, как вы назначаете петли для различных процессоров/потоков.

Ответ 11

Не было бы разницы в производительности. Попробуйте!

JVM и, далее, компилятор, сделают обе петли чем-то вроде

    label:
       ;code inside your for loop.
    LOOP label

Ответ 12

Кто-нибудь пробовал вот так...

int i = 20;
while (--i > -1){
    // do stuff
}

По сравнению с:

for (int i = 0; i < 20; i++){
    // do Stuff
}

Ответ 13

Исходя из этого: https://jsperf.com/loops-analyze (не созданный мной) цикл while на 22% медленнее, чем цикл for в целом. По крайней мере, в Javascript это.