Массивы в Java: объявление, инициализация, доступ и перебор

Массив - это список фиксированного размера

Массив в Java хранит фиксированное количество значений одного типа, расположенных по порядку и доступных по позиции. «Фиксированный» - ключевое слово: как только вы создаёте массив, его длина уже никогда не меняется. И «одного типа»: int[] хранит только значения int, String[] хранит только строки. Эта жёсткость - плата за то, что массивы быстры и компактны в памяти.

Тип массива объявляется добавлением [] после типа элемента, после чего вы либо присваиваете литерал, либо выделяете память с помощью 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]);
    }
}

Скобки могут стоять после типа (int[] scores) или после имени (int scores[]). Оба варианта компилируются, но int[] scores - идиоматический стиль Java: ставьте [] рядом с типом, где им и место.

Создание массива с помощью new

Когда вы ещё не знаете значений, но знаете размер, используйте new. Это выделяет ячейки и заполняет их значением по умолчанию для типа:

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]);
    }
}

Значения по умолчанию - не случайный мусор: Java инициализирует каждый элемент нулём. Числовые типы начинаются с 0 (или 0.0), boolean начинается с false, а ссылочные типы вроде String начинаются с null. Этот null стоит запомнить: только что выделенный String[] полон null-ов, и вызов метода на одном из них выбрасывает NullPointerException.

Индексация начинается с нуля

Вы читаете и записываете элементы по индексу, отсчитывая от 0. Последний допустимый индекс всегда равен 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]);
    }
}

В отличие от массивов в некоторых скриптовых языках, выход за границы не возвращает тихо null или undefined - он выбрасывает исключение. Попробуйте прочитать несуществующий индекс:

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

Эта программа падает с ошибкой:

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

Это одна из самых частых ошибок новичков. Исправление почти всегда сводится к ошибке на единицу (off-by-one) в условии цикла - использование <= там, где имелось в виду <.

length - это поле, а не метод

Каждый массив хранит свой размер в поле length. Внимание: без круглых скобок.

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

Вот подвох, на который хоть раз попадается каждый: массивы используют .length (поле), а String использует .length() (метод). Написать nums.length() для массива - ошибка компиляции, как и написать text.length для строки. Одно и то же слово, разные правила - у массива оно без скобок.

Перебор массива

Цикл for-each вы изучили на предыдущей странице, и это самый чистый способ прочитать каждый элемент, когда индекс вам не нужен:

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));
    }
}

Когда вам нужен индекс - чтобы вывести номера позиций, изменить элементы на месте или пройти в обратном порядке - возьмите классический индексный цикл for с length в качестве границы:

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]);
        }
    }
}

Условие - i < names.length, а не <=. Использование <= делает один лишний шаг и выбрасывает исключение выхода за границы из предыдущего раздела. Простое правило: for-each, когда вы только читаете значения, индексный for, когда вам нужна позиция или вы хотите записывать обратно в массив.

Многомерные массивы

Двумерный массив на самом деле является массивом массивов - представьте его как сетку из строк и столбцов. Вы добавляете вторую пару скобок:

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[строка][столбец] выбирает одну ячейку. Поскольку каждая строка - это отдельный массив, grid.length - это количество строк, а grid[0].length - количество столбцов в первой строке. Строки даже не обязаны быть одинаковой длины (такое называют зубчатым массивом), хотя большинство сеток прямоугольные.

Класс-утилита Arrays

У самих массивов почти нет методов - их нельзя напрямую отсортировать или с пользой вывести. Для этого Java предоставляет класс-утилиту java.util.Arrays, полный статических помощников:

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);
    }
}

Несколько моментов, на которые стоит опереться. Arrays.toString(arr) - правильный способ вывести массив: при прямом выводе вы получите бесполезную строку вроде [I@1b6d3586. Arrays.sort сортирует на месте. Arrays.copyOf - это способ «изменить размер»: он возвращает новый массив запрошенной длины, дополняя значениями по умолчанию (две лишние ячейки выше равны 0). А Arrays.binarySearch работает корректно только на уже отсортированном массиве.

Массивы против ArrayList

Используйте обычный массив, когда размер известен заранее и не будет меняться - фиксированный набор дней недели, игровое поле, данные пикселей. Массивы быстры и легковесны, но их фиксированная длина - реальное ограничение: вы не можете добавить седьмой элемент в массив длины 6, не построив совершенно новый.

Как только вам нужно свободно добавлять и удалять элементы, массив становится неудобным. Для этого и существует ArrayList - изменяемый, растущий список, который берёт копирование на себя.

Далее: ArrayList

Когда вы не знаете, сколько элементов у вас будет, или это число меняется по ходу работы программы, массив фиксированной длины мешает. ArrayList - ответ Java: список, который растёт и сжимается по требованию, с методами add и remove вместо жонглирования индексами. Об этом - дальше.