Java Array/ArrayList/LinkedList performance

Question

I used the following code to test the performance between Array/ArrayList/LinkedList

import java.util.ArrayList;
import java.util.LinkedList;

public class Main3 {
    public static void main(String[] args) throws Exception{

        int n = 20000000;
        long bt = 0, et = 0;

        int[] a0 = new int[n];
        ArrayList<Integer> a1 = new ArrayList<>(n);
        LinkedList<Integer> a2 = new LinkedList<>();
        Integer[] a3 = new Integer[n];

        bt = System.currentTimeMillis();
        for(int i=0; i<n; i++){
            a0[i] = i;
        }
        et = System.currentTimeMillis();
        System.out.println("===== loop0 time =======" + (et - bt));

        bt = System.currentTimeMillis();
        for(int i=0; i<n; i++){
            a1.add(i);
        }
        et = System.currentTimeMillis();
        System.out.println("===== loop1 time =======" + (et - bt));

        bt = System.currentTimeMillis();
        for(int i=0; i<n; i++){
            a2.add(i);
        }
        et = System.currentTimeMillis();
        System.out.println("===== loop2 time =======" + (et - bt));


        bt = System.currentTimeMillis();
        for(int i=0; i<n; i++){
            a3[i] = i;
        }
        et = System.currentTimeMillis();
        System.out.println("===== loop3 time =======" + (et - bt));
    }
}

The result is

===== loop0 time =======11
===== loop1 time =======6776
===== loop2 time =======17305
===== loop3 time =======56

Why the ArralyList/LinkedList is so slower than array? How could I improve the performance.

env: Java: jdk1.8.0_231

Thanks

Answer 1

There are potential inaccuracies in your benchmark, but the overall ranking of the results is probably correct. You may get faster results for all of the benchmarks if you "warm-up" the code before taking timings to allow the JIT compiler to generate native code and optimise it. Some benchmark results may be closer or even equal.

Iterating over an int array is going to be much faster than iterating over a List of Integer objects. A LinkedList is going to be slowest of all. These statements assume the optimiser doesn't make radical changes.

Let's look at why:

An int array ( int[] ) is a contiguous area of memory containing your 4 byte ints arranged end-to-end. The loop to iterate over this and set the elements just has to work its way through the block of memory setting each 4 bytes in turn. In principle an index check is required, but in practice the optimiser can realise this isn't necessary and remove it. The JIT compiler is well able to optimise this kind of thing based on native CPU instructions.

An ArrayList of Integer objects contains an array of references which point to individual Integer objects (or are null). Each Integer object will have to be allocated separately (although Java can re-use Integers of small numbers). There is an overhead to allocate new objects and in addition the reference may be 8 bytes instead of 4. Also, if the list size is not specified (though it is in your case) the internal array may need to be reallocated. There is an overhead due to calling the add method instead of assigning to the array directly (the optimizer may remove this though).

Your array of Integer benchmark is similar to the array list but doesn't have the overhead of the list add method call (which has to track the list size). Probably your benchmark overstates the difference between this array and the array list though.

A LinkedList is the worst case. Linked lists are optimised for inserting in the middle. They have references to point to the next item in the list and nodes to hold those references in addition to the Integer object that needs allocating. This is a big memory overhead that also requires some initialisation and you would not use a linked list unless you were expecting to insert a lot of elements into the middle of the list.