Все действия с двумерными массивами в java. Полезные материалы о массивах. Главное о массивах

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 массив однороден , то есть во всех его ячейках будут храниться элементы одного типа. Так, массив целых чисел содержит только целые числа (например, типа int), массив строк - только строки, массив из элементов созданного нами класса Dog будет содержать только объекты Dog . То есть в Java мы не можем поместить в первую ячейку массива целое число, во вторую String , а в третью - “собаку”.

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

Как объявить массив?

Как и любую переменную, массив в Java нужно объявить. Сделать это можно одним из двух способов. Они равноправны, но первый из них лучше соответствует стилю Java. Второй же - наследие языка Си (многие Си-программисты переходили на Java, и для их удобства был оставлен и альтернативный способ). В таблице приведены оба способа объявления массива в Java: В обоих случаях dataType - тип переменных в массиве. В примерах мы объявили два массива. В одном будут храниться целые числа типа int , в другом - объекты типа Object . Таким образом при объявлении массива у него появляется имя и тип (тип переменных массива). ArrayName - это имя массива.

Создание массива

Как создать массив?

Как и любой другой объект, создать массив Java, то есть зарезервировать под него место в памяти, можно с помощью оператора new . Делается это так: new typeOfArray [ length] ; Где typeOfArray - это тип массива, а length - его длина (то есть, количество ячеек), выраженная в целых числах (int). Однако здесь мы только выделили память под массив, но не связали созданный массив ни с какой объявленной ранее переменной. Обычно массив сначала объявляют, а потом создают, например: int myArray; // объявление массива myArray = new int [ 10 ] ; // создание, то есть, выделение памяти для массива на 10 элементов типа int Здесь мы объявили массив целых чисел по имени myArray , а затем сообщили, что он состоит из 10 ячеек (в каждой из которых будет храниться какое-то целое число). Однако гораздо чаще массив создают сразу после объявления с помощью такого сокращённого синтаксиса: int myArray = new int [ 10 ] ; // объявление и выделение памяти “в одном флаконе” Обратите внимание: После создания массива с помощью new , в его ячейках записаны значения по умолчанию. Для численных типов (как в нашем примере) это будет 0, для boolean - false , для ссылочных типов - null . Таким образом после операции int myArray = new int [ 10 ] ; мы получаем массив из десяти целых чисел, и, пока это не измениться в ходе программы, в каждой ячейке записан 0.

Длина массива в Java

Как мы уже говорили выше, длина массива - это количество элементов, под которое рассчитан массив. Длину массива нельзя изменить после его создания. Обратите внимание: в Java элементы массива нумеруются с нуля. То есть, если у нас есть массив на 10 элементов, то первый элемент массива будет иметь индекс 0, а последний - 9. Получить доступ к длине массива можно с помощью переменной length . Пример: int myArray = new int [ 10 ] ; // создали массив целых чисел на 10 элементов и присвоили ему имя myArray System. out. println (myArray. length) ; // вывели в консоль длину массива, то есть количество элементов, которые мы можем поместить в массив Вывод программы: 10

Инициализация массива и доступ к его элементам

Как создать массив в Java уже понятно. После этой процедуры мы получаем не пустой массив, а массив, заполненный значениями по умолчанию. Например, в случае int это будут 0, а если у нас массив с данными ссылочного типа, то по умолчанию в каждой ячейке записаны null . Получаем доступ к элементу массива (то есть записываем в него значение или выводим его на экран или проделываем с ним какую-либо операцию) мы по его индексу. Инициализация массива - это заполнение его конкретными данными (не по умолчанию). Пример: давайте создадим массив из 4 пор года и заполним его строковыми значениями - названиями этих пор года. String seasons = new String [ 4 ] ; /* объявили и создали массив. Java выделила память под массив из 4 строк, и сейчас в каждой ячейке записано значение null (поскольку строка - ссылочный тип)*/ seasons[ 0 ] = "Winter" ; /* в первую ячейку, то есть, в ячейку с нулевым номером мы записали строку Winter. Тут мы получаем доступ к нулевому элементу массива и записываем туда конкретное значение */ seasons[ 1 ] = "Spring" ; // проделываем ту же процедуру с ячейкой номер 1 (второй) seasons[ 2 ] = "Summer" ; // ...номер 2 seasons[ 3 ] = "Autumn" ; // и с последней, номер 3 Теперь во всех четырёх ячейках нашего массива записаны названия пор года. Инициализацию также можно провести по-другому, совместив с инициализацией и объявлением: String seasons = new String { "Winter" , "Spring" , "Summer" , "Autumn" } ; Более того, оператор new можно опустить: String seasons = { "Winter" , "Spring" , "Summer" , "Autumn" } ;

Как вывести массив в Java на экран?

Вывести элементы массива на экран (то есть, в консоль) можно, например, с помощью цикла for . Ещё один, более короткий способ вывода массива на экран будет рассмотрен в пункте “ . А пока рассмотрим пример с циклическим выводом массива: String seasons = new String { "Winter" , "Spring" , "Summer" , "Autumn" } ; for (int i = 0 ; i < 4 ; i++ ) { System. out. println (seasons[ i] ) ; } В результате программа выведет следующий результат: Winter Spring Summer Autumn

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

А что, если мы захотим создать не массив чисел, массив строк или массив каких-то объектов, а массив массивов? Java позволяет это сделать. Уже привычный нам массив int myArray = new int - так называемый одномерный массив. А массив массивов называется двумерным. Он похож на таблицу, у которой есть номер строки и номер столбца. Или, если вы учили начала линейной алгебры, - на матрицу. Для чего нужны нужны такие массивы? В частности, для программирования тех же матриц и таблиц, а также объектов, напоминающих их по структуре. Например, игровое поле для шахмат можно задать массивом 8х8. Многомерный массив объявляется и создается следующим образом: Int myTwoDimentionalArray = new int [ 8 ] [ 8 ] ; В этом массиве ровно 64 элемента: myTwoDimentionalArray , myTwoDimentionalArray , myTwoDimentionalArray , myTwoDimentionalArray и так далее вплоть до myTwoDimentionalArray . Так что если мы с его помощью представим шахматную доску, то клетку А1 будет представлять myTwoDimentionalArray , а E2 - myTwoDimentionalArray . Где два, там и три. В Java можно задать массив массивов… массив массивов массивов и так далее. Правда, трёхмерные и более массивы используются очень редко. Тем не менее, с помощью трёхмерного массива можно запрограммировать, например, кубик Рубика.

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

Для работы с массивами в Java есть класс java.util.Arrays (arrays на английском и означает “массивы”). В целом с массивами чаще всего проделывают следующие операции: заполнение элементами (инициализация), извлечение элемента (по номеру), сортировка и поиск. Поиск и сортировка массивов - тема отдельная. С одной стороны очень полезно потренироваться и написать несколько алгоритмов поиска и сортировки самостоятельно. С другой стороны, все лучшие способы уже написаны и включены в библиотеки Java, и ими можно законно пользоваться.

Статьи на поиск и сортировку: Сортировка и поиск в курсе CS50:

Вот три полезных метода этого класса

Сортировка массива

Метод void sort(int myArray, int fromIndex, int toIndex) сортирует массив целых чисел или его подмассив по возрастанию.

Поиск в массиве нужного элемента

int binarySearch(int myArray, int fromIndex, int toIndex, int key) . Этот метод ищет элемент key в уже отсортированном массиве myArray или подмассиве, начиная с fromIndex и до toIndex . Если элемент не найден, возвращает номер элемента или fromIndex-1 .

Преобразование массива к строке

Метод String toString(int myArray) преобразовывает массив к строке. Дело в том, что в Java массивы не переопределяют toString() . Это значит, что если вы попытаетесь вывести целый массив (а не по элементам, как в пункте “ ”) на экран непосредственно (System.out.println(myArray)), вы получите имя класса и шестнадцатеричный хэш-код массива (это определено определено Object.toString()). Если вы - новичок, вам, возможно, непонятно пояснение к методу toString . На первом этапе это и не нужно, зато с помощью этого метода упрощается вывод массива. Java позволяет легко выводить массив на экран без использования цикла. Об этом - в примере ниже.

Пример на sort, binarySearch и toString

Давайте создадим массив целых чисел, выведем его на экран с помощью toString , отсортируем с помощью метода sort и найдём в нём какое-то число. class Main { public static void main (String args) { int array = { 1 , 5 , 4 , 3 , 7 } ; //объявляем и инициализируем массив System. out. println (array) ; //пытаемся вывести наш массив на экран без метода toString - получаем 16-ричное число //печатаем массив "правильно" Arrays. sort (array, 0 , 4 ) ; //сортируем весь массив от нулевого до четвёртого члена System. out. println (Arrays. toString (array) ) ; //выводим отсортированный массив на экран int key = Arrays. binarySearch (array, 5 ) ; // ищем key - число 5 в отсортированном массиве. //метод binarySearch выдаст индекс элемента остортированного массива, в котором "спрятано" искомое число System. out. println (key) ; //распечатываем индекс искомого числа System. out. println (Arrays. binarySearch (array, 0 ) ) ; //а теперь попробуем найти число, которого в массиве нет, // и сразу же выведем результат на экран } } Вывод программы: 3 -1 В первой строке - попытка вывода на экран массива без toString , во второй - вывод массива посредством toString , в третьей выведен отсортированный массив, в четвёртой - индекс искомого числа 5 в отсортированном массиве (помните, что считаем с нуля, поэтому четвёртый элемент массива имеет индекс 3). В пятой строке видем -1. Такого индекса у массива не бывает. Вывод сигнализирует о том, что искомого элемента (в данном случае, 0) в массиве нет.

Главное о массивах

Главные характеристики массива: тип помещённых в него данных, имя и длина.
Последнее решается при инициализации (выделении памяти под массив), первые два параметра определяются при объявлении массива.

Размер массива (количество ячеек) нужно определять в int

Изменить длину массива после его создания нельзя.

Доступ к элементу массива можно получить по его индексу.

В массивах, как и везде в Java, элементы нумеруются с нуля.

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

Массив в языке Java значительно отличается от массива в языке C++. Однако он практически совпадает с указателем на динамический массив.

Полезные материалы о массивах

Хотите знать больше о массивах? Обратите внимание на статьи ниже. Там много интересного и полезного по этой теме.

Хорошая подробная статья о массивах

В статье описаны некоторые методы класса Array

Первая лекция JavaRush, посвящённая массивам.

Последнее обновление: 09.11.2018

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

Тип_данных название_массива; // либо тип_данных название_массива;

Например, определим массив чисел:

Int nums; int nums2;

После объявления массива мы можем инициализовать его:

Int nums; nums = new int; // массив из 4 чисел

Создание массива производится с помощью следующей конструкции: new тип_данных[количество_элементов] , где new - ключевое слово, выделяющее память для указанного в скобках количества элементов. Например, nums = new int; - в этом выражении создается массив из четырех элементов int, и каждый элемент будет иметь значение по умолчанию - число 0.

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

Int nums = new int; // массив из 4 чисел int nums2 = new int; // массив из 5 чисел

При подобной инициализации все элементы массива имеют значение по умолчанию. Для числовых типов (в том числе для типа char) это число 0, для типа boolean это значение false , а для остальных объектов это значение null . Например, для типа int значением по умолчанию является число 0, поэтому выше определенный массив nums будет состоять из четырех нулей.

Однако также можно задать конкретные значения для элементов массива при его создании:

// эти два способа равноценны int nums = new int { 1, 2, 3, 5 }; int nums2 = { 1, 2, 3, 5 };

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

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

Int nums = new int; // устанавливаем значения элементов массива nums = 1; nums = 2; nums = 4; nums = 100; // получаем значение третьего элемента массива System.out.println(nums); // 4

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

И так как у нас массив определен только для 4 элементов, то мы не можем обратиться, например, к шестому элементу: nums = 5; . Если мы так попытаемся сделать, то мы получим ошибку.

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

Важнейшее свойство, которым обладают массивы, является свойство length , возвращающее длину массива, то есть количество его элементов:

Int nums = {1, 2, 3, 4, 5}; int length = nums.length; // 5

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

Int last = nums;

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

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

Int nums1 = new int { 0, 1, 2, 3, 4, 5 }; int nums2 = { { 0, 1, 2 }, { 3, 4, 5 } };

Визуально оба массива можно представить следующим образом:

Одномерный массив nums1

Двухмерный массив nums2

Поскольку массив nums2 двухмерный, он представляет собой простую таблицу. Его также можно было создать следующим образом: int nums2 = new int; . Количество квадратных скобок указывает на размерность массива. А числа в скобках - на количество строк и столбцов. И также, используя индексы, мы можем использовать элементы массива в программе:

// установим элемент первого столбца второй строки nums2=44; System.out.println(nums2);

Объявление трехмерного массива могло бы выглядеть так:

Int nums3 = new int;

Зубчатый массив

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

Int nums = new int; nums = new int; nums = new int; nums = new int;

foreach

Специальная версия цикла for предназначена для перебора элементов в наборах элементов, например, в массивах и коллекциях. Она аналогична действию цикла foreach , который имеется в других языках программирования. Формальное ее объявление:

For (тип_данных название_переменной: контейнер){ // действия }

Например:

Int array = new int { 1, 2, 3, 4, 5 }; for (int i: array){ System.out.println(i); }

В качестве контейнера в данном случае выступает массив данных типа int . Затем объявляется переменная с типом int

То же самое можно было бы сделать и с помощью обычной версии for:

Int array = new int { 1, 2, 3, 4, 5 }; for (int i = 0; i < array.length; i++){ System.out.println(array[i]); }

В то же время эта версия цикла for более гибкая по сравнению for (int i: array) . В частности, в этой версии мы можем изменять элементы:

Int array = new int { 1, 2, 3, 4, 5 }; for (int i=0; i

Перебор многомерных массивов в цикле

int nums = new int { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; for (int i = 0; i < nums.length; i++){ for(int j=0; j < nums[i].length; j++){ System.out.printf("%d ", nums[i][j]); } System.out.println(); }

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

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

Массив - это структура данных, в которой хранятся величины одинакового типа. Доступ к отдельному элементу массива осуществляется с помощью целого индекса. Например, если а - массив целых чисел, то значение выражения а [ i ] равно i-му целому числу в массиве.

Массив объявляется следующим образом: сначала указывается тип массива, т.е тип элементов, содержащихся в массиве, за которым ставится пара пустых квадратных скобок, а затем - имя переменной. Например, вот как объявляется массив, состоящий из целых чисел:
int a;

Однако этот оператор лишь объявляет переменную а, не инициализируя ее настоящим массивом. Чтобы создать массив, нужно применить оператор new.

Этот оператор создает массив, состоящий из 100 целых чисел. Элементы этого массива нумеруются от 0 до 99 (а не от 1 до 100). После создания массив можно заполнять, например, с помощью цикла.

int а = new int;
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 };
smailPrimes = anonymous;

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

new типЭлементов

Заметим, что такой массив не эквивалентен объекту null.

Копирование массивов

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

int luckyNumbers = smailPrimes;
luckyNuimbers = 12; // Теперь элемент smailPrimesтакже равен 12.

Результат показан на рис. 3.14. Если необходимо скопировать все элементы одного массива в другой, следует использовать метод arraycopy из класса System. Его вызов выглядит следующим образом:

System.arraycopy(from, fromlndex, to, tolndex, count);

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

Рис. 3.14. Копирование массива

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

int smailPrimes = {2, 3, 5, 7, 11, 13};
int luckyNumbers = {1001, 1002, 1003, 1004, 1005, 1006, 1007};
System.аггаусору(smailPrimes, 2, luckyNumbers, 3, 4);
for (int i = 0; i < luckyNumbers.length; i++)
System.println(i +.": " + luckyNumbersfi]);

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

0: 1001
1: 1002
2: 1003
3: 5
4: 7
5: 11
6: 13

Рис. 3.15. Копирование элементов массива

Массив в языке Java значительно отличается от массива в языке C++. Однако он практически совпадает с указателем на динамический массив. Это значит, что оператор

int a = new int; //Java
эквивалентен оператору
i n t * = new i n t [ 1 0 0 ] ; // C++,
а не
int a; // C++

В языке Java оператор no умолчанию проверяет диапазон изменения индексов. Кроме того, в языке Java нет арифметики указателей - нельзя увеличить указатель а, чтобы обратиться к следующему элементу массива.