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

Все массивы имеют нулевое начало. Массив длиной 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 значения могут также использоваться в качестве индексных значений, поскольку они подвергаются числовому преобразованию с унарным оператором (§5.6.1) и становятся 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' (символом NULL).

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

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