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

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

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

一般的结论

虽然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在性能方面没有实质性的差异)。

我不认为这对Strings有什么影响。字符串数组中连续的是对字符串的引用，字符串本身存储在内存中的随机位置。

数组与列表的区别在于基本类型，而不是对象。如果您预先知道元素的数量，并且不需要灵活性，那么由数百万个整数或双精度数组成的数组将比列表在内存和速度上更有效，因为它们确实是连续存储的，并且可以立即访问。这就是为什么Java仍然使用字符数组表示字符串，使用整数数组表示图像数据，等等。

我写了一个比较数组列表和数组的基准测试。在我的老式笔记本电脑上，遍历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);

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

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

更新:

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

如果你可以使用固定的大小，数组将会更快，需要更少的内存。

如果您需要List接口在添加和删除元素方面的灵活性，那么问题仍然是应该选择哪种实现。通常在任何情况下都推荐使用ArrayList，但如果必须删除或插入列表开头或中间的元素，ArrayList也有其性能问题。

因此，您可能想要看看https://dzone.com/articles/gaplist-lightning-fast-list，它介绍了GapList。这个新的列表实现结合了ArrayList和LinkedList的优点，使得几乎所有的操作都有很好的性能。请登录https://github.com/magicwerk/brownies-collections获取。