Java Arrays

An array is a fixed-size, ordered container that holds multiple values of the same type under a single variable name, with each value accessed by a zero-based integer index. Arrays are themselves objects in Java (even arrays of primitives), which is why every array has a length field and is allocated on the heap with new.

Because an array's size is fixed once created, arrays are best suited to situations where you know how many elements you need in advance. When the number of elements can grow or shrink dynamically, Java's collection classes (like ArrayList) are usually a better fit, but arrays remain the foundation those collections are often built on.

Why it matters

Arrays are the simplest way to hold many values of the same type, and they sit underneath most of the collections you will use later, including ArrayList. Their two fixed rules — the size never changes, and indexes run from 0 to length minus 1 — explain both why they are fast and why ArrayIndexOutOfBoundsException is one of the first exceptions every Java developer meets.

Declaring, Creating, and Initializing Arrays

Declaring an array (int[] scores;) only creates a reference variable — no memory for elements exists yet. Creating an array with new int[4] allocates space for four ints on the heap. Java also supports an array literal shorthand at the point of declaration, such as int[] scores = {90, 85, 78, 92};, which both creates and initializes the array in one step.

Default Values and Length

When an array is created with new but no explicit values, every element gets the type's default value automatically: 0 for numeric types, false for boolean, and null for reference types — the same defaults instance variables get. The length field (not a method — no parentheses) always reports the array's fixed size and never changes after creation.

Bounds and Fixed Size

Valid indices run from 0 to length - 1. Accessing any index outside that range, in either direction, throws an ArrayIndexOutOfBoundsException at runtime rather than being caught at compile time, so index arithmetic needs care. Because arrays cannot grow, "adding" an element in practice means creating a new, larger array and copying the existing elements into it.

Time complexity

Example

public class ArrayBasicsDemo {
    public static void main(String[] args) {
        int[] scores = new int[4];  // default values: 0, 0, 0, 0
        System.out.println("Default: " + java.util.Arrays.toString(scores));

        scores[0] = 90;
        scores[1] = 85;
        scores[2] = 78;
        scores[3] = 92;

        int total = 0;
        for (int i = 0; i < scores.length; i++) {
            total += scores[i];
        }
        System.out.println("Total: " + total);
        System.out.println("Length: " + scores.length);
    }
}

Default: [0, 0, 0, 0]
Total: 345
Length: 4

Exercise

Reverse an array in place, without creating a second array, by swapping elements from the two ends towards the middle.

Expected output: [5, 4, 3, 2, 1]

import java.util.Arrays;

public class ReverseArray {
    public static void main(String[] args) {
        int[] values = {1, 2, 3, 4, 5};

        // TODO: swap values[left] and values[right], moving both towards the middle

        System.out.println(Arrays.toString(values));
    }
}

import java.util.Arrays;

public class ReverseArray {
    public static void main(String[] args) {
        int[] values = {1, 2, 3, 4, 5};

        for (int left = 0, right = values.length - 1; left < right; left++, right--) {
            int temp = values[left];
            values[left] = values[right];
            values[right] = temp;
        }

        System.out.println(Arrays.toString(values)); // [5, 4, 3, 2, 1]
    }
}

Quick quiz

Interview questions