Java foreach循环是否会创建一个新对象？

Question

每次输入foreach循环时,Java都会创建一个新对象吗？我不是在谈论每次迭代,但是如果你有一个多次使用的foreach循环,它每次都在创建对象吗？

简单示例:

for(Object o : Objects)
{
    for(Object p : Objects2)
    {
    }
}

p每次执行只会有一个,还是会p为每个执行实例化Object o？垃圾收集器每次退出时都必须从foreach循环中恢复一个对象吗？

更具体地说,我正在编写一些基于Android的游戏代码.它将以每秒给定的速率迭代所有游戏对象,或者根据具体情况尽可能快地迭代.

这可能是一个过早优化的情况,但如果使用显式for或while循环可以保证我不会从我的循环中收集过多的垃圾,那么我可以将其作为项目的编码标准.

进一步来说:

public void update()
{
    for(GameObject gObj : gameObjects)
    {
        gObj.update();
    }
}

随着update()从设计,使基于我之前所描述的时间调用一个线程被调用.

更新: 我问是否有新的基准p为每个创建o在Objects.如果它复制了对象,则不是Objects2.那么VM是否必须创建一个新的Reference p,然后它会在outter循环的迭代之间收集该引用？更具体地说,在我的情况下,它是否收集方法调用之间的引用？

更新: 来自对Matt Ball的回答的评论.哪个会减少垃圾收集工作？

//Loop just to have it run a number of times
//Could be running the inner foreach numerous time for any reason
for(int i = 0; i < 1000; i++)
{
    for(Object o : Objects)
    {
        o.update();
    }
}

与

Iterator<Object> iter;
//Loop just to have it run a number of times
//Could be running the inner foreach numerous time for any reason
for(int i = 0; i < 1000; i++)
{
    iter = Objects.iterator();

    while(iter.hasNext());
    {
        iter.getNext().update();
    }
}

更新: 比较范围:

import java.util.ArrayList;
import java.util.Iterator;


public class TestLoops
{
    public static Iterator<Object> it;
    public static ArrayList<Object> objects;

    public static void main(String... args)
    {
        objects = new ArrayList<Object>();

        it = objects.iterator();
        it = objects.iterator();

            //Every time we start a foreach loop, does it creates a new reference?
        Iterator<Object> newIt1 = objects.iterator();
        Iterator<Object> newIt2 = objects.iterator();       

    }
}

生成这个字节码:

public class TestLoops {
public static java.util.Iterator<java.lang.Object> it;

public static java.util.ArrayList<java.lang.Object> objects;

public TestLoops();

    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String...);
    Code:
       0: new           #2                  // class java/util/ArrayList
       3: dup
       4: invokespecial #3                  // Method java/util/ArrayList."<init>":()V
       7: putstatic     #4                  // Field objects:Ljava/util/ArrayList;
      10: getstatic     #4                  // Field objects:Ljava/util/ArrayList;
      13: invokevirtual #5                  // Method java/util/ArrayList.iterator:()Ljava/util/Iterator;
      16: putstatic     #6                  // Field it:Ljava/util/Iterator;
      19: getstatic     #4                  // Field objects:Ljava/util/ArrayList;
      22: invokevirtual #5                  // Method java/util/ArrayList.iterator:()Ljava/util/Iterator;
      25: putstatic     #6                  // Field it:Ljava/util/Iterator;
      28: getstatic     #4                  // Field objects:Ljava/util/ArrayList;
      31: invokevirtual #5                  // Method java/util/ArrayList.iterator:()Ljava/util/Iterator;
      34: astore_1
      35: getstatic     #4                  // Field objects:Ljava/util/ArrayList;
      38: invokevirtual #5                  // Method java/util/ArrayList.iterator:()Ljava/util/Iterator;
      41: astore_2
      42: return
}

Answer 1

for-each循环没有神奇的对象构造.这个语法:

for(Object o : Objects)
{
    for(Object p : Objects2)
    {
    }
}

这只是简写:

for(Iterator<Object> iter = Objects.iterator(); iter.hasNext();)
{
    Object o = iter.next();
    for(Iterator<Object> iter2 = Objects2.iterator(); iter2.hasNext();)
    {
        Object p = iter2.next();
    }
}

如果会iter2为我所拥有的每个对象创建一个引用Objects？

这取决于Objects2来自哪里.它来自o哪里？它还取决于如何Objects2.iterator()实施.Iterable#iterator()期望返回独立的迭代器,这意味着Objects2.iterator()几乎肯定会Iterator为每次调用返回一个新的迭代器.但是,这并没有说明是否在Objects2(使用iter2)中迭代对象会创建其他新对象.

总的来说,这听起来像是过早的优化.

哪个会减少垃圾收集工作？

都不是.增强的for循环(又名for-each循环)只是语法糖.编译器生成的字节码是相同的.完整的例子:

package com.stackoverflow;

import java.util.Iterator;

public class Question14640184
{
    public void enhancedForLoop(Iterable<Object> objects1, Iterable<Object> objects2)
    {
        for(Object o1 : objects1)
        {
            for(Object o2 : objects2)
            {
                // do something
            }
        }
    }

    public void iteratorForLoop(Iterable<Object> objects1, Iterable<Object> objects2)
    {
        for(Iterator<Object> iter1 = objects1.iterator(); iter1.hasNext();)
        {
            Object o1 = iter1.next();
            for(Iterator<Object> iter2 = objects2.iterator(); iter2.hasNext();)
            {
                Object o2 = iter2.next();
            }
        }
    }
}

编译:

? javac Question14640184.java
? javap -c Question14640184
Compiled from "Question14640184.java"
public class com.stackoverflow.Question14640184 extends java.lang.Object{
public com.stackoverflow.Question14640184();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

public void enhancedForLoop(java.lang.Iterable, java.lang.Iterable);
  Code:
   0:   aload_1
   1:   invokeinterface #2,  1; //InterfaceMethod java/lang/Iterable.iterator:()Ljava/util/Iterator;
   6:   astore_3
   7:   aload_3
   8:   invokeinterface #3,  1; //InterfaceMethod java/util/Iterator.hasNext:()Z
   13:  ifeq    57
   16:  aload_3
   17:  invokeinterface #4,  1; //InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
   22:  astore  4
   24:  aload_2
   25:  invokeinterface #2,  1; //InterfaceMethod java/lang/Iterable.iterator:()Ljava/util/Iterator;
   30:  astore  5
   32:  aload   5
   34:  invokeinterface #3,  1; //InterfaceMethod java/util/Iterator.hasNext:()Z
   39:  ifeq    54
   42:  aload   5
   44:  invokeinterface #4,  1; //InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
   49:  astore  6
   51:  goto    32
   54:  goto    7
   57:  return

public void iteratorForLoop(java.lang.Iterable, java.lang.Iterable);
  Code:
   0:   aload_1
   1:   invokeinterface #2,  1; //InterfaceMethod java/lang/Iterable.iterator:()Ljava/util/Iterator;
   6:   astore_3
   7:   aload_3
   8:   invokeinterface #3,  1; //InterfaceMethod java/util/Iterator.hasNext:()Z
   13:  ifeq    57
   16:  aload_3
   17:  invokeinterface #4,  1; //InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
   22:  astore  4
   24:  aload_2
   25:  invokeinterface #2,  1; //InterfaceMethod java/lang/Iterable.iterator:()Ljava/util/Iterator;
   30:  astore  5
   32:  aload   5
   34:  invokeinterface #3,  1; //InterfaceMethod java/util/Iterator.hasNext:()Z
   39:  

就像我说的那样,for-each循环只是 语法糖.

这是我刚才所关注的事情.

继续,朋友.