java的循环 - 一类的声明外/内循环

可能显示的文件：
Which loop has better performance? Why?
Which is optimal ?
循环时Efficiency of Java code with primitive types java的循环 - 一类的声明外/内循环

，例如：

for (int j = 0; j < 1000; j++) {};我需要安心赋值1000个对象，当我在循环内声明它在循环外部声明时，它有什么不同？

for (int j = 0; j < 1000; j++) {Object obj; obj =}

Object obj; 
for (int j = 0; j < 1000; j++) {obj =}

很明显的是，对象是只从循环范围或者从周围的范围进行访问。但我不明白性能问题，垃圾收集等。

什么是最佳实践？谢谢

来源

2010-05-25 lisak

第一种形式更好。限制变量的范围可以让读者更容易理解它在哪里以及如何使用。

从表现上看，有限范围也有一些小优点，你可以在another answer.中看到，但这些问题仅次于代码理解。

来源

2010-05-25 00:52:34 erickson

没有区别。编译器会将它们优化到相同的地方。

来源

2010-05-25 00:47:56 bmargulies

不正确。连续尝试其中两个并比较字节码。 – EJP 2010-05-26 00:47:57

字节码不重要。它的JIT将其优化到机器代码中。 – bmargulies 2010-05-26 01:01:06

我测试过这个问题我的机器的差异约为2-4ms超过10000种情况下，我测试的所有类的东西，就像如果你实例化并分配值：比较

int i=0;

在

：

int i; 
i=0;

这里是我用于测试的代码，当然，我改变了它的测试，并且有一个初始平衡作用机器达到优化前，你可以看到，在明确一旦测试：

package initializer; 
public final class EfficiencyTests { 
private static class Stoper { 
    private long initTime; 
    private long executionDuration; 

    public Stoper() { 
    // TODO Auto-generated constructor stub 
    } 
    private void start() { 
     initTime = System.nanoTime(); 
    } 
    private void stop() { 
     executionDuration = System.nanoTime() - initTime; 
    } 
    @Override 
    public String toString() { 
     return executionDuration + " nanos"; 
    } 
} 

private static Stoper stoper = new Stoper(); 

public static void main(String[] args) { 
    for (int i = 0; i < 100; i++) { 
     theCycleOfAForLoop(100000); 
     theCycleOfAForLoopWithACallToSize(100000); 
     howLongDoesItTakeToSetValueToAVariable(100000); 
     howLongDoesItTakeToDefineAVariable(100000); 
     System.out.println("\n"); 
    } 
} 
private static void theCycleOfAForLoop(int loops) { 
    stoper.start(); 
    for (int i = 0; i < loops; i++); 
    stoper.stop(); 
    System.out.println("The average duration of 10 cycles of an empty 'for' loop over " + loops + " iterations is: " + stoper.executionDuration * 10/loops); 
} 
private static void theCycleOfAForLoopWithACallToSize(int loops) { 
    ArrayList<Object> objects=new ArrayList<Object>(); 
    for (int i = 0; i < loops; i++) 
     objects.add(new Object()); 
    stoper.start(); 
    for (int i = 0; i < objects.size(); i++); 
    stoper.stop(); 
    System.out.println("The average duration of 10 cycles of an empty 'for' loop with call to size over " + loops + " iterations is: " + stoper.executionDuration * 10/loops); 

} 
private static void howLongDoesItTakeToSetValueToAVariable(int loops) { 
    int value = 0; 
    stoper.start(); 
    for (int i = 0; i < loops; i++) { 
     value = 2; 
    } 
    stoper.stop(); 
    System.out.println("The average duration of 10 cycles of setting a variable to a constant over " + loops + " iterations is: " + stoper.executionDuration * 10/loops); 
} 
private static void howLongDoesItTakeToDefineAVariable(int loops) { 
    stoper.start(); 
    for (int i = 0; i < loops; i++) { 
     int value = 0; 
    } 
    stoper.stop(); 
    System.out.println("The average duration of 10 cycles of initializing and setting a variable to a constant over " + loops + " iterations is: " + stoper.executionDuration * 10/loops); 

} 

private static void runAForLoopOnAnArrayOfObjects() { 
// TODO Auto-generated method stub 

}}

你可以得到你，如果你减少其他的一个时间有多长......（如果你明白我的意思）

希望这节省您的时间。

你需要明白的是我测试了这些东西来优化我的平台的绘制更新循环，并且它有所帮助。亚当。

来源

2010-05-25 02:30:41 TacB0sS

java的循环 - 一类的声明外/内循环

回答

相关问题