更新:

正如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的灵活性更好。但这是另一个问题。 顺便说一下，我也根据手工构造的数组列表检查了这个。几乎是一样的结果。

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

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

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

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

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

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

使用哪一种取决于问题本身。我们得看看大O。

图片来源:https://github.com/egonSchiele/grokking_algorithms

虽然建议使用数组列表的答案在大多数情况下是有意义的，但相对性能的实际问题还没有真正得到答案。

你可以用数组做以下几件事:

创建它 设置一个项目 买一件物品 克隆/复制它

一般的结论

虽然get和set操作在数组列表(resp。在我的机器上每次调用1和3纳秒)，对于任何非密集的用途，使用ArrayList相对于数组的开销非常小。然而，有几件事要记住:

在列表上调整大小操作(当调用list.add(…)时)代价很高，应该尽可能将初始容量设置为适当的级别(注意，在使用数组时也会出现同样的问题) 在处理原语时，数组可以明显更快，因为它们可以避免许多装箱/拆箱转换 一个只在数组列表中获取/设置值的应用程序(不是很常见!)通过切换到数组可以看到超过25%的性能增益

详细的结果

下面是我在标准x86桌面机器上使用JDK 7使用jmh基准测试库(以纳秒为单位)测量这三个操作的结果。请注意，ArrayList在测试中从不调整大小，以确保结果具有可比性。这里有基准代码。

数组/ ArrayList创造

我运行了4个测试，执行以下语句:

createArray1: Integer[] array = new Integer[1]; createList1: List<Integer> List = new ArrayList<> (1); createArray10000: Integer[] array = new Integer[10000]; createList10000: List<Integer> List = new ArrayList<> (10000);

结果(以纳秒为单位，95%置信度):

a.p.g.a.ArrayVsList.CreateArray1         [10.933, 11.097]
a.p.g.a.ArrayVsList.CreateList1          [10.799, 11.046]
a.p.g.a.ArrayVsList.CreateArray10000    [394.899, 404.034]
a.p.g.a.ArrayVsList.CreateList10000     [396.706, 401.266]

结论:无明显差异。

get操作

我运行了2个测试，执行以下语句:

返回list.get(0); 返回数组[0];

结果(以纳秒为单位，95%置信度):

a.p.g.a.ArrayVsList.getArray   [2.958, 2.984]
a.p.g.a.ArrayVsList.getList    [3.841, 3.874]

结论:从数组中获取信息比从ArrayList中获取信息快25%，尽管差异仅在1纳秒的量级上。

集合操作

我运行了2个测试，执行以下语句:

setList:列表。设置(0,价值); setArray:数组[0]=值;

结果(以纳秒为单位):

a.p.g.a.ArrayVsList.setArray   [4.201, 4.236]
a.p.g.a.ArrayVsList.setList    [6.783, 6.877]

结论:在数组上的set操作比在列表上快40%左右，但是，对于get，每个set操作需要几纳秒——所以为了达到1秒的差异，需要在列表/数组中设置项数亿次!

无性系/ copy

ArrayList的复制构造函数委托给数组。因此，性能与数组复制相同(通过克隆复制数组，数组。copyOf或System。arrayCopy在性能方面没有实质性的差异)。

我建议您使用分析器来测试哪个更快。

我个人的观点是你应该使用列表。

我在一个大型代码库中工作，之前的一组开发人员在任何地方都使用数组。这使得代码非常不灵活。在将大块数据转换为列表后，我们发现速度没有变化。

更新:

正如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的灵活性更好。但这是另一个问题。 顺便说一下，我也根据手工构造的数组列表检查了这个。几乎是一样的结果。