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

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