相关疑难解决方法(0)

如果有的话,以下两个循环之间的性能差异是什么？

for (Object o: objectArrayList) {
    o.DoSomething();
}

和

for (int i=0; i<objectArrayList.size(); i++) {
    objectArrayList.get(i).DoSomething();
}

如果你不得不循环7次循环,你会使用:

for (int i = 0; i < 7; i++)

要么:

for (int i = 0; i <= 6; i++)

有两个注意事项:

• 性能
• 可读性

为了性能,我假设Java或C#.使用"小于"或"小于或等于"是否重要？如果您对其他语言有所了解,请说明哪些语言.

为了便于阅读,我假设基于0的数组.

UPD:我提到的基于0的数组可能会让人感到困惑.我不是在讨论迭代数组元素.只是一个循环.

关于使用常数可以解释这个神奇数字是什么,下面有一个好点.所以,如果我有" int NUMBER_OF_THINGS = 7"然后" i <= NUMBER_OF_THINGS - 1"看起来很奇怪,不会.

(对于那些熟悉JVM编译和优化技巧的人来说一个问题...... :-)

是否有任何"for"和"foreach"模式明显优于其他模式？

考虑以下两个例子:

public void forLoop(String[] text)
{
    if (text != null)
    {
        for (int i=0; i<text.length; i++)
        {
            // Do something with text[i]
        }
    }
}

public void foreachLoop(String[] text)
{
    if (text != null)
    {
        for (String s : text)
        {
            // Do something with s, exactly as with text[i]
        }
    }
}

是forLoop快还是慢foreachLoop？

假设在这两种情况下text阵列都不需要进行任何健全性检查,是否有明显的赢家或仍然太接近无法拨打电话？

编辑:正如在一些答案中所指出的,对于数组,性能应该是相同的,而对于像List这样的抽象数据类型,"foreach"模式可能略微更好.另请参阅讨论该主题的答案.

我想向更多有经验的开发人员询问一个简单但对我来说不明显的事情.假设您有这样的代码(Java):

for(int i=0; i<vector.size(); i++){
   //make some stuff here
}

我经常遇到这样的陈述,所以也许没有任何错误.但对我来说,似乎没有必要在每次迭代中调用一个size方法.我会用这样的方法:

int vectorSize = vector.size();
for(int i=0; i<vectorSize; i++){
    //make some stuff here
}

同样的事情在这里:

for(int i=0; i<myTreeNode.getChildren().size(); i++){
   //make some stuff here
}

我绝对不是编程方面的专家,所以我的问题是:我是否寻求在对冲完整或者在专业代码中处理这些细节很重要的差距？

我正在编写一个游戏引擎,其中ArrayList使用for循环迭代a 中保存的一组对象.显然,效率是相当重要的,所以我想知道循环的效率.

for (String extension : assetLoader.getSupportedExtensions()) {
    // do stuff with the extension here
}

当getSupportedExtension()返回ArrayList的String秒.我想知道的是,每次循环遍历新扩展时是否调用该方法.如果是这样,做以下事情会更有效率:

ArrayList<String> supportedExtensions = ((IAssetLoader<?>) loader).getSupportedExtensions();

for (String extension : supportedExtensions) {
    // stuff
}

？提前致谢.

我一般写

for (int i = 0, n = someMethod(); i < n; i++)

优先于

for (int i = 0; i < someMethod(); i++)

避免someMethod() 重复计算.但是我不确定我什么时候需要这样做.Java在识别每次都会给出相同结果的方法时有多聪明,只需要在循环开始时执行一次？

在编写循环时,我经常会对应该选择哪一个感到困惑.例如,

int sum;
for(int i=0; i<10; i++)
{
   sum=0;
   ...
   ....
}

要么

for(int i=0; i<10; i++)
{
   int sum=0;
   ...
   ....
}

比如,变量仅在此循环中需要.在程序的后期部分不需要它.我需要在循环开始时变量sum的值为0.哪一个更好的做法？在循环开始时重新初始化变量或重新声明它？哪一个更有效率？

可能重复:
for循环优化

在java中我有一段代码:

List e = {element1, element2, ...., elementn};
for(int i = 0; i < e.size(); i++){//Do something in here
};

和另一个块:

List e = {element1, element2, ...., elementn};
int listSize = e.size();
for(int i = 0; i < listSize; i++){//Do something in here
};

我认为第二个块更好,因为在第一个块中,如果i++,我们必须再计算e.size()一次以比较for循环中的条件.是对还是错？比较上面的两个块,写作的最佳做​​法是什么？为什么？解释清楚并亲自尝试这个循环

可能重复:
for循环优化

假设我们想循环遍历字符串的字符s.我会说以下代码或多或少是默认代码.

for( int i = 0; i < s.length(); i++ ) {
    doSomethingWith( s.charAt( i ) );
}

问题1:为什么我经常看到以下内容？

final int length = s.length();
for( int i = 0; i < length; i++ ) {
    doSomethingWith( s.charAt( i ) );
}

乍一看,这似乎是合理的,因为在每次迭代时都会评估不等式.但是我希望VM能够优化它,因为字符串是不可变的.有什么想法吗？如果我们迭代一个可变结构(没有被任何其他线程引用)会怎样？如果length()不能保证在O(1)中运行怎么办？

问题2:有些人认为代++i的i++速度可达代码.他们是对的吗？这不是我所期望的,但我只是不确定.

我们都知道不要过早优化.与此同时,如果我们几乎不用任何代价就可以生成稍微快一点的代码,那么我们就不会傻了.当然,人们可能会争辩说,两种"优化"都会损害可读性,但在我看来,损害是如此之小,以至于在某些情况下这种损害是合理的.

我试图衡量性能上的任何差异,但很难得出确凿的结果.虽然这应该适用于任何特定的应用程序,但我的目标是洞察力和一般答案.

(虽然我在考虑HotSpot VM的情况下编写了这个内容,但考虑其他平台,如移动设备也会很有趣.)