Java内存分配

Question

我有一个一直在思考的问题。以这个特殊的类为例

class A{

private static ArrayList<String> listOne;

public Static ArrayList<String> getList()
  {
    return this.listOne
  }
}  

假设我有一个B类，它拥有一个使用listOne读取详细信息的方法。要查看数组列表，我需要首先获取列表的大小，以便我的代码知道数组列表何时结束。有两种方法可以做到这一点，一种是

int listSize = A.getList().size()
for(int count =0; count < listSize; count++)
{
  // code to read through arraylist
}

或者我也可以用

for(int count=0; count < A.getList().size(); count++)
{
  // code to read through arraylist
}

在内存和效率方面，哪种方法更好？此外，假设我正在递归地读取一个非常大的数组。为了简单起见，让我们假设递归读取此数组将导致堆栈溢出异常。在这种情况下，第一个方法在理论上会导致堆栈溢出发生的时间早于第二个方法，因为每个递归调用的堆栈帧都必须保持变量“listSize”的状态吗？

Answer 1

关于哪种方法更有效，我认为它们不会有任何明显的差异。正如Germann所说，根据JVM的不同，编译器甚至会对此进行优化。所以不要担心这种微不足道的差异。

我个人将使用第二种方法，因为它的代码行较少，而且我很懒。。。

但是，为什么两者都不用呢？

有一个超级酷的选择，它的名字是。。。

让我们将其与正常的for循环进行比较：

正常：

for (int i = 0 ; i < A.getList().size() ; i++ {

}

增强型：

for (String item : A.getList()) {
    // Instead of using A.getList().get(i) to access the items, just use "item"!
}

看这多好啊！

这两个for循环之间的主要区别是

• 正常的for循环只是一种带有初始化和增量的time循环。
• 增强的for循环调用. iterator（）. hasNext（）和. iterator（）. Next（）循环。
• 您需要知道列表的大小才能使用法线for循环
• 您的列表只需要实现Iterable和可能的Iterator即可使用增强的for循环。不需要大小。

增强的for循环有以下限制：

• 您不能同时遍历两个数组
• 如果您想知道列表的索引，最好使用普通的for循环，因为多次调用indexOf不是很有效。

Answer 2

两个循环相同。第二个是更好的编码，因为它减少了代码行。既然您提到需要遍历列表，那么最好使用增强的（for each）for循环。

Java中增强的循环和迭代器的优势是什么？

为什么增强for loop比普通for loop效率高

Answer 3

查看javap-verbose的结果：

 0: invokestatic  #2                  // Method A.getList:()Ljava/util/ArrayList;
 3: invokevirtual #3                  // Method java/util/ArrayList.size:()I
 6: istore_1
 7: iconst_0
 8: istore_2
 9: iload_2
10: iload_1
11: if_icmpge     27
14: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
17: iload_2
18: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V
21: iinc          2, 1
24: goto          9
27: iconst_0
28: istore_2
29: iload_2
30: invokestatic  #2                  // Method A.getList:()Ljava/util/ArrayList;
33: invokevirtual #3                  // Method java/util/ArrayList.size:()I
36: if_icmpge     52
39: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
42: iload_2
43: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V
46: iinc          2, 1
49: goto          29
52: return

第一种情况是：

 9: iload_2
10: iload_1
11: if_icmpge     27
14: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
17: iload_2
18: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V
21: iinc          2, 1
24: goto          9

第二个：

29: iload_2
30: invokestatic  #2                  // Method A.getList:()Ljava/util/ArrayList;
33: invokevirtual #3                  // Method java/util/ArrayList.size:()I
36: if_icmpge     52
39: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
42: iload_2
43: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V
46: iinc          2, 1
49: goto          29

如您所见，它将在每次循环迭代期间获取列表及其大小。但是，这可能会被JIT优化，因此仅从编译的字节码来看结果并不明显。

创建自：

import java.io.*;
import java.util.*;

public class Z {

    public static void main(String[] args) throws Exception {
        int listSize = A.getList().size();
        for(int count =0; count < listSize; count++) {
            System.out.println(count);
        }
        for(int count =0; count < A.getList().size(); count++) {
            System.out.println(count);
        }
    }

}

class A{

    private static ArrayList<String> listOne = new ArrayList<>(Arrays.asList("1", "2", "3"));

    public static ArrayList<String> getList()
    {
        return listOne;
    }
}