Java Arrays: Declare, Initialize, Access, and Loop

An Array Is a Fixed-Size List

An array in Java holds a fixed number of values of the same type, laid out in order and accessed by position. "Fixed" is the key word: once you create an array, its length never changes. And "same type": an int[] holds only int values, a String[] holds only strings. That rigidity is the trade-off for arrays being fast and memory-compact.

You declare an array type by putting [] after the element type, then either assign a literal or allocate one with new:

public class Main {
    public static void main(String[] args) {
        int[] scores = {82, 91, 73, 88};
        String[] names = {"Ada", "Boris", "Chen"};

        System.out.println(scores[0]);
        System.out.println(names[1]);
    }
}

The brackets can sit after the type (int[] scores) or after the name (int scores[]). Both compile, but int[] scores is the idiomatic Java style - put the [] with the type, where it belongs.

Creating an Array with new

When you don't know the values yet but you do know the size, use new. This allocates the slots and fills them with the type's default value:

public class Main {
    public static void main(String[] args) {
        int[] nums = new int[5];
        boolean[] flags = new boolean[3];
        String[] words = new String[2];

        System.out.println(nums[0]);
        System.out.println(flags[0]);
        System.out.println(words[0]);
    }
}

The defaults aren't random garbage - Java zero-initializes every element. Numeric types start at 0 (or 0.0), boolean starts at false, and reference types like String start at null. That null is worth remembering: a freshly allocated String[] is full of nulls, and calling a method on one of them throws a NullPointerException.

Indexing Starts at Zero

You read and write elements by index, counting from 0. The last valid index is always length - 1:

public class Main {
    public static void main(String[] args) {
        String[] colors = {"red", "green", "blue"};

        System.out.println(colors[0]);
        System.out.println(colors[2]);

        colors[1] = "yellow";
        System.out.println(colors[1]);
    }
}

Unlike arrays in some scripting languages, going out of range doesn't quietly give you null or undefined - it throws. Try reading an index that doesn't exist:

public class Main {
    public static void main(String[] args) {
        int[] nums = {10, 20, 30};
        System.out.println(nums[5]);
    }
}

That program crashes with:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 3

This is one of the most common beginner errors. The fix is almost always an off-by-one mistake in a loop condition - using <= where you meant <.

length Is a Field, Not a Method

Every array carries its size in a length field. Note: no parentheses.

public class Main {
    public static void main(String[] args) {
        int[] nums = {10, 20, 30, 40};
        System.out.println(nums.length);
    }
}

Here's a gotcha that bites everyone at least once: arrays use .length (a field), but a String uses .length() (a method). Writing nums.length() on an array is a compile error, and writing text.length on a string is too. Same word, different rules - the array one has no parentheses.

Looping Through an Array

You learned the for-each loop on the previous page, and it's the cleanest way to read every element when you don't need the index:

public class Main {
    public static void main(String[] args) {
        int[] scores = {82, 91, 73, 88};

        int total = 0;
        for (int score : scores) {
            total += score;
        }

        System.out.println("Total: " + total);
        System.out.println("Average: " + (total / scores.length));
    }
}

When you need the index - to print position numbers, modify elements in place, or iterate backward - reach for the classic indexed for loop with length as the bound:

public class Main {
    public static void main(String[] args) {
        String[] names = {"Ada", "Boris", "Chen"};

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

The condition is i < names.length, not <=. Using <= runs one step too far and throws the out-of-bounds exception from the section above. A quick rule: for-each when you only read values, indexed for when you need the position or want to write back into the array.

Multidimensional Arrays

A 2D array is really an array of arrays - think of it as a grid of rows and columns. You add a second pair of brackets:

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

        System.out.println(grid[0][2]);
        System.out.println(grid[1][0]);

        for (int[] row : grid) {
            for (int value : row) {
                System.out.print(value + " ");
            }
            System.out.println();
        }
    }
}

grid[row][column] picks a single cell. Because each row is its own array, grid.length is the number of rows and grid[0].length is the number of columns in the first row. Rows don't even have to be the same length (that's called a jagged array), though most grids are rectangular.

The Arrays Helper Class

Arrays themselves have almost no methods - you can't sort or print one directly in a useful way. Java provides a java.util.Arrays utility class full of static helpers for exactly this:

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] nums = {5, 2, 8, 1, 9};

        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums));

        int[] copy = Arrays.copyOf(nums, 7);
        System.out.println(Arrays.toString(copy));

        int found = Arrays.binarySearch(nums, 8);
        System.out.println("Index of 8: " + found);
    }
}

A few things to lean on here. Arrays.toString(arr) is the right way to print an array - printing one directly gives you a useless string like [I@1b6d3586. Arrays.sort sorts in place. Arrays.copyOf is how you "resize": it returns a new array of the length you ask for, padding with defaults (the two extra slots above are 0). And Arrays.binarySearch only works correctly on an already-sorted array.

Arrays vs ArrayList

Use a plain array when the size is known up front and won't change - a fixed set of weekdays, a game board, pixel data. Arrays are fast and lightweight, but their fixed length is a real limit: you can't add a seventh element to a length-6 array without building a whole new one.

The moment you need to add and remove items freely, an array becomes awkward. That's what ArrayList is for - a resizable, growable list that handles the copying for you.

Next: ArrayList

When you don't know how many items you'll have, or that number changes as your program runs, a fixed-length array gets in the way. ArrayList is Java's answer: a list that grows and shrinks on demand, with add and remove methods instead of index juggling. That's up next.