Инициализация и использование массивов

Java поддерживает способы объявления, создания и явной инициализации массива в одном предложении объявления:

<тип_элемента>[] <имя_массива> = { <Инициализирующий список массива> };

Такой способ инициализации применяется как к членам класса, так и локальным массивам. <Инициализирующий список массива> представляет собой разделяемый запятой список из нуля или более выражений. Таким образом, инициализирующий блок массива приводит к созданию и инициализации массива.

int[] anIntArray = { 1, 3, 49, 2, 6, 7, 15, 2, 1, 5 };

Массив anIntArray объявлен как массив типа int. Он создан, чтобы хранить 10 элементов (равняется длине списка выражений в блоке), причем первый элемент инициализируется значением первого выражения (1), второй элемент — значением второго выражения (3) и т. д.

// Pizza расширяет класс Object

Object[] objArray = { new Pizza(), new Pizza(), null };

Массив objArray объявлен как массив класса Object. Инициализационный код устанавливает первые два элемента массива так, чтобы они ссылались на два объекта типа Pizza, в то время как последний элемент инициализируется ссылкой null. Обратите внимание: в вышеприведенной строке объявления в действительности создается три объекта — массив с тремя ссылками и два объекта типа pizza.

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

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

Topping[] pizzaToppings = { new Topping("cheese"), new Topping("tomato"), };

В строке объявления (1) в следующем коде определяется массив из четырех объектов типа string, а в строке объявления (2) поясняется, что объект string не то же самое, что массив типа char.

// Массив 4 объектов String
String[] pets = { "crocodiles", "elephants", "crocophants", "elediles" }; // (1)

// Масив из 3 символов
char[] charArray = { 'a', 'h', 'a' };    // (2) не то же самое что "aha".

Использование массивов

Обращение ко всему массиву происходит по его имени, а доступ к отдельным элементам массива производится путем указания индекса и оператора [ ]. Выражение доступа к элементу массива имеет следующий синтаксис.

<имя массива> [<индексное выражение>]

Каждый отдельный элемент рассматривается как простая переменная определенного типа. Индекс задается <индексным выражением>, которое может быть любым выражением, в результате вычисления которого получается неотрицательное значение типа int. Нижняя граница массива всегда 0, верхняя граница на единицу меньше, чем размер массива, т.е. <имя массива>.length - 1. i-ый элемент в массиве имеет индекс i - 1. Во время выполнения значение индекса автоматически проверяется, чтобы гарантировать, что оно находится внутри индексных границ массива. Если индексное значение в выражении доступа к элементу массива меньше, чем 0, или больше или равно <имя массива>.length, то выбрасывается исключение ArraylndexOutOfBoundsException. В программе можно явно проверить индекс или перехватить исключение, однако недопустимый индекс обычно служит индикатором программной ошибки.

В выражении доступа к элементу массива <имя массива> само может быть выражением, которое возвращает ссылку на массив. Например, следующее выражение обращается к элементу с индексом 1 символьного массива, возвращаемого методов toCharArray() класса String: "AHA".toCharArray()[1].

Оператор массива [ ] используется для объявления типа массива (Topping [ ]) задания размера массива (new Toppings[3]) и доступа к элементам массива toppings[1]. Этот оператор не используется для манипуляций со ссылкой на массив, например в присваивании ссылки на массив или когда ссылка на массив передается как фактический параметр при вызове метода.

Пример 4.1 демонстрирует проход по массивам. Цикл в строке (3) инициализирует локальный массив trialArray1, объявленный в (2), пять раз псевдослучайными числами (от 0.0 до 100.0), вызывая метод randomize О в строке (5). Минимальное значение массива находится вызовом метода findMinimum() в строке (6) и сохраняется в массиве storeMinimum, объявленном в (1). Цикл в (4) выводит на экран минимальные значения по попыткам. Начальное значение переменной цикла устанавливается в 0. Условие цикла проверяет, что переменная цикла меньше длины массива, что гарантирует, что индекс не выйдет за границы массива.

Пример 4.1. Использование массивов

class Trials {
    public static void main(String[] args) {
        // Declare and construct the local arrays
        double[] storeMinimum = new double[5];             // (1)
        double[] trialArray = new double[15];              // (2)
        for (int i = 0; i < storeMinimum.length; ++i) {    // (3)
            // Инициализация массива
            randomize(trialArray);
            // Поиск и запись минимального значения
            storeMinimum[i] = findMinimum(trialArray);
        }
        // Печать минимальных значений                        (4)
        for (int i = 0; i < storeMinimum.length; ++i)
            System.out.println(storeMinimum[i]);
    }

    public static void randomize(double[] valArray) {      // (5)
        for (int i = 0; i < valArray.length; ++i)
            valArray[i] = Math.random() * 100.0;
    }

    public static double findMinimum(double[] valArray) {  // (6)
        // Предполагаем, что массив имеет хотя бы 1 элемент
        double minValue = valArray[0];
        for (int i = 1; i < valArray.length; ++i)
            minValue = Math.min(minValue, valArray[i]);
        return minValue;
    }
}

Вывод программы:

6.756931310985048
5.364063199341363
8.359410202984296
8.858272848258109
9.759950059619849

Анонимные массивы

Как показано выше в этом разделе, следующая строка объявления вместе с выражением создания массива

<тип_элемента1>[] <имя_массива> = new <тип_элемента2>[<размерность_массива>]; // (1)
int[] intArray = new int[5];

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

 <тип_элемента>[] <имя_массива> = { <Инициализирующий список массива> }; // (2)
int[] intArray = { 3, 5, 2, 8, 6 };

как создает массив, так и инициализирует его элементами, задавая значения в блоке инициализации. Однако инициализационный блок массива не является выражением. В Java есть другое выражение создания массива, называемое анонимным массивом, которое позволяет объединить выражения создания массива из (1) и блок инициализации из (2), чтобы создать и проинициализировать объект-массив.

new <тип_элемента>[] { <Инициализирующий список массива> }
new int[]{ 3, 5, 2, 8, 6 };

В данной конструкции достаточно информации для создания безымянного массива определенного типа. Ни имя, ни размер массива не задаются. Конструкция возвращает ссылку на массив, которая может быть затем присвоена или передана как параметр в метод.

В частности, следующие два примера предложений объявления эквивалентны.

int[] intArray = { 3, 5, 2, 8, 6 };           // (1)
int[] intArray = new int[]{ 3, 5, 2, 8, 6 };  // (2)

В (1) для создания и инициализации элементов массива применяется блок инициализации. В (2) используется выражение анонимного массива. Заманчиво использовать блок инициализации массива как выражение (например, в строке присваивания в качестве краткого решения одновременного присвоения значений элементам массива). Но это недопустимо, вместо такого способа следует использовать выражения анонимного массива.

int[] daysInMonth;
daysInMonth = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; // Не годится.
daysInMonth = new int[]{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; // ok.

Идея анонимных массивов подобна идее анонимных классов: они обе объединяют описание и инициализацию классов в одном процессе.

В примере 4.2 анонимный массив создается в строке (1) и передается как параметр в статический метод findMinimum(), определенный в (2). Обратите внимание, что ни имя массива, ни размер массива не задаются для анонимного массива.

Пример 4.2. Использование анонимных массивов

class AnonArray {
    public static void main(String[] args) {
        System.out.println("Minimum value: " +
                findMinimum(new int[]{ 3, 5, 2, 8, 6 }));           // (1)
    }

    public static int findMinimum(int[] dataSeq) {                   // (2)
        // Пологаем, что массив имеет хотябы 1 элемент
        int min = dataSeq[0];
        for (int index = 1; index < dataSeq.length; ++index)
            if (dataSeq[index] < min)
                min = dataSeq[index];
        return min;
    }
}

Вывод программы:

Minimum value: 2