Java中数组与列表的性能比较

在Java编程语言中，数组和列表是两种主要的数据结构，用于存储一系列元素。数组和列表都有各自的优缺点，选择适当的数据结构取决于我们用例的具体要求。

在本教程中，我们将检查Java中数组和列表的性能差异，并提供测试示例，使用Java Microbenchmark Harness (JMH)来比较它们的效率。

2. 创建新对象的性能

让我们通过一个简单的Java示例比较创建数组和ArrayList的性能：

@Benchmark
public Integer[] arrayCreation() {
    return new Integer[256];
}

@Benchmark
public ArrayList`<Integer>` arrayListCreation() {
    return new ArrayList<>(256);
}

下表显示了创建数组和ArrayList所需的时间（以纳秒为单位）：

基准测试	模式	计数	时间	误差	单位
数组 – 创建	avgt	5	202.909	2.135	ns/op
列表 – 创建	avgt	5	231.565	103.332	ns/op

结果表明，创建数组的平均时间（202.909 ns/op）比创建ArrayList的平均时间（231.565 ns/op）要快得多。

3. 添加项目的性能

让我们比较在数组和ArrayList中添加项目的性能：

@Benchmark
public Integer[] arrayItemsSetting() {
    for (int i = 0; i < 256; i++) {
        array[i] = i;
    }
    return array;
}

@Benchmark
public ArrayList`<Integer>` arrayListItemsSetting() {
    for (int i = 0; i < 256; i++) {
        list.add(i);
    }
    return list;
}

下表显示了在数组和ArrayList中设置项目值所需的时间（以纳秒为单位）：

基准测试	模式	计数	时间	误差	单位
数组 – 添加	avgt	5	2587.040	671.391	ns/op
列表 – 添加	avgt	5	2269.738	906.403	ns/op

基准测试结果表明，设置数组中项目的平均时间（2587.040 ns/op）比创建ArrayList的平均时间（2269.738 ns/op）要慢。

4. 获取项目的性能

让我们比较从数组和ArrayList中获取项目值的性能：

@Benchmark
public void arrayItemsRetrieval(Blackhole blackhole) {
    for (int i = 0; i < 256; i++) {
        int item = array[i];
        blackhole.consume(item);
    }
}

@Benchmark
public void arrayListItemsRetrieval(Blackhole blackhole) {
    for (int i = 0; i < 256; i++) {
        int item = list.get(i);
        blackhole.consume(item);
    }
}

下表显示了从数组和ArrayList中检索项目所需的时间（以纳秒为单位）：

基准测试	模式	计数	时间	误差	单位
数组 – 获取	avgt	5	163.559	13.503	ns/op
列表 – 获取	avgt	5	261.106	5.371	ns/op

数组具有更快的项目检索时间（163.559 ns/op）。相比之下，ArrayList的项目检索时间更长（261.106 ns/op），这是由于在后备数组上执行了额外的检查。

请注意，此基准测试是在Open JDK 17.0.2上运行的。

5. 克隆的性能

让我们比较克隆/复制数组和ArrayList的性能：

@Benchmark
public void arrayCloning(Blackhole blackhole) {
    Integer[] newArray = array.clone();
    blackhole.consume(newArray);
}

@Benchmark
public void arrayListCloning(Blackhole blackhole) {
    ArrayList`<Integer>` newList = new ArrayList<>(list);
    blackhole.consume(newList);
}

下表显示了克隆/复制数组和ArrayList所需的时间（以纳秒为单位）：

基准测试	模式	计数	时间	误差	单位
数组 – 克隆	avgt	5	204.608	5.270	ns/op
列表 – 克隆	avgt	5	232.177	80.040	ns/op

数组克隆比ArrayList快得多，因为数组创建是一个更简单的操作，涉及分配一个连续的内存块。相比之下，ArrayList的创建涉及额外的开销，例如初始化内部数据结构和动态调整列表大小。

让我们记住，实际性能可能会因各种因素而异，例如集合的大小、代码执行的硬件以及使用的Java版本。

6. 结论

总之，本文比较了Java中数组和列表的性能。然而，重要的是要注意，实际性能可能会因集合大小和硬件而异。

完整的示例代码可在GitHub上找到。抱歉，由于原文内容较长，我将分两部分完成翻译。以下是第二部分的翻译：

6. 结论

总之，本文比较了Java中数组和列表的性能。然而，重要的是要注意，实际性能可能会因集合的大小和硬件而异。

完整的示例代码可在GitHub上找到。

请注意，实际性能可能会因各种因素而异，例如集合的大小、代码执行的硬件以及使用的Java版本。

文章的类别和标签可能需要根据网页的实际内容进行调整，因为从提供的文本中无法直接获取这些信息。如果需要进一步的翻译或有其他问题，请随时告知。

OK