我来这里是为了更好地感受使用列表而不是数组对性能的影响。我不得不为我的场景调整代码:数组/列表的~1000个整型，主要使用getter，即数组[j] vs. list.get(j)

从7个中选择最好的并不科学(前几个列表的速度慢2.5倍)，我得到了这样的结果:

array Integer[] best 643ms iterator
ArrayList<Integer> best 1014ms iterator

array Integer[] best 635ms getter
ArrayList<Integer> best 891ms getter (strange though)

用数组大约快30%

现在发表文章的第二个原因是，没有人会提到使用嵌套循环编写数学/矩阵/模拟/优化代码的影响。

假设你有三个嵌套层，而内部循环的速度是原来的两倍，那么你的性能就会下降8倍。一天就能完成的事情现在需要一个星期。

*编辑 这里非常震惊，我试图声明int[1000]而不是Integer[1000]

array int[] best 299ms iterator
array int[] best 296ms getter

使用Integer[] vs. int[]表示双倍的性能打击，带有迭代器的ListArray比int[]慢3倍。真的认为Java的列表实现类似于本机数组…

参考代码(多次调用):

    public static void testArray()
    {
        final long MAX_ITERATIONS = 1000000;
        final int MAX_LENGTH = 1000;

        Random r = new Random();

        //Integer[] array = new Integer[MAX_LENGTH];
        int[] array = new int[MAX_LENGTH];

        List<Integer> list = new ArrayList<Integer>()
        {{
            for (int i = 0; i < MAX_LENGTH; ++i)
            {
                int val = r.nextInt();
                add(val);
                array[i] = val;
            }
        }};

        long start = System.currentTimeMillis();
        int test_sum = 0;
        for (int i = 0; i < MAX_ITERATIONS; ++i)
        {
//          for (int e : array)
//          for (int e : list)          
            for (int j = 0; j < MAX_LENGTH; ++j)
            {
                int e = array[j];
//              int e = list.get(j);
                test_sum += e;
            }
        }

        long stop = System.currentTimeMillis();

        long ms = (stop - start);
        System.out.println("Time: " + ms);
    }

这取决于实现。基元类型数组可能比ArrayList更小更高效。这是因为数组将直接将值存储在一个连续的内存块中，而最简单的ArrayList实现将存储指向每个值的指针。特别是在64位平台上，这可能会产生巨大的差异。

当然，对于这种情况，jvm实现有可能有一个特殊情况，在这种情况下，性能将是相同的。

这里给出的许多微基准测试发现，像array/ArrayList读取这样的事情需要几纳秒。如果所有内容都在L1缓存中，这是非常合理的。

更高级别的缓存或主存访问的数量级可能是10nS-100nS，而L1缓存的数量级更接近1nS。访问ArrayList有一个额外的内存间接，在实际的应用程序中，你可以几乎从不或每次都支付这个代价，这取决于你的代码在访问之间所做的事情。当然，如果你有很多小的数组列表，这可能会增加你的内存使用，使你更有可能缓存丢失。

原来的海报似乎只使用一个，在短时间内访问了很多内容，所以应该没有太大的困难。但是对于其他人来说可能有所不同，在解释微基准测试时应该注意。

Java Strings, however, are appallingly wasteful, especially if you store lots of small ones (just look at them with a memory analyzer, it seems to be > 60 bytes for a string of a few characters). An array of strings has an indirection to the String object, and another from the String object to a char[] which contains the string itself. If anything's going to blow your L1 cache it's this, combined with thousands or tens of thousands of Strings. So, if you're serious - really serious - about scraping out as much performance as possible then you could look at doing it differently. You could, say, hold two arrays, a char[] with all the strings in it, one after another, and an int[] with offsets to the starts. This will be a PITA to do anything with, and you almost certainly don't need it. And if you do, you've chosen the wrong language.

这取决于你如何访问它。

存储后，如果你主要想做搜索操作，很少或不需要插入/删除，那么就去数组(因为在数组中搜索是在O(1)中完成的，而添加/删除可能需要重新排序元素)。

存储之后，如果你的主要目的是添加/删除字符串，很少或没有搜索操作，那么就去List。

如果你有几千个，考虑使用trie。trie是一种树状结构，它合并了存储字符串的公共前缀。

例如，如果字符串是

intern
international
internationalize
internet
internets

该树将存储:

intern
 -> \0
 international
 -> \0
 -> ize\0
 net
 ->\0
 ->s\0

字符串需要57个字符(包括空结束符'\0')来存储，再加上存储它们的String对象的大小。(事实上，我们可能应该四舍五入到16的倍数，但是……)粗略地称它为57 + 5 = 62字节。

这个trie需要29个存储空间(包括空结束符'\0')，加上对trie节点的sizeof，这些节点是一个数组的引用和一列子trie节点。

在这个例子中，结果可能是一样的;对于成千上万的人来说，只要你有共同的前缀，它可能会更少。

现在，在其他代码中使用trie时，必须转换为String，可能使用StringBuffer作为中介。如果在trie之外，同时使用了许多字符串作为字符串，这是一种损失。

但如果你一次只使用几个——比如，在字典中查找东西——trie可以为你节省很多空间。绝对比存储在HashSet中的空间要小。

你说你是“连续地”访问它们——如果这意味着按字母顺序访问，如果你深度优先迭代，trie显然也会免费给你字母顺序。

如果提前知道数据有多大，那么使用数组会更快。

List更加灵活。你可以使用由数组支持的数组列表。