Длина массива в Java

Длина массива в Java — это количество его элементов. Она хранится в специальном поле length, которое есть у каждого массива: array.length. Длина задаётся один раз при создании массива и больше никогда не меняется. В этом уроке разберём, как узнать длину одномерного, многомерного и «рваного» массива, чем length отличается от метода length() у строк и size() у коллекций, и на каких мелочах чаще всего ошибаются новички.

Поле length: как узнать длину массива

Массив в Java — это объект, и у этого объекта есть публичное неизменяемое поле length. Обратиться к нему можно через точку, как к обычному полю:

int[] numbers = {10, 20, 30, 40};
System.out.println(numbers.length); // 4

Обратите внимание: после length нет круглых скобок. Это не метод, а поле, которое JVM заполняет в момент создания массива.

Длина массива фиксируется при создании и не может быть изменена. Если нужно «увеличить» массив, придётся создать новый массив большего размера и скопировать в него элементы (например, методом Arrays.copyOf) — либо сразу использовать коллекцию ArrayList, которая расширяется автоматически.

Длина одномерного массива

С одномерным массивом всё просто: его длина — это количество элементов. При этом индексы элементов идут от 0 до length - 1, поэтому последний элемент — это array[array.length - 1], а не array[array.length]:

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

        System.out.println("Длина массива array1 = " + array1.length);
        System.out.println("Первый элемент = " + array1[0]);
        System.out.println("Последний элемент = " + array1[array1.length - 1]);
    }
}

Результат выполнения:

Длина массива array1 = 4
Первый элемент = 1
Последний элемент = 4

Поле length постоянно используется в циклах для перебора массива:

int[] array1 = {1, 2, 3, 4};
for (int i = 0; i < array1.length; i++) {
    System.out.println(array1[i]);
}

Условие цикла — строго i < array1.length. Если написать i <= array1.length, на последней итерации программа обратится к несуществующему индексу и выбросит исключение:

int[] array1 = {1, 2, 3, 4};
// Ошибка: индекса 4 не существует, допустимые индексы: 0..3
System.out.println(array1[array1.length]);
// Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException:
// Index 4 out of bounds for length 4

Длина многомерного и рваного массива

Двумерный массив в Java — это на самом деле «массив массивов». Поэтому array2.length возвращает количество строк (длину первой размерности), а array2[i].length — количество элементов в строке с индексом i:

public class MultiArrayLengthExample {
    public static void main(String[] args) {
        int[][] array2 = {{1, 1, 1}, {2, 2, 2}};

        System.out.println("Количество строк array2 = " + array2.length);
        System.out.println("Длина строки с индексом 0 = " + array2[0].length);
        System.out.println("Длина строки с индексом 1 = " + array2[1].length);
    }
}

Результат выполнения:

Количество строк array2 = 2
Длина строки с индексом 0 = 3
Длина строки с индексом 1 = 3

В Java строки двумерного массива могут иметь разную длину — такие массивы называют «рваными» (jagged). Поэтому нельзя полагаться на то, что все строки такой же длины, как первая: длину каждой строки нужно спрашивать у неё самой.

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

        for (int i = 0; i < jagged.length; i++) {
            System.out.println("Строка " + i + ", длина = "
                    + jagged[i].length);
        }
    }
}

Результат выполнения:

Строка 0, длина = 1
Строка 1, длина = 3
Строка 2, длина = 2

Общее число элементов рваного массива приходится считать вручную — суммированием длин всех строк:

int total = 0;
for (int[] row : jagged) {
    total += row.length;
}
System.out.println("Всего элементов: " + total); // Всего элементов: 6

Пустой массив и null

Пустой массив — это полноценный объект нулевой длины: обращение к его полю length вернёт 0. А вот если ссылка на массив равна null, то массива не существует, и попытка прочитать length закончится NullPointerException:

int[] empty = new int[0];
System.out.println(empty.length); // 0 — это нормально

int[] nothing = null;
System.out.println(nothing.length); // NullPointerException!

length, length() и size(): в чём разница

В Java «длина» у разных типов данных запрашивается по-разному, и эти три варианта постоянно путают:

Небольшой пример, где встречаются все три варианта сразу:

import java.util.List;

public class LengthVsSizeExample {
    public static void main(String[] args) {
        int[] array = {1, 2, 3};
        String text = "Java";
        List<String> list = List.of("a", "b");

        System.out.println(array.length);  // 3 — поле массива
        System.out.println(text.length()); // 4 — метод String
        System.out.println(list.size());   // 2 — метод коллекции
    }
}

На чём чаще всего ошибаются

Несколько типичных промахов при работе с длиной массива:

• array.length() со скобками. Не скомпилируется: у массива length — поле. Скобки нужны только у строк: str.length().
• Обращение по индексу array.length. Последний допустимый индекс — array.length - 1. Обращение к array[array.length] выбрасывает ArrayIndexOutOfBoundsException.
• Условие i <= array.length в цикле. Классическая ошибка «на единицу» (off-by-one): цикл делает лишнюю итерацию и падает с исключением. Правильно: i < array.length.
• Предположение, что все строки двумерного массива одинаковой длины. В рваном массиве это не так — длину каждой строки берите через array[i].length.
• Чтение length у null-ссылки. Приводит к NullPointerException. Пустой массив (length == 0) и null — принципиально разные вещи.
• Попытка присвоить length новое значение. Код array.length = 10; не скомпилируется: поле финальное, размер массива изменить нельзя.

Полезные приёмы

• Для простого перебора всех элементов используйте цикл for-each — в нём вообще не нужно обращаться к length и невозможно ошибиться с границами: for (int x : array) { ... }.
• Последний элемент массива — всегда array[array.length - 1]; заведите привычку писать это выражение автоматически.
• Если размер данных заранее неизвестен или должен меняться — берите ArrayList вместо массива: метод size() всегда вернёт актуальное количество элементов.
• Из методов лучше возвращать пустой массив (new int[0]), а не null — вызывающему коду не придётся делать лишнюю проверку.
• Чтобы «изменить размер» массива, используйте Arrays.copyOf(array, newLength) — метод создаст новый массив нужной длины и скопирует элементы.

Презентация с видео на Patreon →