Глава 10. Массивы

Типы массивов используются в объявлениях и в выражениях приведения типов (§15.16).

Тип массива записывается как имя типа элемента, за которым следует некоторое количество пар пустых квадратных скобок []. Количество пар скобок указывает глубину вложенности массива.

Каждая пара скобок в типе массива может быть аннотирована анотациями типов (§9.7.4). Анотация применяется к паре скобок (или эллипсису, в объявлении параметра с переменным числом аргументов), которая следует за ней.

Тип элемента массива может быть любым типом, примитивным или ссылочным. В частности:

Длина массива не является частью его типа.

Супертипы типа массива указаны в §4.10.3.

Отношение супертипа для типов массивов не такое же, как отношение суперкласса. Прямой супертип Integer[] — это Number[] в соответствии с §4.10.3, но прямой суперкласс Integer[] — это Object согласно Class объекту для Integer[] (§10.8). Это не имеет практического значения, потому что Object также является супертипом всех типов массивов.

Переменная типа массива хранит ссылку на объект. Объявление переменной типа массива не создаёт объект массива или не выделяет место для компонентов массива. Оно создаёт только саму переменную, которая может содержать ссылку на массив. Однако часть инициализатора декларатора (§8.3, §9.3, §14.4.1) может создать массив, ссылка на который затем становится начальным значением переменной.

int[]     ai;        // array of int
short[][] as;        // array of array of short
short     s,         // scalar short
          aas[][];   // array of array of short
Object[]  ao,        // array of Object
          otherAo;   // array of Object
Collection<?>[] ca;  // array of Collection of unknown type

Exception ae[]  = new Exception[3];
Object aao[][]  = new Exception[2][3];
int[] factorial = { 1, 1, 2, 6, 24, 120, 720, 5040 };
char ac[]       = { 'n', 'o', 't', ' ', 'a', ' ',
                    'S', 't', 'r', 'i', 'n', 'g' };
String[] aas    = { "array", "of", "String", };

Тип массива переменной зависит от пар скобок, которые могут быть частью типа в начале объявления переменной, или в части декларатора переменной, или и то, и другое. В частности, при объявлении поля, формального параметра, локальной переменной или компонента записи (§8.3, §8.4.1, §9.3, §9.4, §14.4.1, §14.14.2, §15.27.1, §8.10.1), тип массива переменной определяется следующим образом:

Тип результата метода (§8.4.5) может быть типом массива. Точный тип массива зависит от пар скобок, которые могут появляться в части типа в начале объявления метода или после списка формальных параметров метода, или и то, и другое. Тип массива определяется следующим образом:

Не рекомендуется использовать «смешанную запись» в объявлениях переменных массивов, где пары скобок появляются как в типе, так и в деклараторах; также не рекомендуется использовать в объявлениях методов, где пары скобок появляются как до, так и после списка формальных параметров.

byte[] rowvector, colvector, matrix[];

byte rowvector[], colvector[], matrix[][];

int a, b[], c[][];

int a;
int[] b;
int[][] c;

float[][] f[][], g[][][], h[];  // Yechh!

float[][][][] f;
float[][][][][] g;
float[][][] h;

void m(int @A [] @B []  x) {}
void n(int @A [] @B ... y) {}

int @A [] f @B [];
int @B [] @A [] g;

После создания объекта массива его длина никогда не изменяется. Чтобы сделать переменную массива ссылкой на массив другой длины, переменной необходимо присвоить ссылку на другой массив.

Одна переменная типа массива может содержать ссылки на массивы различной длины, потому что длина массива не является частью его типа.

Если переменная массива v имеет тип A[], где A — тип ссылки, то v может содержать ссылку на экземпляр любого типа массива B[], при условии, что B можно присвоить A (§5.2). Это может привести к исключению во время выполнения на позднем присваивании; см. §10.5 для обсуждения.

Массив создаётся с помощью выражения создания массива (§15.10.1) или инициализатора массива (§10.6).

Выражение создания массива указывает тип элемента, количество уровней вложенных массивов и длину массива по крайней мере для одного из уровней вложенности. Длина массива доступна как final переменная экземпляра length.

Инициализатор массива создаёт массив и предоставляет начальные значения для всех его компонентов.

Компонент массива доступен через выражение доступа к массиву (§15.10.3), которое состоит из выражения, значение которого является ссылкой на массив, за которым следует выражение индексации, заключённое в [ и ], как в A[i].

Все массивы имеют 0 нумерацию. Массив с длиной n может быть индексирован целыми числами 0 до n-1.

class Gauss {
    public static void main(String[] args) {
        int[] ia = new int[101];
        for (int i = 0; i < ia.length; i++) ia[i] = i;
        int sum = 0;
        for (int e : ia) sum += e;
        System.out.println(sum);
    }
}

5050

Массивы должны индексироваться int значениями; short, byte или char значения также могут использоваться в качестве значений индекса, поскольку они подвергаются числовому преобразованию с приведением к int значениям.

Попытка доступа к компоненту массива с long значением индекса приводит к ошибке компиляции.

Все обращения к массиву проверяются во время выполнения; попытка использования индекса, который меньше нуля или больше или равен длине массива, вызывает исключение ArrayIndexOutOfBoundsException (§15.10.4).

Для массива, тип которого A[], где A — тип ссылки, присвоение элементу массива проверяется во время выполнения, чтобы убедиться, что присваиваемое значение совместимо с типом элемента.

Если тип присваиваемого значения не совместим с типом элемента (§5.2), выбрасывается исключение ArrayStoreException.

Если тип элемента массива не был бы реифицируемым (§4.7), виртуальная машина Java не могла бы выполнить проверку сохранения, описанную в предыдущем абзаце. Вот почему выражение создания массива с нереифицируемым типом элемента запрещено (§15.10.1). Можно объявить переменную типа массива с нереифицируемым типом элемента, но присвоение результата выражения создания массива переменной неизбежно вызовет предупреждение об unchecked-преобразовании (§5.1.9).

class Point { int x, y; }
class ColoredPoint extends Point { int color; }
class Test {
    public static void main(String[] args) {
        ColoredPoint[] cpa = new ColoredPoint[10];
        Point[] pa = cpa;
        System.out.println(pa[1] == null);
        try {
            pa[0] = new Point();
        } catch (ArrayStoreException e) {
            System.out.println(e);
        }
    }
}

true
java.lang.ArrayStoreException: Point

Инициализатор массива может быть указан в объявлении поля (§8.3, §9.3) или объявлении локальной переменной (§14.4), или как часть выражения создания массива (§15.10.1), для создания массива и предоставления некоторых начальных значений.

Следующая продукция из §8.3 показана здесь для удобства:

Инициализатор массива записывается как список выражений, разделенных запятыми, заключенные в фигурные скобки { и }.

Запятая после последнего выражения в инициализаторе массива может быть опущена и игнорируется.

Каждый инициализатор переменной должен быть совместим с типом элемента массива (§5.2), в противном случае возникает ошибка компиляции.

Если тип элемента массива, который инициализируется, не является реифицируемым (§4.7), возникает ошибка компиляции.

Длина создаваемого массива равна числу инициализаторов переменных, заключенных в фигурные скобки инициализатора массива. Выделяется память для нового массива указанной длины. Если памяти недостаточно для выделения массива, выполнение инициализатора массива прерывается с выбрасыванием исключения OutOfMemoryError. В противном случае создается одномерный массив заданной длины, и каждый элемент массива инициализируется своим значением по умолчанию (§4.12.5).

Затем инициализаторы переменных, заключенные в фигурные скобки инициализатора массива, выполняются слева направо в текстовом порядке их появления в исходном коде. n'й инициализатор переменной задаёт значение n-го компонента массива. Если выполнение инициализатора переменной прерывается, то выполнение инициализатора массива прерывается по той же причине. Если все выражения инициализаторов переменных завершаются успешно, инициализатор массива завершается успешно, возвращая значение инициализированного массива.

Если тип элемента — это тип массива, то инициализатор переменной, задающий элемент, сам может быть инициализатором массива; то есть инициализаторы массивов могут быть вложены. В этом случае выполнение вложенного инициализатора массива создаёт и инициализирует массив-объект с рекурсивным применением алгоритма выше и присваивает его элементу.

class Test {
    public static void main(String[] args) {
        int[][] ia = { { 1, 2 }, null };
        for (int[] ea : ia) {
            for (int e: ea) {
                System.out.println(e);
            }
        }
    }
}

1
2

Членами типа массива являются следующие:

Таким образом, массив имеет те же поля и методы, что и следующий класс:

class A<T> implements Cloneable, java.io.Serializable {
    public final int length = X;
    public T[] clone() {
        try {
            return (T[])super.clone();
        } catch (CloneNotSupportedException e) {
            throw new InternalError(e.getMessage());
        }
    }
}

Обратите внимание, что приведение к типу T[] в приведенном выше коде сгенерирует предупреждение об unchecked-преобразовании (§5.1.9), если массивы действительно реализованы таким образом.

class Test1 {
    public static void main(String[] args) {
        int[] ia1 = { 1, 2 };
        int[] ia2 = ia1.clone();
        System.out.print((ia1 == ia2) + " ");
        ia1[1]++;
        System.out.println(ia2[1]);
    }
}

false 2

class Test2 {
    public static void main(String[] args) throws Throwable {
        int[][] ia = { { 1, 2 }, null };
        int[][] ja = ia.clone();
        System.out.print((ia == ja) + " ");
        System.out.println(ia[0] == ja[0] && ia[1] == ja[1]);
    }
}

false true

Каждый массив имеет связанный с ним Class объект, общий для всех других массивов с одинаковым типом компонентов.

Хотя тип массива не является классом, Class объект каждого массива ведет себя так, как будто:

class Test1 {
    public static void main(String[] args) {
        int[] ia = new int[3];
        System.out.println(ia.getClass());
        System.out.println(ia.getClass().getSuperclass());
        for (Class<?> c : ia.getClass().getInterfaces())
            System.out.println("Superinterface: " + c);
    }
}

class [I
class java.lang.Object
Superinterface: interface java.lang.Cloneable
Superinterface: interface java.io.Serializable

class Test2 {
    public static void main(String[] args) {
        int[] ia = new int[3];
        int[] ib = new int[6];
        System.out.println(ia == ib);
        System.out.println(ia.getClass() == ib.getClass());
    }
}

false
true

В языке программирования Java, в отличие от C, массив char не является String, и ни String, ни массив char не завершается '\u0000' (символом NUL).

Объект String является неизменяемым, то есть его содержимое никогда не меняется, в то время как массив char имеет изменяемые элементы.

Метод toCharArray в классе String возвращает массив символов, содержащий ту же последовательность символов, что и String. Класс StringBuffer реализует полезные методы для изменяемых массивов символов.