Java for循环优化(Java for-loop optimization)

 我用java for循环做了一些运行时测试，并认识到了一个奇怪的行为。 对于我的代码，我需要像int，double等基本类型的包装对象来模拟io和输出参数，但那不是重点。 只需看我的代码。 具有字段访问权限的对象如何比原始类型更快？ 
 
 具有prtimitive类型的for循环： 
 
public static void main(String[] args) {
    double max = 1000;
    for (int j = 1; j < 8; j++) {
        double i;
        max = max * 10;
        long start = System.nanoTime();
        for (i = 0; i < max; i++) {
        }
        long end = System.nanoTime();
        long microseconds = (end - start) / 1000;
        System.out.println("MicroTime primitive(max: ="+max + "): " + microseconds);
    }
}
 
 结果： 
 
 
 
 MicroTime原语（最大值：= 10000.0）：110 
 MicroTime原语（最大值：= 100000.0）：1081 
 MicroTime原语（最大值：= 1000000.0）：2450 
 MicroTime原语（max：= 1.0E7）：28248 
 MicroTime原语（最大值：= 1.0E8）：276205 
 MicroTime原语（最大：= 1.0E9）：2729824 
 MicroTime原语（最大值= 1.0E10）：27547009 
 
 
 for loop with simple type（wrapper object）： 
 
public static void main(String[] args) {
    HDouble max = new HDouble();
    max.value = 1000;
    for (int j = 1; j < 8; j++) {
        HDouble i = new HDouble();
        max.value = max.value*10;
        long start = System.nanoTime();
        for (i.value = 0; i.value <max.value; i.value++) {
        }
        long end = System.nanoTime();
        long microseconds = (end - start) / 1000;
        System.out.println("MicroTime wrapper(max: ="+max.value + "): " + microseconds);
    }
}
 
 结果： 
 
 
 
 MicroTime封装（最大：= 10000.0）：157 
 MicroTime包装器（最大值：= 100000.0）：1561 
 MicroTime包装器（最大值：= 1000000.0）：3174 
 MicroTime包装器（最大值：= 1.0E7）：15630 
 MicroTime包装器（最大值：= 1.0E8）：155471 
 MicroTime包装器（最大值：= 1.0E9）：1520967 
 MicroTime包装器（最大值：= 1.0E10）：15373311 
 
 
 迭代次数越多，第二个代码就越快。 但为什么？ 我知道java编译器和jvm正在优化我的代码，但我从来没有想过，基元类型可能比有字段访问的对象慢。 
 有人有合理的解释吗？ 
 
 编辑：HDouble类： 
 
public class HDouble {
    public double value;

    public HDouble() {
    }

    public HDouble(double value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return String.valueOf(value);
    }
}
 
 我还用代码测试了我的循环。 例如，我计算总和 - >相同的行为（差异不是那么大，但我认为原始算法必须更快？）。 首先我想，计算需要很长时间，这个领域几乎没有区别。 
 
 包装for循环： 
 
for (i.value = 0; i.value <max.value; i.value++) {
    sum.value = sum.value + i.value;
}
 
 结果： 
 
 
 
 MicroTime包装器（最大值：= 10000.0）：243 
 MicroTime包装器（最大值：= 100000.0）：2805 
 MicroTime包装器（最大值：= 1000000.0）：3409 
 MicroTime包装器（最大值：= 1.0E7）：28104 
 MicroTime包装器（最大值：= 1.0E8）：278432 
 MicroTime封装（最大= 1.0E9）：2678322 
 MicroTime包装器（最大值：= 1.0E10）：26665540 
 
 
 原始for循环： 
 
for (i = 0; i < max; i++) {
    sum = sum + i;
}
 
 结果： 
 
 
 
 MicroTime基元（最大值= 10000.0）：149 
 MicroTime基元（最大：= 100000.0）：1996 
 MicroTime原语（最大值：= 1000000.0）：2289 
 MicroTime原语（最大值：= 1.0E7）：27085 
 MicroTime原语（最大值：= 1.0E8）：279939 
 MicroTime原语（最大值= 1.0E9）：2759133 
 MicroTime原语（最大值：= 1.0E10）：27369724 
 

I made some runtime tests with java for loops and recognized a strange behaviour. For my code I need wrapper objects for primitive types like int, double and so on, to simulate io and output parameters, but thats not the point. Just watch my code. How can objects with field access be faster then primitive types?
 
for loop with prtimitive type:
 
public static void main(String[] args) {
    double max = 1000;
    for (int j = 1; j < 8; j++) {
        double i;
        max = max * 10;
        long start = System.nanoTime();
        for (i = 0; i < max; i++) {
        }
        long end = System.nanoTime();
        long microseconds = (end - start) / 1000;
        System.out.println("MicroTime primitive(max: ="+max + "): " + microseconds);
    }
}
 
Result:
 
 
 
MicroTime primitive(max: =10000.0): 110
 MicroTime primitive(max: =100000.0): 1081
 MicroTime primitive(max: =1000000.0): 2450
 MicroTime primitive(max: =1.0E7): 28248
 MicroTime primitive(max: =1.0E8): 276205
 MicroTime primitive(max: =1.0E9): 2729824
 MicroTime primitive(max: =1.0E10): 27547009
 
 
for loop with simple type (wrapper object):
 
public static void main(String[] args) {
    HDouble max = new HDouble();
    max.value = 1000;
    for (int j = 1; j < 8; j++) {
        HDouble i = new HDouble();
        max.value = max.value*10;
        long start = System.nanoTime();
        for (i.value = 0; i.value <max.value; i.value++) {
        }
        long end = System.nanoTime();
        long microseconds = (end - start) / 1000;
        System.out.println("MicroTime wrapper(max: ="+max.value + "): " + microseconds);
    }
}
 
Result:
 
 
 
MicroTime wrapper(max: =10000.0): 157
 MicroTime wrapper(max: =100000.0): 1561
 MicroTime wrapper(max: =1000000.0): 3174
 MicroTime wrapper(max: =1.0E7): 15630
 MicroTime wrapper(max: =1.0E8): 155471
 MicroTime wrapper(max: =1.0E9): 1520967
 MicroTime wrapper(max: =1.0E10): 15373311
 
 
The more iterations, the faster is the second code. But why? I know that the java-compiler and jvm are optimizing my code, but I never thought that primitive types can be slower, than objects with field access.
 Does anyone have a plausible explanation for it?
 
Edited: HDouble class:
 
public class HDouble {
    public double value;

    public HDouble() {
    }

    public HDouble(double value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return String.valueOf(value);
    }
}
 
I also tested my loops with code in it. For example I calculate the sum -> same behaviour (the difference is not that big, but I thought the primitive algorithm have to be much faster?). First I thought, that the calculation takes that long, that the field access nearly no difference.
 
Wrapper for-loop:
 
for (i.value = 0; i.value <max.value; i.value++) {
    sum.value = sum.value + i.value;
}
 
Result:
 
 
 
MicroTime wrapper(max: =10000.0): 243
 MicroTime wrapper(max: =100000.0): 2805
 MicroTime wrapper(max: =1000000.0): 3409
 MicroTime wrapper(max: =1.0E7): 28104
 MicroTime wrapper(max: =1.0E8): 278432
 MicroTime wrapper(max: =1.0E9): 2678322
 MicroTime wrapper(max: =1.0E10): 26665540
 
 
Primitive for-loop:
 
for (i = 0; i < max; i++) {
    sum = sum + i;
}
 
Result:
 
 
 
MicroTime primitive(max: =10000.0): 149
 MicroTime primitive(max: =100000.0): 1996
 MicroTime primitive(max: =1000000.0): 2289
 MicroTime primitive(max: =1.0E7): 27085
 MicroTime primitive(max: =1.0E8): 279939
 MicroTime primitive(max: =1.0E9): 2759133
 MicroTime primitive(max: =1.0E10): 27369724
 

原文：https://stackoverflow.com/questions/33842116