java中for和while循环_Java for循环与while循环 性能差异？

假设我有以下代码，有3个for循环可以执行某些操作。 如果我将最外部的for循环更改为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];

}

}

}

它会优化以测试= 0; 因为未填充数组，所以test = test + input [j + k]; 将始终为零。

时间到了！ 还有idk java，但我在perl中知道，在读取文件的情况下，C风格的循环比while循环特别慢。

不，更改循环的类型无关紧要。

唯一可以使其更快的方法是减少循环的嵌套，并减少循环的值。

for循环和while循环之间的唯一区别是定义它们的语法。根本没有性能差异。

int i = 0;

while (i < 20){

// do stuff

i++;

}

是相同的：

for (int i = 0; i < 20; i++){

// do Stuff

}

(实际上，for循环要好一些，因为i将在循环后超出范围，而i将在while循环情况下停留。)

for循环只是语法上更漂亮的循环方式。

您可以在i周围添加范围，以在完成操作后将其从堆栈中剔除：D

实际上，由于continue的行为，for循环和while循环略有不同。增量将始终在for循环中发生，而while循环中的继续执行将跳过它，从而导致循环永远继续下去。

为什么这不是正确的答案？恕我直言，这完全解释了如何使用这些循环。

这种微优化是没有意义的。

一会儿循环不会更快。

循环结构不是您的瓶颈。

首先优化算法。

更好的是，不要先进行优化。只有在发现算法中确实存在不依赖I / O的瓶颈后，才进行优化。

您无法通过将其更改为while来对其进行优化。

您可以通过更改直线来非常非常非常非常快地提高速度

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

通过

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

其中lengthMinusOne是在之前计算的

此减法运算几乎是(200x201 / 2)x(200-1)倍，对于计算机来说这是很少的数字:)

这些天，Java编译器通常会优化该调用。但是从技术上讲，您认为它更快。

呵呵，我有一半期望有人建议将k++更改为++k：D

您将节省非常非常少的编译时间。现在大多数编译器都支持这种优化，请检查stackoverflow.com/questions/5981460/

有人建议测试while与for循环，因此我创建了一些代码来测试while循环或for循环是否更快。平均而言，超过100,000个测试，while循环的速度约为95％。我可能编码不正确，我是编码的新手，还要考虑如果我只运行10,000个循环，它们最终在运行期间会变得很均匀。

编辑当我去测试更多的试验时，我并没有移动所有的数组值。对其进行了修复，以便更轻松地更改您运行的试验次数。

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几乎快一倍，但两者相同。

但是这篇文章写于2009年，所以我在我的机器上尝试了一下，结果如下：

使用Java 1.7：Iterator比For和While(仍然相同)快20％-30％

使用Java 1.6：Iterator比For和While(仍然相同)快大约5％。

所以我想最好的办法是将它放在您自己的版本和机器上，然后得出结论

在任何安全的语言中，迭代器的使用通常更快，因为解释器/编译器可以省略边界检查。

for和while之间的区别是语义：

在while循环中，只要条件为真，就会循环，这可能会发生很大变化，因为您可能会在循环中使用消除while条件来修改变量。

通常，在for循环中，您循环N次。这个N可以是变量，但要等到N循环结束后才能移动，因为通常开发人员不会修改在循环条件下评估的变量。

这是帮助他人理解您的代码的一种方法。您没有义务不修改循环变量，但这是一种常见的(也是很好的做法)。

即使while循环比for循环快的假设是正确的(事实并非如此)，您不得不更改/优化的循环也不会是外部的，而是内部的，因为它们执行的次数更多。

看看你的算法！您是否事先知道数组中的哪些值被多次添加？

如果您知道可以减少循环次数，那将导致更好的性能。

不，您仍在循环相同的次数。没关系。

While循环和For循环相同

http://www.mkyong.com/java/while-loop-for-loop-and-iterator-performance-test-java/

链接中的结论表明，迭代器机制是循环遍历列表的最慢方法。 For和While循环之间没有太多性能差异。

本文甚至没有说While循环比For循环快。

有没有人尝试过这样的...

int i = 20;

while (--i > -1){

// do stuff

}

相比：

for (int i = 0; i < 20; i++){

// do Stuff

}

不会有性能差异。试试看！

JVM和进一步的编译器会将两个循环都变成类似

label:

;code inside your for loop.

LOOP label

仅在使用多线程或多处理器编程时才重要。然后，这还取决于您如何将循环分配给各种处理器/线程。

基于此：https://jsperf.com/loops-analyze(不是我创建的)，而while循环通常比for循环慢22％。 至少在Javascript中是这样。