Array vs. List Performance in Java

[latexpage]

1. Introduction

In Java programming language, arrays and lists are two primary data structures to store a collection of elements.

Both arrays and lists have advantages and disadvantages, and choosing the appropriate data structure depends on the specific requirements of our use case.

In this tutorial, we’ll examine the performance differences between arrays and lists in Java and provide test examples to compare their efficiency using the Java Microbenchmark Harness (JMH).

2. Performance of Creating New Objects

Let’s compare the performance of creating arrays and ArrayList using a simple Java example:

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

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

The following table shows the time taken to create the array and the ArrayList in nanoseconds:

The results show that the average time to create an array (202.909 ns/op) is much faster than the average time to create an ArrayList (231.565 ns/op).

3. Performance of Adding Items

Let’s compare the performance of adding items in an array and an 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;
}

The following table shows the time taken to set a value for an item in the array and the ArrayList in nanoseconds:

The benchmark results show that the average time it takes to set an item in an array is (2587.040 ns/op), which is slower than the average time it takes to create an ArrayList (2269.738 ns/op).

4. Performance of Getting Items

Let’s compare the performance of getting values of items from an array and an 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);
    }
}

The following table shows the time taken to retrieve items from the array and the ArrayList in nanoseconds:

The array has a quicker item retrieval time of (163.559 ns/op). In comparison, the ArrayList‘s item retrieval time is longer at (261.106 ns/op) due to additional checks performed on the backing array.

Please note that this benchmark ran with Open JDK 17.0.2.

5. Performance of Cloning

Let’s compare the performance of cloning/copying an array and an 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);
}

The following table displays the time taken to clone/copy the array and the ArrayList in nanoseconds:

Array cloning is much faster than ArrayList because array creation is a simpler operation that involves allocating a contiguous block of memory. In contrast, ArrayList creation involves additional overhead, such as initializing internal data structures and dynamically resizing the list as elements are added.

Let’s remember that actual performance can vary depending on various factors, such as the size of the collection, the hardware on which the code is executed, and the Java version you use.

6. Conclusion

In conclusion, this article compares the performance of arrays and lists in Java. However, it’s important to note that actual performance can vary based on collection size and hardware.

The full example code is available on GitHub.