Массивы в Java

Last updated: 2 мая 2025 г.

Рассмотрим массивы.

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

А что если мы хотим иметь переменную в которой будет храниться 100 разных числовых значений?

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

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

int[] a;

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

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

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

a = new int[5];

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

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

int[] a = new int[5];

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

int[] b = {56, 3, 7, 63, 13};

Заранее с помощью 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}

Вывод:

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

Выведем все элементы массива b по порядку с помощью for.

Любой массив имеет внутри себя переменную 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 нам не нужно знать размер массива.

В примере ниже цикл 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 мы изменяем элемент массива

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

Также массивы бывают многомерными.

То есть представьте массив в котором каждый элемент это массив чисел.

Такой массив чисел, который мы разбирали только что.

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

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

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

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

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

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

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

System.out.println(b[1][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        // на каждом цикле этого foreach происходит запись в single2DSubArray 
15        // одного из массивов двумерного массива b
16        for(int [] single2DSubArray : b){
17            // Во внутреннем foreach ниже
18            // по очереди извлекаются числа массива single2DSubArray.
19            // Пока мы находимся внутри любой из итераций внешнего foreach
20            // в single2DSubArray записан один из подмассивов двумерного массива b.
21
22            // извлекаем числа из single2DSubArray внутренним foreach ниже
23            for(int singleArrayElement : single2DSubArray){
24                // Через запятую выводим числа подмассива single2DSubArray
25                System.out.print(singleArrayElement + ", ");
26            }
27            // После обработки каждого подмассива внутренним for-each 
28            // переходим на новую строку с помощью \n.
29            // Это позволяет визуально отделить выводимые подмассивы 
30            // друг от друга при выводе в консоль
31            System.out.println("\n");
32        }
33    }
34}