Предположим, у меня есть следующий код, для цикла есть три цикла. Будет ли он работать быстро, если я изменил самый внешний для цикла цикл 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];
}
}
}
Нет, изменение типа цикла не имеет значения.
Единственное, что может сделать это быстрее, - это иметь меньше вложенных циклов и зацикливаться на меньших значениях.
Единственное различие между циклом 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.)
А для цикла является просто синтаксически более красивым способом цикла.
Такая микро-оптимизация бессмысленна.
вы не можете его оптимизировать, изменив его на время.
вы можете просто увеличить скорость очень очень очень мало, изменив строку
for (int k = 0; k < length - 1; k++) {
по
for (int k = 0; k < lengthMinusOne; k++) {
где lengthMinusOne вычисляется до
это вычитание вычисляется почти (200x201/2) x (200-1) раз, и для компьютера очень мало:)
Кто-то предложил протестировать циклы 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.");
}
}
Даже если гипотеза о том, что цикл while был быстрее, чем цикл for, был истинным (и это не так), петли, которые вы должны были изменить/оптимизировать, не были бы внешними, а внутренними, потому что это выполняется больше раз.
Разница между символами for и while семантической:
Это способ помочь другим понять ваш код. Вы не обязаны изменять переменные цикла, но это обычная (и хорошая) практика.
здесь полезная ссылка в статью по этому вопросу
в соответствии с ним, "Вниз" и "В" почти в два раза быстрее, но оба они одинаковы.
НО эта статья была написана в 2009 году, поэтому я попробовал ее на своей машине и вот результаты:
поэтому я думаю, что самое лучшее - просто время на вашей собственной версии и машине и сделать вывод из этого
Нет, вы все равно повторяете то же самое количество раз. Совсем неважно.
Посмотрите на свой алгоритм! Знаете ли вы заранее, какие значения из вашего массива добавляются более одного раза?
Если вы знаете, что можете уменьшить количество циклов, и это приведет к повышению производительности.
Было бы важно, только если вы используете многопоточное или многопроцессорное программирование. Тогда это также зависит от того, как вы назначаете петли для различных процессоров/потоков.
Не было бы разницы в производительности. Попробуйте!
JVM и, далее, компилятор, сделают обе петли чем-то вроде
label:
;code inside your for loop.
LOOP label
Кто-нибудь пробовал вот так...
int i = 20;
while (--i > -1){
// do stuff
}
По сравнению с:
for (int i = 0; i < 20; i++){
// do Stuff
}
Исходя из этого: https://jsperf.com/loops-analyze (не созданный мной) цикл while на 22% медленнее, чем цикл for в целом. По крайней мере, в Javascript это.
В то время как циклы Loop и For одинаковы
http://www.mkyong.com/java/while-loop-for-loop-and-iterator-performance-test-java/