Обход двумерного массива java

Многомерные массивы в Java

Многомерный массив в Java — это массив, состоящий из массивов разного размера в качестве элементов. Его также называют «массивом массивов», «рваным массивом» или «зубчатым массивом».

В этом кратком руководстве мы более подробно рассмотрим определение многомерных массивов и работу с ними.

2. Создание многомерного массива​

Давайте начнем с рассмотрения способов создания многомерного массива:

2.1. Сокращенная форма​

Простой способ определить многомерный массив:

 int[][] multiDimensionalArr = 1, 2>, 3, 4, 5>, 6, 7, 8, 9>>; 

Здесь мы объявили и инициализировали multiDimensionalArr за один шаг.

2.2. Декларация, а затем инициализация​

Начнем с объявления многомерного массива размера три:

 int[][] multiDimensionalArr = new int[3][]; 

Здесь мы не указали второе измерение, поскольку оно будет варьироваться .

Далее, давайте пойдем дальше, объявив и инициализировав соответствующие элементы в multiDimensionalArr :

 multiDimensionalArr[0] = new int[] 1, 2>;  multiDimensionalArr[1] = new int[] 3, 4, 5>;  multiDimensionalArr[2] = new int[] 6, 7, 8, 9>; 

Мы также можем просто объявить его элементы без их инициализации:

 multiDimensionalArr[0] = new int[2];  multiDimensionalArr[1] = new int[3];  multiDimensionalArr[2] = new int[4]; 

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

Мы также можем использовать метод java.util.Arrays.fill для инициализации элементов массива:

 void initialize2DArray(int[][] multiDimensionalArray)    for (int[] array : multiDimensionalArray)    Arrays.fill(array, 7);   >   > 

Все элементы в массивах инициализируются одним и тем же значением.

3. Представление памяти​

Как будет выглядеть представление в памяти нашего multiDimensionalArr ?

Как известно, массив в Java — это не что иное, как объект, элементами которого могут быть как примитивы, так и ссылки. Итак, двумерный массив в Java можно рассматривать как массив одномерных массивов.

Наш multiDimensionalArr в памяти будет выглядеть примерно так:

Ясно, что multiDimensionalArr [0] содержит ссылку на одномерный массив размера 2, multiDimensionalArr[1] содержит ссылку на другой одномерный массив размера 3 и так далее.

Таким образом, Java позволяет нам определять и использовать многомерные массивы.

4. Перебор элементов​

Мы можем перебирать многомерный массив так же, как любой другой массив в Java.

Давайте попробуем повторить и инициализировать элементы multiDimensionalArr , используя пользовательские данные:

 void initializeElements(int[][] multiDimensionalArr)    Scanner sc = new Scanner(System.in);   for (int outer = 0; outer  multiDimensionalArr.length; outer++)    for (int inner = 0; inner  multiDimensionalArr[outer].length; inner++)    multiDimensionalArr[outer][inner] = sc.nextInt();   >   >   > 

Здесь multiDimensionalArr[outer].length — это длина массива по внешнему индексу в multiDimensionalArr .

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

5. Элементы печати​

Что, если мы хотим напечатать элементы нашего многомерного массива?

Одним из очевидных способов было бы использование логики итерации, которую мы уже рассмотрели. Это включает в себя итерацию по каждому элементу в нашем многомерном массиве, который сам является массивом, а затем итерацию по этому дочернему массиву — по одному элементу за раз.

Другой вариант, который у нас есть, — использовать вспомогательный метод java.util.Arrays.toString() :

 void printElements(int[][] multiDimensionalArr)    for (int index = 0; index  multiDimensionalArr.length; index++)    System.out.println(Arrays.toString(multiDimensionalArr[index]));   >   > 

И в итоге мы получаем чистый и простой код. Сгенерированный вывод консоли будет выглядеть так:

6. Длина элементов​

Мы можем найти длину массивов в многомерном массиве, перебирая основной массив:

 int[] findLengthOfElements(int[][] multiDimensionalArray)    int[] arrayOfLengths = new int[multiDimensionalArray.length];   for (int i = 0; i  multiDimensionalArray.length; i++)    arrayOfLengths[i] = multiDimensionalArray[i].length;   >   return arrayOfLengths;   > 

Мы также можем найти длину массивов, используя потоки Java:

 Integer[] findLengthOfArrays(int[][] multiDimensionalArray)    return Arrays.stream(multiDimensionalArray)   .map(array -> array.length)   .toArray(Integer[]::new);   > 

7. Скопируйте двумерный массив​

Мы можем скопировать двумерный массив с помощью метода Arrays.copyOf :

 int[][] copy2DArray(int[][] arrayOfArrays)    int[][] copied2DArray = new int[arrayOfArrays.length][];   for (int i = 0; i  arrayOfArrays.length; i++)    int[] array = arrayOfArrays[i];   copied2DArray[i] = Arrays.copyOf(array, array.length);   >   return copied2DArray;   > 

Мы также можем добиться этого, используя потоки Java:

 Integer[][] copy2DArray(Integer[][] arrayOfArrays)    return Arrays.stream(arrayOfArrays)   .map(array -> Arrays.copyOf(array, array.length))   .toArray(Integer[][]::new);   > 

8. Заключение​

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

Как всегда, исходный код представленных примеров можно найти на GitHub .

Источник

Массивы в Java: создаём, заполняем, применяем

Учимся работать с массивами в Java. Всё разбираем на примерах.

Массив в Java (Java Array) — это структура данных, которая хранит набор пронумерованных значений одного типа (элементы массива).

Допустим, у нас есть класс из десяти учеников и нам нужно сохранить их оценки. Для этого можно создать десять переменных:

int mark1 = 4; int mark2 = 3; int mark3 = 5; int mark4 = 3; int mark5 = 2; int mark6 = 4; int mark7 = 4; int mark8 = 3; int mark9 = 4; int mark10 = 2;

А если в нашем классе будет не десяток учеников, а в десять раз больше, не заводить же нам 100 переменных! На выручку приходят массивы.

Как создать одномерный массив

В Java массив объявляется с помощью квадратных скобок и специального слова new.

Такой вот синтаксис пришёл из языка C:

тип_массива название_переменной[] = new тип_массива[размер_массива];

Но в Java предпочтительнее делать так:

тип_массива[] название_переменной = new тип_массива[размер_массива];

Тип массива может быть любым (int, Integer, String, Date, byte, char, Long и так далее).

Инициализация массива по умолчанию

Объявим массив типа int из 10 элементов:

При подобной инициализации все элементы массива будут иметь значение по умолчанию. Для int это 0; для float и double — 0.0; для char — \0; для boolean — false, а для String и любого другого класса это null.

В Java размер массива (длина, протяжённость) определяется при объявлении, а изменить его можно только пересоздав массив.

Доступ к элементам массива

Начнём с одномерного массива. Каждый элемент в нём хранится под своим индексом.

Важно помнить, что в Java нумерация элементов массива начинается с 0. Поэтому индекс первого элемента равен 0, а у последнего определяется размером массива минус один.

Для доступа к элементу массива указывают имя массива и номер ячейки в квадратных скобках. Например, обратимся к первому элементу массива и выведем его значение:

int[] marks = new int[10]; System.out.println(marks[0]); --OUTPUT> 0

В консоли мы получим число 0. Почему ноль — читайте выше, в пункте про инициализацию по умолчанию.

Заполним элементы массива. Для этого обратимся к каждому по индексу и присвоим значения с помощью оператора «=»:

int[] marks = new int[10]; marks[0] = 5; marks[1] = 3; marks[2] = 5; marks[3] = 3; marks[4] = 4; marks[5] = 4; marks[6] = 3; marks[7] = 2; marks[8] = 5; marks[9] = 4;

Инициализация массива на этапе объявления

Теперь у нас есть массив, куда мы записали оценки десяти учеников. С этим уже удобнее работать, чем объявлять 10 переменных, но можно записать ещё короче:

int[] marks = new int[] 5, 3, 5, 3, 4, 4, 3, 2, 5, 4>;

Мы опустили размер массива, поставили фигурные скобки после квадратных и перечислили все значения через запятую. Размер массива теперь определяется числом элементов в фигурных скобках (в нашем случае их тоже 10).

Но нет предела совершенству:

int[] marks = 5, 3, 5, 3, 4, 4, 3, 2, 5, 4>;

После знака «=» остались только фигурные скобки с перечислением значений через запятую.

Обход одномерного массива

У массива в Java есть специальное поле length. Значение в нём нельзя изменить. Оно возвращает число элементов массива:

int[] marks = 5, 3, 5, 3, 4, 4, 3, 2, 5, 4>; System.out.println("Всего оценок: " + marks.length); --OUTPUT> Всего оценок: 10

А раз мы знаем длину массива и что все его ячейки упорядочены, то остаётся обратиться к ним по очереди — в цикле:

int[] marks = 5, 3, 5, 3, 4, 4, 3, 2, 5, 4>; for (int i = 0; i < marks.length; i++) < System.out.printf("Ученик №%d: оценка %d%n", (i + 1), marks[i]); > --OUTPUT> Ученик №1: оценка 5 --OUTPUT> Ученик №2: оценка 3 --OUTPUT> Ученик №3: оценка 5 --OUTPUT> Ученик №4: оценка 3 --OUTPUT> Ученик №5: оценка 4 --OUTPUT> Ученик №6: оценка 4 --OUTPUT> Ученик №7: оценка 3 --OUTPUT> Ученик №8: оценка 2 --OUTPUT> Ученик №9: оценка 5 --OUTPUT> Ученик №10: оценка 4

С помощью счётчика в цикле for мы получаем индекс каждого элемента.

Напомним! Счётчик должен стартовать с 0, так как нумерация в массиве тоже начинается с 0.

И цикл будет продолжаться «пока счётчик меньше размера массива», а раз индекс последнего элемента на один меньше их количества, то выхода за границы массива в нашем цикле не произойдёт.

int[] marks = 5, 3, 4>; String[] names = "Вася", "Петя", "Маша">; for (int i = 0; i < marks.length; i++) < System.out.printf("%s получает оценку %d%n", names[i], marks[i]); > --OUTPUT> Вася получает оценку 5 --OUTPUT> Петя получает оценку 3 --OUTPUT> Маша получает оценку 5

Массив можно обойти и в цикле foreach (подробнее о циклах):

int[] marks = 5, 3, 5, 3, 4, 4, 3, 2, 5, 4>; for (int mark : marks) < System.out.printf("Оценка %d%n", mark); > --OUTPUT> Оценка 5 --OUTPUT> Оценка 3 --OUTPUT> Оценка 5 --OUTPUT> Оценка 3 --OUTPUT> Оценка 4 --OUTPUT> Оценка 4 --OUTPUT> Оценка 3 --OUTPUT> Оценка 2 --OUTPUT> Оценка 5 --OUTPUT> Оценка 4

int[] marks = 5, 3, 5, 3, 4, 4, 3, 2, 5, 4>; for (int i = marks.length - 1; i >= 0; i--) < System.out.printf("Ученик №%d: оценка %d%n", (i + 1), marks[i]); >

Здесь счётчик стартует со значения на один меньше размера массива, и цикл продолжается «пока счётчик не меньше 0».

Можем пройтись и только по элементам с чётными индексами:

int[] marks = 5, 3, 5, 3, 4, 4, 3, 2, 5, 4>; for (int i = 0; i < marks.length; i += 2) < System.out.printf("Ученик №%d: оценка %d%n", (i + 1), marks[i]); >

А вот как заполнить массив случайными значениями:

int[] marks = new int[10]; Random random = new Random(); for (int i = 0; i < marks.length; i ++) < marks[i] = 2 + random.nextInt(4); >

N-мерные массивы

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

Массивы бывают одномерными (векторы), двумерными (матрицы), трёхмерными и так далее. То есть можно создавать не просто массивы, но и массивы массивов, а также массивы массивов массивов и так далее.

Рассмотрим вариант с двумерным массивом. Остальные многомерные массивы создаются похоже.

Объявление двумерного массива

Чтобы создать двумерный массив в Java, укажем его размеры в квадратных скобках:

Доступ к элементу подобного массива выглядит так:

int[][] mas = new int[3][4]; mas[0][1] = 2;

Мы присвоили значение 2 элементу с индексами [0,1].

Для простоты представим двумерный массив в виде таблицы. Вот как выглядит наш массив (столбцы — это первый индекс в квадратных скобках, а строки — второй):

[0,0] = 0	[1,0] = 0	[2,0] = 0
[0,1] = 2	[1,1] = 0	[2,1] = 0
[0,2] = 0	[1,2] = 0	[2,2] = 0
[0,3] = 0	[1,3] = 0	[2,3] = 0

Несложно представить двумерный массив таблицей, а трёхмерный — кубом, но вот с массивами большей размерности так уже не получится.

Массивы внутри массива в Java могут быть разной длины. Зададим двумерный массив, где размер третьего массива (по индексу второго) равен двум элементам, а размер всех остальных — трём:

int[][] mas2 = 1, 3, 5>, 1, 3, 4>, 1, 3>>;

Как помним, размер массива нам не изменить, но мы можем присвоить новый массив элементу с нужным индексом.

Если мы объявляем двумерный массив так:

то размер каждого вложенного массива будет равен четырём элементам.

А теперь заменим массив под индексом 1 (длиной в четыре элемента) массивом из двух элементов:

int[][] mas = new int[3][4]; mas[1] = new int[2];

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

Проверим, что размер массива под индексом 1 теперь равен двум элементам. Для этого используем цикл с выводом в консоль:

for (int i = 0; i < mas.length; i++) < System.out.printf("Индекс массива в двумерном массиве: %d; длина массива: %d%n", i, mas[i].length); > --OUTPUT> Индекс массива в двумерном массиве: 0; длина массива: 4 --OUTPUT> Индекс массива в двумерном массиве: 1; длина массива: 2 --OUTPUT> Индекс массива в двумерном массиве: 2; длина массива: 4

Для обхода элементов двумерного массива применяем уже два цикла:

Источник