Array vs ArrayList in Java

Direct Answer

An array has a fixed length and can store either primitives or references. ArrayList<E> is a resizable List backed by an array and stores reference types, so primitive values use wrappers such as Integer. Arrays fit fixed-size or primitive data; ArrayList fits a collection whose size changes and needs List operations. Choose from the required behavior, not a blanket performance rule.

Code Example

Watching the same job done both ways makes the trade-off tangible: the array hits a wall at its fixed size, while the ArrayList just keeps accepting elements. Run it as a Java 17 console app.

import java.util.ArrayList;

public class ArrayVsArrayList {
    public static void main(String[] args) {

        // ARRAY — fixed size, direct primitive storage
        int[] topScores = new int[3];
        topScores[0] = 95;
        topScores[1] = 88;
        topScores[2] = 76;
        // topScores[3] = 70;  // compiles, but throws ArrayIndexOutOfBoundsException at runtime
        System.out.println(topScores.length); // 3

        // ARRAYLIST — dynamic, grows as needed
        ArrayList<Integer> playerScores = new ArrayList<>();
        playerScores.add(95);
        playerScores.add(88);
        playerScores.add(76);
        playerScores.add(70);  // no problem — ArrayList resizes automatically
        playerScores.remove(0); // removes the first element (95)
        System.out.println(playerScores.size()); // 3
        System.out.println(playerScores.get(0)); // 88
    }
}

The array rejects the fourth element at runtime with an index exception; the ArrayList absorbs it and even lets you remove from the middle — that flexibility is the whole reason it exists, and primitive values such as int are boxed as Integer elements.

Common Mistakes & Pitfalls

• Mixing up length and size() — arrays use the field arr.length; ArrayList uses the method list.size(). Calling arr.size() or list.length is a compile error and a classic exam trap.
• Trying ArrayList<int> — generics only accept reference types, so it must be ArrayList<Integer>. Autoboxing converts the int, but storing millions of boxed Integers costs far more memory than an int[].
• Array covariance bites at runtime — Object[] arr = new String[3]; arr[0] = 42; compiles fine but throws ArrayStoreException at runtime, because the real array is a String[]. Generics close this hole: a List<String> simply won't let you add an Integer at compile time.
• list.remove(2) on an ArrayList<Integer> — this removes the element at index 2, not the value 2. To delete the value you must call list.remove(Integer.valueOf(2)).