Как создать двумерный массив в java. Массивы в Java — определение и создание, инициализация и заполнение. Определение размера массива

Массив (англ. array) представляет собой мощный инструмент, позволяющий работать с большим количеством данных. Очевидно, что если вам в процессе работы вашего кода где-то нужно сохранить, к примеру, 100 значений, то делать для этого такое же количество переменных как минимум неразумно. Массив позволяет хранить большое количество значений под одним именем и обращаться к ним по соответствующему индексу. Понятие массивов является краеугольным камнем в изучении курса Java для начинающих. Ведь они являются основой для многих структур данных.

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

Создание и манипуляции одномерными массивами

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

Вначале объявляется тип Java array, который определяет тип значений, хранящихся в нем. Это может быть любой допустимый в Далее идут имя массива и квадратные скобки, сообщающие компилятору, что данная переменная является массивом. Обратите внимание на важный факт. можно ставить как после базового типа массива, так и после имени массива. После знака равенства указывается оператор new, инициирующий выделение памяти под массив (так же, как и в случае с объектами), тип элементов, которые будут храниться в нем (должен быть совместим с базовым типом, объявленным ранее), и, наконец, их количество, указанное в квадратных скобках.

Нумерация элементов в Java array начинается с 0. Так, индекс первого элемента в данном массиве будет равен 0, а шестого - 5. Чтобы обратиться к конкретному элементу массива, например, пятому, достаточно указать имя массива и индекс элемента в квадратных скобках рядом с именем. Таким образом можно как присваивать значение элементу, так и извлекать его. Однако следует быть внимательным, поскольку если передать индекс, по которому не существует элемента, то возникнет ошибка.

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

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

Как видим, синтаксис не особо отличается от одномерных массивов. Давайте разберем структуру. В первых скобках мы выделили место под 5 элементов. Эти элементы являются ничем иным как ссылками на отдельные массивы. При этом размер каждого из них определен числом во вторых скобках. По сути, аналогом двумерных массивов в математике являются матрицы. Обратите внимание, что помимо элементов, в памяти выделяется отдельное место, где хранится значение длины массива (length). Как правило, работа с многомерными массивами осуществляется посредством вложенных циклов for.

Нерегулярные массивы

Двумерный массив является массивом массивов. Это мы уже выяснили. Но могут ли массивы, содержащиеся в нем, иметь разную длину? Ответ - да, могут. Для этого в Java предусмотрена возможность объявлять двумерный массив специальным образом. К примеру, мы хотим создать двумерный массив, который хранил бы в себе три одномерных массива длиной 2, 3 и 4 соответственно. Объявляется он следующим образом:

intarr = newint;

Обратите внимание, что мы не указали число во вторых скобках. Определение размера массивов в arr делается так:

Обращаясь к элементу под индексом 0, указывающему на первый массив, мы объявляем его с размерностью 2. Под элементом с индексом 1 будет храниться массив размерностью 3, и так далее. Все довольно просто.

Альтернативный синтаксис объявления java array

Инициализировать массивы можно и непосредственно при их создании. Это довольно просто.

Обратите внимание на объявление массивов jerseyNumber и playerName.

В случае с двумерными массивами данное объявление выглядит так:

Для этого вместо оператора new открываются фигурные скобки, в которых через запятую идет перечисление всех элементов. Java в этом случае автоматически выделяет память под них и индексирует их соответствующим образом.

Вспомогательный класс Arrays

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

Разберем некоторые самые полезные Java array методы:

CopyOf (массив, длина) - возвращает копию переданного массива соответствующей длины. Если переданная длина больше оригинального массива, то все «лишние» элементы заполняются значением по умолчанию (0, если простой тип, и null , если ссылочный).

CopyOfRange (массив, первый индекс, последний индекс) - не указанный на рисунке, но полезный метод. Он копирует часть переданного массива, определенную соответствующими индексами, начиная с первого и заканчивая последним.

Sort (массив) - сортирует элементы массива по возрастанию.

Fill (массив, значение) - заполняет переданный массив соответствующим значением.

BinarySearch (массив, значение) - возвращает индекс, под которым элемент с соответствующим значением находится в переданном отсортированном массиве. Если же такой элемент отсутствует, то возвращается отрицательное число.

Поскольку методы статические, то для их вызова не требуется создавать экземпляр класса Arrays. Они вызываются напрямую из него: Arrays.sort(arr).

Заключение

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

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

Мы научились создавать одномерные массивы. Подобным образом в 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
0 0
0 0 0
0 0 0 0
0 0 0 0 0

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

Упражнения на тему многомерные массивы в Java:

1. Создайте массив размерностью 5 на 6 и заполните его случайными числами (в диапазоне от 0 до 99). Выведите на консоль третью строку
2. Даны матрицы С и D размерностью 3 на 3 и заполненные случайными числами в диапазоне от 0 до 99. Выполните по отдельности сначала сложение, потом умножения матриц друг на друга. Выведете исходные матрицы и результат вычислений на консоль.
3. Просуммируйте все элементы двумерного массива.
4. Дан двумерный массив, содержащий отрицательные и положительные числа. Выведете на экран номера тех ячеек массива, которые содержат отрицательные числа.
5. Отсортируйте элементы в строках двумерного массива по возрастанию

Что такое массив?

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

Элементы массивов в Java расположены друг за другом в памяти компьютера. Ниже разбирается пример массива в Java.

Объявление массива в Java

Объявим массив, для хранения элементов типа int:

Здесь объявлена переменная arr, которая является массивом. Чтоб использовать эту переменную нужно её определить.

Определение массива в Java

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

В нашем массиве бедет храниться 5 элементов.

Массив - это набор элементов. К каждому элементу массива можно обратиться по его номеру. Номер принято называть индексом. Нумерация элементов массива в Java идёт с нуля.

Как загрузить элементы в массив?

Присвоим значение первому элементу массива, а первый элемент имеет индекс ноль:

Присвоим значение второму элементу массива, а второй элемент имеет индекс один:

for(int inn = 0; inn < 5; inn++)
{
arr = inn;
}

Можно при объявлении массива сразу загрузить в него значения:

int arr = {0, 1, 2, 3, 4};

количество элементов здесь равно 5-ти, т.е. нет необходимости указать число элементов, оно будет определено автоматически.

Как получить элементы из массива?

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

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

Присвоим значение третьего элемента массива переменной int a:

Выведем в цикле все элементы массива (переберем массив):

For(int inn = 0; inn < 5; inn++) { System.out.println("arr[" + inn + "] = " + arr); }

Упрощенный вариант цикла для вывода массива таков:

For(int inn: arr) { System.out.println("arr[" + inn + "] = " + arr); }

Как удалить массив в Java?

Удалить массив в Java можно так:

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

Длину массива в Java получаем так:

int arrLength = arr.length;

Как получить первый элемент массива в Java?

int firstElem = arr;

Как получить полследний элемент массива в Java?

int lastElem = arr;

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

Как в Java задать массив переменной длины? Никак. Когда вы определяете массив, тогда и задаёте его длину, изменить её в дальнейшем нельзя. В таких случаях используют коллекции, например: Vector, ArrayList и др.

Итак, перемнной длина массива быть не может. Но можно использовать переменную при определении массива. Если так:

int cd;
int ab = new int;//Error.

то получим ошибку, длина массива не может быть переменной.

Надо задать значение cd:

int cd = 10;
int ab = new int;

Теперь нормально. Если после определения массива изменить переменную cd, то это не повлияет на массив, т.е. его длина не изменится. Пример:

Int cd = 10; int ab = new int; cd = 12;// Это можно arrLength = ab.length; System.out.println("ab array length = " + arrLength); //Выводит: ab array length = 10 ab=4;// А вот здесь ошибка

Получим ошибку:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 11

Максимальный индекс нашего массива равен 9-ти. Изменение значения переменной cd не влияет на массив, ведь он уже определен и его длина есть константа.

Переменные можно использовать для обращения к элементам массива:

Int var = 1;
int elem = arr;
var = 2;
elem = arr;

Массив символов в Java

Пример массива символов в Java и его вывода:

Char charArr = {"S", "B", "P"}; for(int inn = 0; inn < charArr.length; inn++) { System.out.println("charArr[" + inn + "] = " + charArr); }

Как заполнить массив в Java?

Заполнить массив можно с помощью статического метода fill.

1. Что такое массивы?

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

Представим, что у вас есть приют для бездомных животных, в котором пять котов. Как зовут каждого вы не помните, но у каждого есть жетончик с номерком, который позволяет идентифицировать каждое животное. Можно сказать, что это и есть массив "котики" размером пять. Обратите внимание, на то что индексация начинается с нуля - так принято в Java. Если бы не было возможности создавать массивы, нужно было бы объявлять пять переменных и придумывать им имена, что не очень удобно.

В Java можно создавать массивы любой размерности - одномерные, двумерные, трехмерные и т.д. Начнем с простейшего варианта - с одномерных массивов.

2. Одномерные массивы

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

Тип имяПеременной;

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

Пример 1. Пример объявления массивов

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

Int monthDays; double monthSalaries;

2.1. Инициализация массива с помощью ключевого слова new

Когда массив объявлен, память под него еще не выделена. Для выделение памяти под массив используется ключевое слово new, после которого опять указывается тип массива и в квадратных скобках - размер:

ИмяПеременной = new тип[размер];

Массив может быть объявлен и инициализирован одной строкой:

Int values = new int;

Пример 2. Пример объявления массива

Рассмотрим пример объявления массива типа int размером 12 на данном примере. После выполнения строки int monthDays = new int массив из 12 элементов создан. Каждому элементу присваивается значение по умолчанию для заданного типа. Для типа int это ноль. Для обращения к отдельному элементу массива после имени массива в квадратных скобочках задаем индекс элемента. Таким образом мы можем обратиться к элементу массива для изменения или получения его значения.

Public class Array1 { public static void main(String args) { int monthDays = new int; monthDays = 31; monthDays = 28; monthDays = 31; monthDays = 30; monthDays = 31; monthDays = 30; monthDays = 31; monthDays = 31; monthDays = 30; monthDays = 31; monthDays = 30; monthDays = 31; System.out.println("B апреле " + monthDays + " дней."); } }

2.2. Инициализация массива с помощью блока для инициализации

Пример 3. Пример инициализации одномерного массива

Если заранее известны значения для каждого элемента массива, можно использовать блок для инициализации массива. Вместо new int, в фигурных скобках через запятую перечисляются значения элементов массива. Размер массива выводится компилятором из количества указанных элементов.

Public class Array2 { public static void main(String args) { int monthDays = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; System.out.println("B апреле " + monthDays + " дней."); } }

2.3. Безымянный массив

Существует еще и третья форма объявления массива - безымянный массив. Он может использоваться в двух случаях. Первый - вы объявили и инициализировали массив testScores размера четыре, но потом по какой-то причине он должен быть изменен - он должен содержать три элемента. Использовать повторно форму для инициализации массива нельзя - будет ошибка компиляции:

Int testScores = {1, 2, 3, 4}; ... testScores = {4, 7, 2}; //ошибка компиляции

Но можно использовать безымянный массив, который создаст новый массив в памяти. Форма написания безымянного массива - это микс первых двух:

TestScores = new int{4, 7, 2};

Второй случай использования безымянного массива - это передача массива в метод. В следующем примере метод print принимает на входа массив типа int. При вызове метода в качестве аргумента можно передать безымянный массив.

Пример 4. Пример безымянного массива

public class Array3 { public static void main(String args) { int testScores = {1, 2, 3, 4}; for (int element: testScores) { System.out.print(element + " "); } System.out.println(); testScores = new int{4, 7, 2}; for (int element: testScores) { System.out.print(element + " "); } System.out.println(); print(new int{4, 6, 2, 3}); } public static void print(int array) { for (int element: array) { System.out.print(element + " "); } } }

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

Многомерные массивы представляют собой массивы массивов.

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

Int twoD = new int;

Следующий рисунок показывает как можно визуально представить двумерный массив 4 на 5. Левый индекс определяет строку, а правый столбец.

Пример 5. Пример двухмерного массива

Следующий пример демонстрирует каким образом можно установить значения в двухмерный массив 4x5. Для перебора строк используется внешний цикл for , для перебора столбцов - внутренний. Каждому следующему элементу присваивается значение на единицу большее чем предыдущее.

Public class TwoDArray1 { public static void main(String args) { int twoD = new int; int i, j, k = 0; for (i = 0; i < 4; i++) { for (j = 0; j < 5; j++) { twoD[i][j] = k++; System.out.print(twoD[i][j] + " "); } System.out.println(); } } }

3.2.Представление многомерного массива в памяти

Рассмотрим теперь как представлен массив int twoD = new int; в памяти.Переменная twoD указывает не на матрицу, а на строку (красного цвета) состоящую из трех элементов. Значение каждого элемента - это ссылка на строку из четырех элементов (фиолетового цвета).

Следующая картинка показывает каким образом хранится трехмерный массив int threeD = new int в памяти:

Подобным образом может храниться массив любой размерности в памяти.

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

Пример 6. Пример двухмерного массива с разной размерностью

Посмотрим код, реализующий такой массив. При объявлении массива необходимо задать количество элементов только для первой размерности - int array = new int . Таким образом, мы указываем количество строк в массиве, но под каждую строку память не выделяем. Далее выделяем отдельно память под каждую строку массива. Например, строка с индексом ноль будет размера 1 - array = new int.

Public class TwoDArray2 { public static void main(String args) { int array = new int; array = new int; array = new int; array = new int; array = new int; int i, j, k = 0; for (i = 0; i < 4; i++) { for (j = 0; j < i + 1; j++) { array[i][j] = k++; System.out.print(array[i][j] + " "); } System.out.println(); } } }

3.4. Блок для инициализации многомерного массива

Пример 7. Инициализация двухмерного массива

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

Public class TwoDArray3 { public static void main(String args) { double arrayTwoD = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}, {12, 13, 14, 15} }; for (double arrayOneD: arrayTwoD) { for (double element: arrayOneD) { System.out.print(element + " "); } System.out.println(); } } }

3.4. Длина массива

Пример 8. Получение длины массива

Следующий пример демонстрирует как получать длину массива. Для этого используется переменная length . С одномерным массивом все понятно - его длина это количество его элементов. Длина многомерного массива - это количество элементов его первой размерности. Например, длина массива array2 - это 2. Также можно получить длину каждой строки массива. Например, array2.length - вернет количество элементов в строке с индексом ноль.

Public class ArraySize { public static void main(String args) { int array1 = {1, 2, 3, 4}; int array2 = {{1, 1, 1}, {2, 2, 2}}; System.out.println("Размер массива array1 = " + array1.length); System.out.println("Размер массива array2 = " + array2.length); System.out.println("Размер 1-строки массива array2 = " + array2.length); } }

Результат выполнения:

Размер массива array1 = 4 Размер массива array2 = 2 Размер 1-строки массива array2 = 3

4. Полезные методы при работе с массивами

Существует ряд методов, полезных при работе с массивами. Рассмотрим их:

4.1. Метод Arrays.toString()

Метод возвращает строковое представление одномерного массива, разделяя элементы запятой. Вместо того, чтобы перебирать массивы циклом for , как мы делали в примере 4, можно воспользоваться этим методом для вывода элементов на консоль:

Пример 9. Применение метода Arrays.toString()

import java.util.Arrays; public class ArraysToStringDemo { public static void main(String args) { int array = {1, 4, 6, 3, 8}; System.out.println(Arrays.toString(array)); } }

4.2. Метод Arrays.deepToString()

Метод возвращает строковое представление многомерного массива, выделяя строки квадратными скобками:

Пример 10. Применение метода Arrays.deepToString()

import java.util.Arrays; public class ArraysDeepToStringDemo { public static void main(String args) { String array = {{"один-один", "один-два", "один-три"}, {"два-один", "два-два", "два-три"}}; System.out.println(Arrays.deepToString(array)); } }

4.3. Метод Arrays.sort()

Метод Arrays.sort() сортирует элементы числового массива по возрастанию:

Пример 11. Сортировка массива

import java.util.Arrays; public class ArraysSort1 { public static void main(String args) { int array = new int{3, 1, 5, 6, 8}; Arrays.sort(array); System.out.println(Arrays.toString(array)); } }

4.4. Метод Arrays.binarySearch()

Метод Arrays.binarySearch() ищет в массиве заданное значение и возвращает номер элемента. Если искомый элемент не найден, то возвращается -(position + 1) , где position - позиция элемента где он МОГ БЫ БЫТЬ. Массив должен быть отсортирован, иначе результат вызова метода будет неопределен:

Пример 12. Поиск элемента массива

import java.util.Arrays; public class BinarySearch1 { public static void main(String args) { int array1 = {10, 20, 30, 40}; int pos1 = Arrays.binarySearch(array1, 20); int pos2 = Arrays.binarySearch(array1, 25); System.out.println(pos1); System.out.println(pos2); } }

Результат выполнения:

4.5. Метод System.arraycopy()

Метод System.arraycopy() позволяет копировать часть массива в другой массив.

Пример 13. Копирование массива

Рассмотрим пример, копирующий элементы 2,3,4 из массива arraySource в массив arrayDestination:

Import java.util.Arrays; public class ArrayCopy1 { public static void main(String args) { int arraySource = {1, 2, 3, 4, 5, 6}; int arrayDestination = {0, 0, 0, 0, 0, 0, 0, 0}; System.out.println("arraySource: " + Arrays.toString(arraySource)); System.out.println("arrayDestination: " + Arrays.toString(arrayDestination)); System.arraycopy(arraySource, 1, arrayDestination, 2, 3); System.out.println("arrayDestination after arrayCopy: " + Arrays.toString(arrayDestination)); } }

Результат выполнения:

ArraySource: arrayDestination: arrayDestination after arrayCopy:

Пример 14. Копирование массива из себя в себя

Можно копировать в тот же массив с перекрытием областей:

Import java.util.Arrays; public class ArrayCopy2 { public static void main(String args) { int array = {1, 2, 3, 4, 5, 6, 7, 8}; System.out.println(Arrays.toString(array)); System.arraycopy(array, 1, array, 3, 3); System.out.println(Arrays.toString(array)); } }

Результат выполнения:

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

Для примера рассмотрим двумерный массив в 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}};

Длина многомерного массива в Java

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

Пример трехмерного массива в Java:

int triArray;
triArray = new int;

Здесь объявлен и определен трехмерный массив. Его можно представит как куб, состоящий из двух слоёв (layer), каждый слой состоит из двух рядов и двух столбцов, т.е. каждый слой - это двумерный массив.

Как заполнить трехмерный массив? Можно в цикле, но мы для примера вручную заполним:

//**************** //THE FIRST LAYER //**************** //the first row of the first layer triArray = 1; triArray = 2; //the second row of the first layer triArray = 3; triArray = 4; //**************** //THE SECOND LAYER //**************** //the first row of the second layer triArray = 5; triArray = 6; //the second row of the second layer triArray = 7; triArray = 8;

Как вывести трехмерный массив? Или как перебрать трехмерный массив? Так.