Массивы в Java

В этом уроке мы познакомимся с массивами в Java: разберём их концепцию, научимся с ними взаимодействовать и узнаем, какие типы массивов бывают.

В прошлых уроках у нас была переменная int a=31 хранящая одно число 31.

Такая переменная называется массивом.

Объявляется массив так:

[] значат, что это массив и в нем будет храниться много значений (значений типа int в данном случае).

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

Ключевым словом new мы выделяем память под массив, который может вмещать максимум 5 элементов.

После этого можно записывать в эту память числа.

Объявление и выделение памяти можно записать в одну строку как:

Также можно при создании массива сразу записать в них значения.

Заранее с помощью new память под эти значения выделять не нужно, так как мы сразу записываем в память значения.

Взаимодействие с массивом

Итак рассмотрим как мы можем взаимодействовать с массивом.

Ниже в примере программы создается массив b, который содержит 5 числовых значений.

Каждое из пяти значений имеет свой порядковый номер в массиве:

56 – имеет номер 0, 3 – имеет номер 1, 7 – имеет номер 2, 63 – имеет номер 3, 13 – имеет номер 4. Очевидно, что номера элементам массива выдаются по порядку, то есть первому элементу в массиве номер ноль, второму номер 1, третьему элементу номер 2 и т.д.

Также как видим порядковый номер в массивах начинается с нуля, а не единицы.

Правильно этот порядковый номер в массиве называть индексом.

Поясним на примере:

1class Test
2{
3    public static void main(String []args)
4    {
5        int[] b = {56, 3, 7, 63, 13};
6        
7        // По индексу мы можем взаимодействовать
8        // с элементами массива.
9
10        // Например, ниже мы записываем
11        // в элемент массива с индексом 1 число 33.
12        // Индекс указывается в квадратных скобках.
13        // Теперь вместо 3 теперь будет 33.
14        b[1] = 33;
15
16        // Можно обратиться к элементу по индексу
17        // чтобы его использовать каким-то образом.
18        // Например, вывести на консоль как ниже.
19        System.out.println(b[1]);
20    }
21}

Вывод:

Обход массива циклом

Любой массив имеет внутри себя переменную length в которой храниться количество элементов массива. Это можно использовать для обхода элементов циклом.

Поясним на примере:

1class Test
2{
3    public static void main(String []args)
4    {
5        int[] b = {56, 3, 7, 63, 13};
6
7        //В данном случае b.length равно 5,
8        //так как в массиве пять элементов.
9        //Условие цикла как видим, такое, что пока i
10        //меньше длины массива (то есть пяти)
11        //цикл for продолжает свое выполнение.
12        for(int i=0; i < b.length; i++)
13        {
14            //Каждую итерацию цикла i увеличивается на 1,
15            //и эту i мы помещаем в квадратные скобки в качестве индекса
16            //для извлечения каждого элемента массива по индексу
17            //на каждой итерации.
18            //То есть на первой итерации на консоль выводится
19            //значение элемента b[0], на второй итерации значение
20            //элемента b[1] и т.д. до b[4]
21            System.out.println(b[i]);
22        }
23    }
24};

Вывод:

Как видим, можно легко пройтись по элементам массива и совершать с каждым какие-то действия на каждой итерации. Например, выводить на консоль каждый элемент, как в приведенном примере.

Обход массива циклом for-each

Для обхода элементов массива можно использовать особенный вид for цикла.

Называется он for-each.

В примере ниже цикл foreach начиная с первого элемента массива b поочереди берет элементы и помещает их в singleArrayElement

1class Test
2{
3    public static void main(String []args)
4    {
5        int[] b = {56, 3, 7, 63, 13};
6
7        for(int singleArrayElement : b){
8            System.out.println(singleArrayElement);
9        }
10    }
11}

Вывод:

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

Важно знать: singleArrayElement — это копия значения элемента массива, а не сам элемент. Это означает, что изменяя singleArrayElement в теле цикла, вы не изменяете сам массив.

Однако, если массив содержит объекты (которые мы ещё не проходили), а не простые типы данных, то for-each работает с самим объектом, а не с его копией

Двумерные массивы

Представьте одномерный массив, в котором каждый элемент — это полноценный одномерный массив чисел, такой же, как мы рассматривали выше.

То есть это массив массивов чисел, и он называется двумерным массивом.

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

1int[][] b = {
2    {56, 3, 63, 13},
3    {3,67,2},
4    {5,5,3,7,9}
5};

Как же получить доступ к числам подмассивов?

В первой скобочке мы пишем индекс нужного нам подмассива.

Во второй скобочке пишем индекс нужного нам элемента (в нашем случае числа) этого подмассива.

Пример: строка кода ниже достает из массива b число 2. Мы обращаемся ко второму подмасиву, к третьему элементу этого подмассива.

Помним что элементы в массивах нумеруются начиная с нуля. Поэтому 1 и 2, а не 2 и 3.

Полный пример:

1class Test
2{
3    public static void main(String []args)
4    {
5        // Ниже пример двумерного массива.
6        // Как видим, через запятую перечислены массивы чисел.
7        int[][] b = {
8            {56, 3, 63, 13},
9            {3, 67, 2},
10            {5, 5, 3, 7, 9}
11        };
12
13        // Выведем третий элемент во втором подмассиве.
14        System.out.println(b[1][2]);
15    }
16}

Вывод:

Обход двумерного массива циклом

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

Для простоты воспользуемся for-each. Ниже показано, как с помощью вложенных циклов пройтись по всем числам в двумерном массиве и вывести их на консоль.

Пример программы:

1class Test
2{
3    public static void main(String []args)
4    {
5        int[][] b = {
6            {56, 3, 63, 13},
7            {3, 67, 2},
8            {5, 5, 3, 7, 9}
9        };
10
11        System.out.println(b[1][2]);
12
13        // Внешний foreach по очереди записывает в single2DSubArray
14        // один из подмассивов двумерного массива b. Таким образом
15        // single2DSubArray перезаписываеться новым подмассивом каждую итерацию.
16        for(int [] single2DSubArray : b){
17            // Внутренний foreach ниже перебирает числа из текущего подмассива,
18            // который внешним foreach был записан в переменную single2DSubArray.
19            for(int singleArrayNumber : single2DSubArray){
20                // Через запятую выводим числа подмассива в single2DSubArray
21                System.out.print(singleArrayNumber + ", ");
22            }
23            // После обработки каждого подмассива внутренним for-each 
24            // происходит переход на новую строку с помощью \n.
25            // Это позволяет визуально отделить выводимые подмассивы 
26            // друг от друга при выводе в консоль.
27            System.out.println("\n");
28        }
29    }
30}

Вывод: