3

作为这个问题的附录Java 循环效率（“for”与“foreach”）

我有一个简单的问题。增强的 for 循环是否具有更大的内存占用，或者它们会编译成相同的结构，使它们的内存占用相同，从而for(Object o : collection) { ... }总是更好地进行只读操作？

我问的原因是，在我正在处理的模拟器中，每帧（60/秒）我都在对数组中可能有数千个项目运行操作，例如要绘制的面、要进行光线跟踪等。循环

for(Object o : collection) {
   o.doSomething(); 
}

看起来它可以制作集合的内存副本（我似乎记得我之前的阅读中确实如此）这在大多数情况下是可以的，但如果你每秒执行 30000 次光线跟踪乘以 60 次则不行。

另一方面，很明显循环

count = collection.size();
for(i = 0; i < count; i++) {
   collection[i].doSomething();
}

通过参考做所有事情，并且占用空间相对较小，即使它更难阅读（虽然老实说，不多）

有什么想法吗，伙计们？

（注意：阅读 for 循环的难度的影响仅在您进入多层时才明显 - 对于单层 fors 增益非常小。我从经验中这么说......collection[i].property.subcollection[j].row[k].col[l].prop.subtable[m]变得令人心碎，特别是如果一些其中需要演员：((Type3)((Type2)((Type1)collection[i]).property.subcollection[j].row[k]).col[l].prop).subtable[m]例如。）

4

2 回答 2

2

如果您有一个使用 hte 的 ArrayList，则以下模式可以是一个微优化

for(int i=0, len=list.size(); i < len; i++)

您节省的内存大约为 16-24 字节，因为 for-each 循环将始终创建一个迭代器。

（60/秒）我正在对数组中可能有数千个项目运行操作，例如要绘制的面部，要针对光线追踪，

对于每秒 60,000 次，您不太可能注意到差异，尤其是因为您正在对每个项目进行相对重要的工作。

看起来它可能会制作集合的内存副本

如果在循环遍历列表时更改列表，这不是为什么会得到 ConcurrentModicationException 的原因。一种解决方法是复制一份。

于 2012-09-12T15:37:46.080 回答
1

很难说 JIT 将如何优化您的代码（Java 的哪个实现，哪个操作系统等）。这里的要点是 for-each 语法编译为与使用迭代器语法相同的字节码，请参见此处和此处。使用迭代器语法的主要原因是在迭代期间删除项目。请注意，Iterator接口上的 remove 方法是可选的。

我自己做了一些简单的例子来查看字节码：

对于数组的每次迭代

// compiled .class file is 585 bytes
public class ForEachLoop {
  public static void main(String[] args) {
    for(String s : args){
      System.out.println(s);
    }
  }
}

// byte code for main method
public static void main(java.lang.String[]);
  Code:
   Stack=2, Locals=5, Args_size=1
   0:   aload_0
   1:   dup
   2:   astore  4
   4:   arraylength
   5:   istore_3
   6:   iconst_0
   7:   istore_2
   8:   goto    26
   11:  aload   4
   13:  iload_2
   14:  aaload
   15:  astore_1
   16:  getstatic   #16; //Field java/lang/System.out:Ljava/io/PrintStream;
   19:  aload_1
   20:  invokevirtual   #22; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   23:  iinc    2, 1
   26:  iload_2
   27:  iload_3
   28:  if_icmplt   11
   31:  return
  LineNumberTable: 
   line 4: 0
   line 5: 16
   line 4: 23
   line 7: 31

  LocalVariableTable: 
   Start  Length  Slot  Name   Signature
   0      32      0    args       [Ljava/lang/String;
   16      7      1    s       Ljava/lang/String;

数组索引循环

// compiled .class file is 554 bytes
public class ArrayLoop {
  public static void main(String[] args) {
    for (int i = 0; i < args.length; i++) {
      System.out.println(args[i]);
    }
  }
}

// byte code for main method
public static void main(java.lang.String[]);
  Code:
   Stack=3, Locals=2, Args_size=1
   0:   iconst_0
   1:   istore_1
   2:   goto    17
   5:   getstatic   #16; //Field java/lang/System.out:Ljava/io/PrintStream;
   8:   aload_0
   9:   iload_1
   10:  aaload
   11:  invokevirtual   #22; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   14:  iinc    1, 1
   17:  iload_1
   18:  aload_0
   19:  arraylength
   20:  if_icmplt   5
   23:  return
  LineNumberTable: 
   line 4: 0
   line 5: 5
   line 4: 14
   line 7: 23

  LocalVariableTable: 
   Start  Length  Slot  Name   Signature
   0      24      0    args       [Ljava/lang/String;
   2      21      1    i       I

我们可以看到数组迭代字节码更紧凑（准确地说是 31 个字节）。

于 2012-09-12T15:46:33.240 回答