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

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

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

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

Надтипы типа массива указаны в §4.10.3.

Непосредственным суперклассом типа массива является Object.

Каждый тип массива реализует интерфейсы Cloneable и java.io.Serializable.

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

Однако, часть инициализатора декларатора (§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", };

[] может появиться в качестве части типа в начале объявления, или как часть декларатора для конкретной переменной, или и то, и другое.

byte[] rowvector, colvector, matrix[];

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

В объявлении переменной (§8.3, §8.4.1, §9.3, §14.14, §14.20) за исключением переменной с изменяемым количеством аргументов, тип массива переменной обозначается типом массива, который появляется в начале объявления, за которым следуют любые пары скобок, следующие за идентификатором переменной в деклараторе.

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

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

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

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

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

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

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

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

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

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

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

Элемент массива доступен с помощью выражения доступа к массиву (§15.13), которое состоит из выражения, значение которого — ссылка на массив, за которым следует выражение индексации, заключённое в [ и ], как в 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 исключения.

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

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

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

Следующее повторяется из §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(); // unchecked warning
        } catch (CloneNotSupportedException e) {
            throw new InternalError(e.getMessage());
        }
    }
}

См. §9.6.3.4 для другой ситуации, когда разница между public и не-public методами Object требует особого внимания.

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 Test {
    public static void main(String[] args) {
        int[] ia = new int[3];
        System.out.println(ia.getClass());
        System.out.println(ia.getClass().getSuperclass());
    }
}

class [I
class java.lang.Object

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

true
ia has length=3

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

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

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