Глава 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). Можно объявить переменную типа массива, тип элементов которого не реифицируем, но присваивание результата выражения создания массива переменной неизбежно вызовет предупреждение о неявном преобразовании (§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-1-го компонента массива. Если выполнение инициализатора переменной завершается аварийно, выполнение инициализатора массива завершается аварийно по той же причине. Если все выражения инициализатора переменной завершаются нормально, инициализатор массива завершается нормально со значением только что инициализированного массива.

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

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[] в приведенном выше коде сгенерирует предупреждение о неявном преобразовании (§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 реализует полезные методы для изменяемых массивов символов.