Java的方式是，您应该考虑哪种数据抽象最适合您的需求。记住，在Java中，List是抽象的数据类型，而不是具体的数据类型。您应该将字符串声明为List，然后使用ArrayList实现初始化它。

List<String> strings = new ArrayList<String>();

抽象数据类型和特定实现的分离是面向对象编程的一个关键方面。

An ArrayList implements the List Abstract Data Type using an array as its underlying implementation. Access speed is virtually identical to an array, with the additional advantages of being able to add and subtract elements to a List (although this is an O(n) operation with an ArrayList) and that if you decide to change the underlying implementation later on you can. For example, if you realize you need synchronized access, you can change the implementation to a Vector without rewriting all your code.

事实上，ArrayList是专门为在大多数情况下替换低级数组构造而设计的。如果Java是今天设计的，那么完全有可能将数组完全排除在外，转而使用数组列表结构。

由于数组将所有数据保存在一个连续的内存块中(与list不同)，使用数组存储数千个字符串会导致问题吗?

In Java, all collections store only references to objects, not the objects themselves. Both arrays and ArrayList will store a few thousand references in a contiguous array, so they are essentially identical. You can consider that a contiguous block of a few thousand 32-bit references will always be readily available on modern hardware. This does not guarantee that you will not run out of memory altogether, of course, just that the contiguous block of memory requirement is not difficult to fufil.

这里给出的许多微基准测试发现，像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)中完成，这也提供了方便地添加、获取和删除数据的方法。更容易使用。

但是始终记住，当数据存储在数组中的索引位置是已知的时，数据的抓取将是快速的。

这可以通过对数组排序很好地实现。因此，这增加了获取数据的时间(即;存储数据+排序数据+寻找数据所在的位置)。因此，这增加了从数组中获取数据的额外延迟，即使它们可能擅长更快地获取数据。

因此，这可以用三元数据结构或三元数据结构来解决。如上所述，树数据结构在搜索数据时非常有效，对特定单词的搜索可以在O(1)量级上完成。当时间紧迫时;如果你必须快速搜索和检索数据，你可以使用三种数据结构。

如果你希望你的内存空间消耗更少，你希望有一个更好的性能，那么使用三元数据结构。这两个都适合存储大量的字符串(例如;比如字典里的单词)。

请记住，ArrayList封装了一个数组，因此与使用原始数组相比没有什么区别(除了在java中使用List更容易)。

选择数组而不是数组列表的唯一有意义的情况是，当你存储基本类型时，比如byte、int等，你需要通过使用基本类型数组获得特定的空间效率。

我写了一个比较数组列表和数组的基准测试。在我的老式笔记本电脑上，遍历5000个元素的数组列表1000次的时间比等效的数组代码慢了大约10毫秒。

所以，如果你什么都不做，只是迭代列表，而且你做了很多，那么也许它值得优化。否则，我会使用列表，因为当你需要优化代码时，它会让你更容易。

注意:我确实注意到，使用for String s: stringsList比使用老式的for循环访问列表要慢50%左右。去图…这是我计时的两个函数;数组和列表由5000个随机(不同的)字符串填充。

private static void readArray(String[] strings) {
    long totalchars = 0;
    for (int j = 0; j < ITERATIONS; j++) {
        totalchars = 0;
        for (int i = 0; i < strings.length; i++) {
            totalchars += strings[i].length();

        }
    }
}

private static void readArrayList(List<String> stringsList) {
    long totalchars = 0;
    for (int j = 0; j < ITERATIONS; j++) {
        totalchars = 0;
        for (int i = 0; i < stringsList.size(); i++) {
            totalchars += stringsList.get(i).length();
        }
    }
}

数组列表在内部使用数组对象来添加(或存储)对象 元素。换句话说，ArrayList由Array数据支持 结构。ArrayList的数组是可调整大小的(或动态的)。

Array比ArrayList快，因为ArrayList内部使用数组。如果我们可以直接在数组中添加元素，而间接地在数组中添加元素 数组通过数组列表总是直接机制比间接机制快。

在ArrayList类中有两个重载的add()方法:

add(Object):将一个对象添加到列表末尾。 add(int index, Object):将指定对象插入到列表的指定位置。

数组列表的大小如何动态增长?

public boolean add(E e)        
{       
     ensureCapacity(size+1);
     elementData[size++] = e;         
     return true;
}

An important point to note from the above code is that we are checking the capacity of the ArrayList, before adding the element. ensureCapacity() determines what is the current size of occupied elements and what is the maximum size of the array. If the size of the filled elements (including the new element to be added to the ArrayList class) is greater than the maximum size of the array then increase the size of the array. But the size of the array can not be increased dynamically. So what happens internally is new Array is created with the capacity

到 Java 6

int newCapacity = (oldCapacity * 3)/2 + 1;

(更新)来自Java 7

 int newCapacity = oldCapacity + (oldCapacity >> 1);

此外，旧数组中的数据被复制到新数组中。

数组列表中有开销方法这就是为什么数组比数组列表快。