Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

[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:

Benchmark Mode Cnt Time Error Units
Array – Creation avgt 5 202.909 2.135 ns/op
List – Creation avgt 5 231.565 103.332 ns/op

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:

Benchmark Mode Cnt Time Error Units
Array – Addition avgt 5 2587.040 671.391 ns/op
List – Addition avgt 5 2269.738 906.403 ns/op

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:

Benchmark Mode Cnt Time Error Units
Array – Fetch avgt 5 163.559 13.503 ns/op
List – Fetch avgt 5 261.106 5.371 ns/op

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:

Benchmark Mode Cnt Time Error Units
Array – Clone avgt 5 204.608 5.270 ns/op
List – Clone avgt 5 232.177 80.040 ns/op

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 code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

2 Comments
Oldest
Newest