Мы научились создавать одномерные массивы. Подобным образом в Java можно создать двумерный, трехмерный, четырехмерный… иначе говоря, многомерные массивы. Многомерный массив в Java по сути является массивом из массивов.
Популярным примером использования такого рода массивов, являются матрицы, для представления которых, используются двумерные массивы. Итак, что же такое матрица и как ее представить с помощью двумерного массива в Java.
Матрицы и двумерные массивы в Java
Матрица это прямоугольная таблица, состоящая из строк и столбцов на пересечении которых находятся её элементы. Количество строк и столбцов матрицы задают ее размер.
Общий вид матрицы размером m x n (m — количество строк, n — количество столбцов), выглядит следующим образом:
Каждый элемент матрицы имеет свой индекс, где первая цифра обозначает номер строки на которой находится элемент, а вторая — номер столбца.
Рассмотрим примеры конкретных матриц и создадим их с помощью Java.
Матрица A имеет размерность 2 на 3 (2 строки, 3 столбца). Создадим двухмерный массив этой размерности:
Int matrixA; matrixA = new int ;
Мы объявили двумерный массив целых чисел (поскольку матрица в данном случае содержит целые числа) и зарезервировали для него память. Для этого мы использовали 2 индекса: первый индекс определяет строку и ее размер, второй индекс определяет столбец и его размер.
Для доступа к элементам двумерного массива необходимо использовать 2 индекса: первый для строки, второй – для столбца. Как и в случае с одномерными массивами, индексы также начинаются с нуля. Поэтому нумерация строк и столбцов в таблице начинается с 0.
MatrixA = 1; matrixA = -2; matrixA = 3; matrixA = 4; matrixA = 1; matrixA = 7;
Для того, чтобы вывести матрицу на консоль, нужно пройти все элементы, используя два цикла. Количество циклов, при прохождении элементов массива, равно его размерности. В нашем случае первый цикл осуществляется по строкам, второй — по столбцам.
For (int i = 0; i < 2; i++) { for (int j = 0; j < 3; j++) { System.out.print(matrixA[i][j] + "\t"); } System.out.println(); }
То есть, сначала выводим все элементы первой строки, отделяя их символом табуляции "\t", переносим строку и выводим все элементы второй строки.
Полностью код для матрицы А выглядит следующим образом:
Public class Matrix { public static void main(String args) { int matrixA; matrixA = new int; matrixA = 1; matrixA = -2; matrixA = 3; matrixA = 4; matrixA = 1; matrixA = 7; for (int i = 0; i < 2; i++) { for (int j = 0; j < 3; j++) { System.out.print(matrixA[i][j] + "\t"); } System.out.println(); } } }
Для матрицы B воспользуемся упрощенным способом инициализации — в момент объявления. По аналогии с одномерными массивами.
Int matrixB = { {-9,1,0}, {4,1,1}, {-2,2,-1} };
Каждую строку массива необходимо заключить в пару фигурных скобок и отделить друг от друга запятой.
Полностью код для матрицы B :
Public class Matrix { public static void main(String args) { int matrixB = { {-9,1,0}, {4,1,1}, {-2,2,-1} }; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { System.out.print(matrixB[i][j] + "\t"); } System.out.println(); } } }
Рассмотрим инициализацию в цикле для двумерного массива на примере таблицы умножения.
Public class Mult { public static void main(String args) { // создаем двумерный массив 10 на 10 int multiplyTab = new int; // цикл по первой размерности for (int i = 0; i < 10; i++) { // цикл по второй размерности for (int j = 0; j < 10; j++) { //инициализация элементов массива multiplyTab[i][j] = (i+1)*(j+1); //вывод элементов массива System.out.print(multiplyTab[i][j] + "\t"); } System.out.println(); } } }
Здесь инициализация элементов значениями таблицы умножения совмещена с их выводом на консоль в одном цикле.
Многомерные и несимметричные массивы.
Создаются многомерные массивы в Java аналогичным способом. Количество квадратных скобок указывает на размерность.
Примеры создания массивов фиксированной длины:
Int a = new int;// двумерный массив int b = new int;// трехмерный массив int c = new int;// четырехмерный массив // и т.д.
Однако, не обязательно изначально указывать размер на всех уровнях, можно указать размер только на первом уровне.
Int a1 = new int;// двумерный массив с 5 строками
В данном случае, пока неизвестно сколько будет элементов в каждой строке, это можно определить позже, причем, массив может содержать в каждой строке разное количество элементов, то есть быть несимметричным . Определим количество элементов в каждой строке для массива a1
A1 = new int ; a1 = new int ; a1 = new int ; a1 = new int ; a1 = new int ;
В результате, при выводе на экран,
For(int i = 0; i массив будет иметь такой вид: 0 При создании массива его элементы автоматически инициализируются нулями, поэтому в это примере на экран выведены нули. Для примера рассмотрим двумерный массив в Java. Двумерные массивы Java - это прямоугольная или не прямоугольная таблица чисел. Двумерный массив Java состоит из рядов и столбцов. Первый индекс двумерного массива Java - это число рядов. Пример двумерного прямоугольного массива Java: Int multyArr;
multyArr = new int;
/*
* multyArr structure
* | (0,0) | (0,1) |
* | (1,0) | (1,1) |
*/
Здесь объявлен и определен двумерный массив, имеющий две строки и два столбца. Загрузим массив элементами: MultyArr = 1;
multyArr = 2;
multyArr = 3;
multyArr = 4;
Вывод двумерного массива (перебираем массив): System.out.println("multyArr");
for(int inn = 0; inn < 2; inn++)
{
for(int jnn = 0; jnn < 2; jnn++)
{
System.out.println("multyArr[" + inn + "][" + jnn + "] = " + multyArr );
}
}
Получаем:
for(int inn = 0; inn < 2; inn++) мы проходим по рядам, а в цикле for(int jnn = 0; jnn < 2; jnn++) по столбцам. Можно объявить и определить многомерный массив одновременно: int multyArr = {{1,2}, {3,4}}; Int multyArr = {{1,2}, {3,4}, {5,6}};
/*
* multyArr structure
* | 1 | 2 |
* | 3 | 4 |
* | 5 | 6 |
*/
System.out.println("Array length = " + multyArr.length);
Array length = 3 Здесь три ряда по два элемента каждый. Первая размерность - три, это и есть длина двумерного массива. Пример трехмерного массива в Java: int triArray; Здесь объявлен и определен трехмерный массив. Его можно представит как куб, состоящий из двух слоёв (layer), каждый слой состоит из двух рядов и двух столбцов, т.е. каждый слой - это двумерный массив. Как заполнить трехмерный массив? Можно в цикле, но мы для примера вручную заполним: Как вывести трехмерный массив? Или как перебрать трехмерный массив? Так. Массивы
(arrays) _ это упорядоченные наборы элементов одного типа. Элементами массива могут служить объекты простых и ссылочных типов, в том Числе и ссылки на другие массивы. Массивы сами по себе являются объектами и наследуют класс Object. Объявление int ia = new int; Определяет массив с именем ia, который изначально указывает на набор из трех Элементов типа int. В объявлении массива его размерность не указывается. Количество элементов массива задается при его создании посредством оператора new. Длина массива фиксируется в момент создания и в дальнейшем изменению не поддается. Впрочем, переменной
типа массива (в нашем примере – ia) в любой момент может быть поставлен в соответствие новый массив с другой размерностью. Доступ к элементам массива осуществляется по значениям их номеров-индексов. Первый элемент массива имеет индекс, равный нулю (0), а последний – length – 1. Обращение к элементу массива выполняется посредством задания имени массива и значения индекса, заключенного в квадратные скобки, [ и ]. в предыдущем примере первым элементом массива ia будет ia, а последним – ia. При каждом обращении к элементу массива по индексу исполняющая система Java проверяет, находится ли значение индекса в допустимых пределах, и генерирует исключение типа ArraylndexOutOfBoundsException, если результат проверки ложен. 6 Выражение индекса должно относиться к типу int – только этим и ограничивается максимальное количество элементов массива. Длину массива легко определить с помощью поля length объекта массива (которое неявно снабжено признаками publiс и final). Ниже приведен дополненный код прежнего примера, в котором предусмотрено выполнение Цикла, обеспечивающего вывод на экран содержимого каждого элемента массива ia: for (int i = о; i < ia.length; i++) system.out.println(i + ": " + ia[i]); Массив нулевой длины (т.е. такой, в котором нет элементов) принято называть пустым.
Обратите внимание, что ссылка на массив, равная значению null, и ссылка на пустой массив – это совершенно разные вещи. Пустой массив это реальный массив, в котором попросту отсутствуют элементы. Пустой массив представляет собой удобную альтернативу значению null при возврате из метода. Если метод способен возвращать null, прикладной код, в котором выполняется обращение к методу, должен сравнить возвращенное значение с null прежде, чем перейти к выполнению оставшихся операций. Если же метод возвращает массив (возможно, пустой), никакие дополнительные проверки не нужны – разумеется, помимо тех, которые касаются длины массива и должны выполняться в любом случае. Допускается и иная форма объявления массива, в которой квадратные скобки задаются после идентификатора массива, а не после наименования его типа: int ia = new int; Прежний синтаксис, однако, считается более предпочтительным, поскольку описание типа в таком случае выглядит более компактным. Модификаторы в объявлениях массивов
Правила употребления в объявлениях массивов тех или иных модификаторов
обычны и зависят только от того, к какой категории относится массив – к полям или Локальным переменным. Существует единственная особенность, которую важно помнить, – модификаторы применяются к массиву как таковому, но не к его отдельным элементам. Если в объявлении массива указан признак final, это значит только то, что ссылка на массив не может быть изменена после его создания, но никак не запрещает возможность изменения содержимого отдельных элементов массива. Язык не позволяет задавать каких бы то ни было модификаторов (скажем, final или уоlatilе) для элементов массива. Многомерные массивы
В Java поддерживается возможность объявления многомерных массивов
(multidimensional arrays) (т.е. массивов, элементами которых служат другие массивы), Код, предусматривающий объявление двумерной матрицы и вывод на экран содержимого ее элементов, может выглядеть, например, так: float mat = new float; setupMatrix(mat); for (int у = о; у < mat.length; у++) { for (int х = о; х < mat[y].length; х++) system.out.print(mat[y][x] + " "); system.out.println(); При создании массива должна быть указана, по меньшей мере, его первая, "самая левая", размерность. Другие размерности разрешается не задавать – в этом случае их придется определить позже. Указание в операторе new единовременно всех размерностей – это самый лаконичный способ создания массива, позволяющий избежать необходимости использования дополнительных операторов new. Выражение объявления и создания массива mat, приведенное выше, равнозначно следующему фрагменту кода: float mat = new float; for (int у = о; у < mat.length; у++) mat[y] = new float; Такая форма объявления обладает тем преимуществом, что позволяет наряду с получением массивов с одинаковыми размерностями (скажем, 4 х 4) строить и массивы массивов различных размерностей, необходимых для хранения тех или иных последовательностей данных. Инициализация массивов
При создании массива каждый его элемент получает значение, предусмотренное по умолчанию и зависящее от типа массива: нуль (0) – для числовых типов, ‘\u0000′ _ для char, false – для boolean и null – для ссылочных типов. Объявляя массив ссылочного типа, мы на самом деле определяем массив переменных
этого типа. Рассмотрим следующий фрагмент кода: Attr attrs = new Attr; for (int i = о; i < attrs.length; i++) attrs[i] = new Attr(names[i], values[i]); После выполнения первого выражения, содержащего оператор new, переменная attrs получит ссылку на массив из 12 переменных, которые инициализированы значением null, Объекты Attr как таковые будут созданы только в процессе про хождения цикла. Массив может инициализироваться (одновременно с объявлением) посредством конструкции в фигурных скобках, в которой перечислены исходные Значения его элементов: String dangers = { "Львы", "Тигры", "Медведи" }; Следующий фрагмент кода даст тот же результат: String dangers = new String; dangers = "Львы"; dangers = "Тигры"; dangers = "Медведи"; Первая форма, предусматривающая задание списка инициализаторов в фигурных скобках, не требует явного использования оператора new – он вызывается косвенно исполняющей системой. Длина массива в этом случае определяется Количеством значений-инициализаторов. Допускается и возможность явного задания оператора new, но размерность все равно следует опускать она, как и раньше, определяется исполняющей системой: String dangers = new String { "Львы", "Тигры", "Медведи" }; Подобную форму объявления и инициализации массива разрешается применять в любом месте кода, например в выражении вызова метода: printStringsCnew String { "раз", "два", "три" }); Массив без названия, который создается таким образом, называют анонимным
(anonymous). Массивы массивов могут инициализироваться посредством вложенных последовательностей исходных значений. Ниже приведен пример объявления массива, содержащего несколько первых строк так называемого треугольника Паскаля,
где каждая строка описана собственным массивом значений. int pascalsTriangle = { { 1, 4, 6, 4, 1 }, Индексы многомерных массивов следуют в порядке от внешнего к внутренним. Так, например, pascalsTriangle);
// Пример для иллюстрации создания array class GFG // allocating memory for 5 integers. //so on... // accessing the elements of the specified array Element at index 0: 10
Element at index 1: 20
Element at index 2: 30
Element at index 3: 40
Element at index 4: 50
Массив объектов создается так же, как элементов данных следующим образом: Student arr = new Student;
StudentArray содержит семь элементов памяти каждый из класса student, в котором адреса семи объектов Student могут быть сохранены. Student объекты должны быть созданы с помощью конструктора класса student и их ссылки должны быть присвоены элементам массива следующим образом: Student arr = new Student;
// Java program to illustrate creating an array of class Student // Elements of array are objects of a class Student. // allocating memory for 5 objects of type Student. // initialize the first elements of the array // initialize the second elements of the array // so on... // accessing the elements of the specified array Получаем: Element at 0: 1 aman
Element at 1: 2 vaibhav
Element at 2: 3 shikar
Element at 3: 4 dharmesh
Element at 4: 5 mohit
Что произойдет, если мы попытаемся получить доступ к элементу за пределами массива? Многомерные массивы — это массивы массивов, каждый элемент которых содержит ссылку на другой массив. Создается путем добавления одного набора квадратных скобок () для каждого измерения. Рассмотрим пример: Int intArray = new int; //a 2D array or matrix
int intArray = new int; //a 3D array
class multiDimensional // printing 2D array System.out.println(); Output:
2 7 9
3 6 1
7 4 2
Как и переменные, мы можем передавать массивы в методы. // Java program to demonstrate
// passing of array to method
class Test
{
// Driver method
public static void main(String args)
{
int arr = {3, 1, 2, 5, 4};
// passing array to method m1
sum(arr);
}
public static void sum(int arr)
{
// getting sum of array values
int sum = 0;
for (int i = 0; i < arr.length; i++)
sum+=arr[i];
System.out.println("sum of array values: " + sum);
}
}
На выходе получим: sum of array values: 15 Как обычно, метод также может возвращать массив. Например, ниже программа возвращает массив из метода m1. // Java program to demonstrate
// return of array from method
class Test
{
// Driver method
public static void main(String args)
{
int arr = m1();
for (int i = 0; i < arr.length; i++)
System.out.print(arr[i]+" ");
}
public static int m1()
{
// returning array
return new int{1,2,3};
}
}
Каждый массив имеет связанный объект класса, совместно используемый со всеми другими массивами с тем же типом компонента. // Java program to demonstrate
// Class Objects for Arrays
class Test
{
public static void main(String args)
{
int intArray = new int;
byte byteArray = new byte;
short shortsArray = new short;
// array of Strings
String strArray = new String;
System.out.println(intArray.getClass());
System.out.println(intArray.getClass().getSuperclass());
System.out.println(byteArray.getClass());
System.out.println(shortsArray.getClass());
System.out.println(strArray.getClass());
}
}
class +" ");
}
}
}
Клон многомерного массива (например, Object ) является копией и это означает, что он создает только один новый массив с каждым элементом и ссылкой на исходный массив элементов, но вложенные массивы являются общими. // Java program to demonstrate
// cloning of multi-dimensional arrays
class Test
{
public static void main(String args)
{
int intArray = {{1,2,3},{4,5}};
int cloneArray = intArray.clone();
// will print false
System.out.println(intArray == cloneArray);
// will print true as shallow copy is created
// i.e. sub-arrays are shared
System.out.println(intArray == cloneArray);
System.out.println(intArray == cloneArray);
}
}
0 0
0 0 0
0 0 0 0
0 0 0 0 0Упражнения на тему многомерные массивы в Java:
Массив - это структура данных, в которой хранятся величины одинакового типа. Доступ к отдельному элементу массива осуществляется с помощью целого индекса. Например, если а - массив целых чисел, то значение выражения а [ i ] равно i-му целому числу в массиве.
Массив объявляется следующим образом: сначала указывается тип массива, т.е тип элементов, содержащихся в массиве, за которым ставится пара пустых квадратных скобок, а затем - имя переменной. Например, вот как объявляется массив, состоящий из целых чисел:
int
a;
Однако этот оператор лишь объявляет переменную а, не инициализируя ее настоящим массивом. Чтобы создать массив, нужно применить оператор new .
int
a =
new
int
[
100
]
;
Этот оператор создает массив, состоящий из 100 целых чисел. Элементы этого массива нумеруются от 0 до 99 (а не от 1 до 100). После создания массив можно заполнять, например, с помощью цикла.
int
а =
new
int
[
100
]
;
for
(int
i =
0
;
i <
100
;
i++
)
a[
i]
=
i;
//Заполняет массив числами от 0 до 99
Если вы попытаетесь обратиться к элементу а (или любому другому элементу, индекс которого выходит за пределы диапазона от 0 до 99), создав массив, состоящий из 100 элементов, программа прекратит работу, поскольку возникнет исключительная ситуация, связанная с выходом индекса массива за пределы допустимого диапазона.
Чтобы подсчитать количество элементов в массиве, используйте метод имя Массива.length .
Например,
for
(int
i =
0
;
i <
a.
length;
i++
,
System.
out.
println
(a[
i]
)
)
;
После создания массива изменить его размер невозможно (хотя можно, конечно, изменять отдельные его элементы). Если в ходе выполнения программы необходимо часто изменять размер массива, лучше использовать другую структуру данных, называемую списком массивов (array list).
Массив можно объявить двумя способами:
int
a;
или
int
a
;
Большинство программистов на языке Java предпочитают первый стиль, поскольку в нем четче отделяется тип массива int (целочисленный массив) от имени переменной.
Инициализаторы массивов и безымянные массивы
В языке Java есть средство для одновременного создания массива и его инициализации. Вот пример такой синтаксической конструкции:
int
smallPrimes =
{
2
,
3
,
5
,
7
,
11
,
13
}
;
Отметим, что в этом случае не нужно применять оператор new . Кроме того, можно даже инициализировать безымянный массив:
new
int
{
16
,
19
,
23
,
29
,
31
,
37
}
Это выражение выделяет память для нового массива и заполняет его числами, указанными в фигурных скобках. При этом подсчитывается их количество и, соответственно, определяется размер массива. Эту синтаксическую конструкцию удобно применять для повторной инициализации массива без образования новой переменной. Например, выражение
smallPrimes =
new
int
{
17
,
19
,
23
,
29
,
31
,
37
}
;
представляет собой укороченную запись выражения
int
anonymous =
{
17
,
19
,
23
,
29
,
31
,
37
}
;
smallPrimes =
anonymous;
Можно создать массив нулевого размера. Такой массив может оказаться полезным при написании метода, вычисляющего некий массив, который оказывается пустым. Массив нулевой длины объявляется следующим образом:
new
тип Элементов
Заметим, что такой массив не эквивалентен объекту null .
Копирование массивов arrays
Один массив можно скопировать в другой, но при этом обе переменные будут ссылаться на один и тот же массив.
int
luckyNumbers =
smallPrimes;
luckyNumbers[
5
]
=
12
;
//Теперь элемент smallPrimesтакже равен 12
Результат показан на рис. 3.1. Если необходимо скопировать все элементы одного массива в другой, следует использовать метод arraycopy из класса System . Его вызов выглядит следующим образом:
System.
arraycopy
(from,
fromlndex,
to,
tolndex,
count)
;
Массив to должен иметь достаточный размер, чтобы в нем поместились все копируемые элементы.
Рис.3.1. Копирование массива
Например, показанные ниже операторы, результаты работы которых изображены на рис. 3.2, создают два массива, а затем копируют последние четыре элемента первого массива во второй. Копирование начинается со второй позиции в исходном массиве, а копируемые элементы помещаются в целевой массив, начиная с третьей позиции.
int
smallPrimes =
{
2
,
3
,
5
,
7
,
11
,
13
}
;
int
luckyNumbers =
{
1001
,
1002
,
1003
,
1004
,
1005
,
1006
,
1007
}
;
System.
аrrаусору(smallPrimes,
2
,
luckyNumbers,
3
,
4
)
;
for
(int
i =
0
;
i <
luckyNumbers.
length;
i++
)
System.
out.
println
(i +
": "
+
luckyNumbers[
i]
)
;
Выполнение этих операторов приводит к следующему результату.
0
:
1001
1
:
1002
2
:
1003
3
:
5
4
:
7
5
:
11
6
:
13
Рис. 3.2. Копирование элементов массива
Массив в языке Java значительно отличается от массива в языке C++. Однако он практически совпадает с указателем на динамический массив. Это значит, что оператор
int
a =
new
int
[
100
]
;
//Java
эквивалентен оператору
int
*
=
new
int
[
100
]
;
//C++,
а не
int
a[
100
]
;
//C++
В языке Java оператор пo умолчанию проверяет диапазон изменения индексов. Кроме того, в языке Java нет арифметики указателей - нельзя увеличить указатель а, чтобы обратиться к следующему элементу массива.
Ссылка на перво
Многомерные массивы в Java
Длина многомерного массива в Java
Трехмерный массив в Java
triArray = new int;
// целых чисел, помещает некоторые значения в массив,
// и выводит каждое значение.
{
{
int arr;
arr = new int;
arr = 10;
arr = 20;
arr = 30;
arr = 40;
arr = 50;
for (int i = 0; i < arr.length; i++)
System.out.println("Element at index " + i +
" : "+ arr[i]);
}
}
В итоге получаем:Массивы объектов
// objects
{
public int roll_no;
public String name;
Student(int roll_no, String name)
{
this.roll_no = roll_no;
this.name = name;
}
}
public class GFG
{
public static void main (String args)
{
// declares an Array of integers.
Student arr;
arr = new Student;
arr = new Student(1,"aman");
arr = new Student(2,"vaibhav");
arr = new Student(3,"shikar");
arr = new Student(4,"dharmesh");
arr = new Student(5,"mohit");
for (int i = 0; i < arr.length; i++)
System.out.println("Element at " + i + " : " +
arr[i].roll_no +" "+ arr[i].name);
}
}
Компилятор создает исключение ArrayIndexOutOfBoundsException, указывающее, что к массиву был получен доступ с недопустимым индексом. Индекс либо отрицательный, либо больше или равен размеру массива.Многомерные
{
public static void main(String args)
{
// declaring and initializing 2D array
int arr = { {2,7,9},{3,6,1},{7,4,2} };
for (int i=0; i< 3 ; i++)
{
for (int j=0; j < 3 ; j++)
System.out.print(arr[i][j] + " ");
}
}
}
Передача массивов в метод
Возврат массивов из методов
Объекты класса
