数组-当我们必须实现更快的结果获取时，它总是更好的

列表——执行插入和删除的结果，因为它们可以在O(1)中完成，这也提供了方便地添加、获取和删除数据的方法。更容易使用。

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

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

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

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

既然这里已经有了很多好的答案，我想给你一些其他的实际观点的信息，这是插入和迭代性能的比较:Java中的基元数组与链表。

这是实际的简单性能检查。因此，结果将取决于机器的性能。

用于此的源代码如下:

import java.util.Iterator;
import java.util.LinkedList;

public class Array_vs_LinkedList {

    private final static int MAX_SIZE = 40000000;

    public static void main(String[] args) {

        LinkedList lList = new LinkedList(); 

        /* insertion performance check */

        long startTime = System.currentTimeMillis();

        for (int i=0; i<MAX_SIZE; i++) {
            lList.add(i);
        }

        long stopTime = System.currentTimeMillis();
        long elapsedTime = stopTime - startTime;
        System.out.println("[Insert]LinkedList insert operation with " + MAX_SIZE + " number of integer elapsed time is " + elapsedTime + " millisecond.");

        int[] arr = new int[MAX_SIZE];

        startTime = System.currentTimeMillis();
        for(int i=0; i<MAX_SIZE; i++){
            arr[i] = i; 
        }

        stopTime = System.currentTimeMillis();
        elapsedTime = stopTime - startTime;
        System.out.println("[Insert]Array Insert operation with " + MAX_SIZE + " number of integer elapsed time is " + elapsedTime + " millisecond.");


        /* iteration performance check */

        startTime = System.currentTimeMillis();

        Iterator itr = lList.iterator();

        while(itr.hasNext()) {
            itr.next();
            // System.out.println("Linked list running : " + itr.next());
        }

        stopTime = System.currentTimeMillis();
        elapsedTime = stopTime - startTime;
        System.out.println("[Loop]LinkedList iteration with " + MAX_SIZE + " number of integer elapsed time is " + elapsedTime + " millisecond.");


        startTime = System.currentTimeMillis();

        int t = 0;
        for (int i=0; i < MAX_SIZE; i++) {
            t = arr[i];
            // System.out.println("array running : " + i);
        }

        stopTime = System.currentTimeMillis();
        elapsedTime = stopTime - startTime;
        System.out.println("[Loop]Array iteration with " + MAX_SIZE + " number of integer elapsed time is " + elapsedTime + " millisecond.");
    }
}

表现结果如下:

数组-当我们必须实现更快的结果获取时，它总是更好的

列表——执行插入和删除的结果，因为它们可以在O(1)中完成，这也提供了方便地添加、获取和删除数据的方法。更容易使用。

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

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

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

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

更新:

正如Mark所指出的那样，在JVM预热之后(几次测试通过)没有明显的差异。检查与重新创建的数组，甚至新传递开始的新行矩阵。有很大的可能性，这表明简单数组的索引访问不用于有利于集合。

前1-2次简单数组还是快2-3倍。

原来的帖子:

对这个主题来说，太多的词太简单了。毫无疑问，数组比任何类容器都快几倍。我在这个问题上为我的性能关键部分寻找替代方案。下面是我为检查实际情况而构建的原型代码:

import java.util.List;
import java.util.Arrays;

public class IterationTest {

    private static final long MAX_ITERATIONS = 1000000000;

    public static void main(String [] args) {

        Integer [] array = {1, 5, 3, 5};
        List<Integer> list = Arrays.asList(array);

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

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

这就是答案:

基于数组(第16行是活动的):

Time: 7064

根据列表(第17行是活动的):

Time: 20950

还有关于“更快”的评论吗?这是可以理解的。问题是什么时候大约3倍的速度比List的灵活性更好。但这是另一个问题。 顺便说一下，我也根据手工构造的数组列表检查了这个。几乎是一样的结果。

您应该更喜欢泛型类型而不是数组。正如其他人所提到的，数组是不灵活的，不具有泛型类型的表达能力。(它们确实支持运行时类型检查，但这与泛型类型混在一起很糟糕。)

但是，与往常一样，在优化时，你应该始终遵循以下步骤:

Don't optimize until you have a nice, clean, and working version of your code. Changing to generic types could very well be motivated at this step already. When you have a version that is nice and clean, decide if it is fast enough. If it isn't fast enough, measure its performance. This step is important for two reasons. If you don't measure you won't (1) know the impact of any optimizations you make and (2) know where to optimize. Optimize the hottest part of your code. Measure again. This is just as important as measuring before. If the optimization didn't improve things, revert it. Remember, the code without the optimization was clean, nice, and working.

如果你有几千个，考虑使用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显然也会免费给你字母顺序。