Массивы

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

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

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

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

int nums[]; int[] nums2;

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

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

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

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

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

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

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

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

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

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

int[] nums = new int[4]; nums[0] = 1; nums[1] = 2; nums[2] = 4; nums[3] = 100; System.out.println(nums[2]); // 4

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

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

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

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

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

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

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

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

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

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

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

int[][][] nums3 = new int[2][3][4];

Массив массивов

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

int[][] nums = new int[3][]; nums[0] = new int[2]; nums[1] = new int[3]; nums[2] = new int[5];

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

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

int length = nums.length;

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

int last = nums[nums.length-1];

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

В Java можно объявить массив массивов, известный как многомерный массив. К примеру:

Здесь мы видим двухмерный массив Java, который может содержать до 12 элементов типа int:

Не забывайте, что индексирование в Java начинается с нуля, поэтому первые элементы массива имеют индекс 0, а не 1.

Аналогично можно объявить и трёхмерный (3D) массив. Например:

В примере выше personalInfo — это трёхмерный массив, в котором может быть до 24 (3*4*2) элементов типа String.

В Java составляющие многомерного массива — это тоже массивы. Если вы знаете C/C++, то может показаться, что многомерные массивы в Java и C/C++ работают одинаково.

Массивы в Java

Но это не совсем так — в Java ряды массивов могут быть разной длины. Разницу мы увидим во время инициализации.

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

Ниже приводится пример инициализации двумерного массива Java:

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

Давайте напишем программу, чтобы это доказать:

При запуске этой программы мы получим:

Длина ряда 1: 3
Длина ряда 2: 4
Длина ряда 3: 1

Поскольку многомерный массив состоит из отдельных массивов (a[0], a[1] and a[2]), можно использовать метод length для определения длины каждого ряда длины двумерного массива Java.

Пример: вывод на экран всех элементов двумерного массива с помощью циклов:

Всегда лучше использовать цикл for…each, когда нужно пройти по элементам массива. Пример сортировки двумерного массива Java можно записать с помощью цикла for…each следующим образом:

При запуске этой программы мы получим следующий результат заполнения двумерного массива Java:

Как инициализировать трёхмерный массив в Java?

Трёхмерный массив инициализируется почти так же, как двухмерный:

Трёхмерный массив — это массив, состоящий из двумерных массивов. Как и у двумерных массивов Java, его ряды могут быть различной длины.

Пример: программа для вывода элементов трёхмерного массива с помощью циклов:

При запуске программы вывода двумерного массива Java получаем следующий результат:

Перевод статьи “Java Multidimensional Arrays” был подготовлен дружной командой проекта Сайтостроение от А до Я.

Массивы в Java

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

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

Индекс начального элемента — 0, следующего за ним — 1 и т. д. Индекс последнего элемента в массиве — на единицу меньше, чем размер массива.

В Java массивы являются объектами. Это значит, что имя, которое даётся каждому массиву, лишь указывает на адрес какого-то фрагмента данных в памяти. Кроме адреса в этой переменной ничего не хранится. Индекс массива, фактически, указывает на то, насколько надо отступить от начального элемента массива в памяти, чтоб добраться до нужного элемента.

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

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

тип[] имя; тип имя[];

Где тип — это тип элементов массива, а имя — уникальный (незанятый другими переменными или объектами в этой части программы) идентификатор, начинающийся с буквы.

Примеры:

int[] a; double[] ar1; double ar2[];

В примере мы объявили имена для трёх массивов. С первом именем a сможет быть далее связан массив из элементов типа int, а с именами ar1 и ar2 далее смогут быть связаны массивы из вещественных чисел (типа double). Пока мы не создали массивы, а только подготовили имена для них.

Теперь создать (или как ещё говорят инициализировать) массивы можно следующим образом:

a = new int[10]; // массив из 10 элементов типа int int n = 5; ar1 = new double[n]; // Массив из 5 элементов double ar2 = {3.14, 2.71, 0, -2.5, 99.123}; // Массив из 6 элементов типа double

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

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

Если массив был создан с помощью оператора new, то каждый его элемент получает значение по умолчанию. Каким оно будет определяется на основании типа данных (0 для int, 0.0 для double и т. д.).

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

тип[] имя = new тип[размер]; тип[] имя = {эл0, эл1, …, элN};

Примеры:

int[] mas1 = {10,20,30}; int[] mas2 = new int[3];

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

System.out.println("Последний элемент массива " + mas1[2]);

А вот так мы можем положить в массив mas2 тот же набор значений, что хранится в mas1:

mas2[0] = 10; mas2[1] = 20; mas2[2] = 30;

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

for(int i=0; i<=2; i++) { mas2[i] = (i+1) * 10; }

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

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

int razmer = mas1.length;

Это свойство нельзя изменять (т. е. ему нельзя ничего присваивать), можно только читать. Используя это свойство можно писать программный код для обработки массива даже не зная его конкретного размера.

Например, так можно вывести на экран элементы любого массива с именем ar2:

for(int i = 0; i <= ar2.length — 1; i++) { System.out.print(ar2[i] + " "); }

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

for(int i = 0; i < ar1.length; i++) {ar1[i] = Math.floor(Math.random() * 10); System.out.print(ar1[i] + " "); }

Обратите внимание, на каждом шаге цикла мы сначала отправляли случайное значение в элемент массива с i-ым индексом, а потом этот же элемент выводили на экран. Но два процесса (наполнения и вывода) можно было проделать и в разных циклах. Например:

for(int i = 0; i < ar1.length; i++) { ar1[i] = Math.floor(Math.random() * 9); } for(int i = 0; i < ar1.length; i++) { System.out.print(ar1[i] + " "); }

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

Для обработки массивов всегда используются циклы типа «n раз» (for) потому, что нам заранее известно сколько раз должен повториться цикл (столько же раз, сколько элементов в массиве).

Задачи

1. Создайте массив из всех чётных чисел от 2 до 20 и выведите элементы массива на экран сначала в строку, отделяя один элемент от другого пробелом, а затем в столбик (отделяя один элемент от другого началом новой строки). Перед созданием массива подумайте, какого он будет размера.

   2 4 6 … 18 20
   2
   4
   6
   …
   20

2. Создайте массив из всех нечётных чисел от 1 до 99, выведите его на экран в строку, а затем этот же массив выведите на экран тоже в строку, но в обратном порядке (99 97 95 93 … 7 5 3 1).

3. Создайте массив из 15 случайных целых чисел из отрезка [0;9]. Выведите массив на экран. Подсчитайте сколько в массиве чётных элементов и выведете это количество на экран на отдельной строке.

4. Создайте массив из 8 случайных целых чисел из отрезка [1;10]. Выведите массив на экран в строку. Замените каждый элемент с нечётным индексом на ноль. Снова выведете массив на экран на отдельной строке.

5. Создайте 2 массива из 5 случайных целых чисел из отрезка [0;5] каждый, выведите массивы на экран в двух отдельных строках. Посчитайте среднее арифметическое элементов каждого массива и сообщите, для какого из массивов это значение оказалось больше (либо сообщите, что их средние арифметические равны).

6. Создайте массив из 4 случайных целых чисел из отрезка [10;99], выведите его на экран в строку. Определить и вывести на экран сообщение о том, является ли массив строго возрастающей последовательностью.

7. Создайте массив из 20-ти первых чисел Фибоначчи и выведите его на экран. Напоминаем, что первый и второй члены последовательности равны единицам, а каждый следующий — сумме двух предыдущих.

8. Создайте массив из 12 случайных целых чисел из отрезка [-15;15]. Определите какой элемент является в этом массиве максимальным и сообщите индекс его последнего вхождения в массив.

9. Создайте два массива из 10 целых случайных чисел из отрезка [1;9] и третий массив из 10 действительных чисел. Каждый элемент с i-ым индексом третьего массива должен равняться отношению элемента из первого массива с i-ым индексом к элементу из второго массива с i-ым индексом.

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

10. Создайте массив из 11 случайных целых чисел из отрезка [-1;1], выведите массив на экран в строку. Определите какой элемент встречается в массиве чаще всего и выведите об этом сообщение на экран. Если два каких-то элемента встречаются одинаковое количество раз, то не выводите ничего.

11. Пользователь должен указать с клавиатуры чётное положительное число, а программа должна создать массив указанного размера из случайных целых чисел из [-5;5] и вывести его на экран в строку. После этого программа должна определить и сообщить пользователю о том, сумма модулей какой половины массива больше: левой или правой, либо сообщить, что эти суммы модулей равны. Если пользователь введёт неподходящее число, то программа должна требовать повторного ввода до тех пор, пока не будет указано корректное значение.

12. Программа должна создать массив из 12 случайных целых чисел из отрезка [-10;10] таким образом, чтобы отрицательных и положительных элементов там было поровну и не было нулей. При этом порядок следования элементов должен быть случаен (т. е. не подходит вариант, когда в массиве постоянно выпадает сначала 6 положительных, а потом 6 отрицательных чисел или же когда элементы постоянно чередуются через один и пр.). Вывести полученный массив на экран.

13. Пользователь вводит с клавиатуры натуральное число большее 3, которое сохраняется в переменную n. Если пользователь ввёл не подходящее число, то программа должна просить пользователя повторить ввод. Создать массив из n случайных целых чисел из отрезка [0;n] и вывести его на экран. Создать второй массив только из чётных элементов первого массива, если они там есть, и вывести его на экран.

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

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

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

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

Сортировка выбором

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

Суть алгоритма такова. Во всём отыскиваем минимальный элемент, меняем его местами с начальным. Затем в оставшейся части массива (т. е. среди всех элементов кроме начального) снова отыскиваем минимальный элемент, меняем его местами уже со вторым элементом в массиве. И так далее.

Иллюстрация:

Код:

for (int i = 0; i < a.length; i++) { /* Предполагаем, что начальный элемент рассматриваемого * фрагмента и будет минимальным. */ int min = a[i]; // Предполагаемый минимальный элемент int imin = i; // Индекс минимального элемента /* Просматриваем оставшийся фрагмент массива и ищем там * элемент, меньший предположенного минимума. */ for (int j = i+1; j < a.length; j++) { /* Если находим новый минимум, то запоминаем его индекс. * И обновляем значение минимума. */ if (a[j] < min) { min = a[j]; imin = j; } } /* Проверяем, нашёлся ли элемент меньше, чем стоит на * текущей позиции. Если нашёлся, то меняем элементы местами. */ if (i != imin) { int temp = a[i]; a[i] = a[imin]; a[imin] = temp; } }

Сортировка методом пузырька

Суть алгоритма такова. Если пройдёмся по любому массиву установив правильный порядок в каждой паре соседних элементов, то после того прохода на последнем месте массива гарантированно будет стоять нужный элемент (самый большой для сортировки по возрастанию или самый маленький для сортировки по убыванию). Если ещё раз пройтись по массиву с такими же преобразованиями, то и на предпоследнем месте гарантированно окажется нужный элемент. И так далее.

Пример:

2 9 1 4 3 5 2 → порядок правильный, не будет перестановки

2 9 1 4 3 5 2 → 2 1 9 4 3 5 2

2 1 9 4 3 5 2 → 2 1 4 9 3 5 2

2 1 4 9 3 5 2 → 2 1 4 3 9 5 2

2 1 4 3 9 5 2 → 2 1 4 3 5 9 2

2 1 4 3 5 9 2 → 2 1 4 3 5 2 9

Код:

/* Внешний цикл постоянно сужает фрагмент массива, * который будет рассматриваться, ведь после каждого прохода * внутреннего цикла на последнем месте фрагмента будет * оказываться нужный элемент (его не надо рассматривать снова). */ for (int i = a.length — 1; i >= 2; i—) { /* В переменной sorted мы будем хранить признак того, * отсортирован ли массив. Перед каждым проходом внутреннего * цкла будем предполагать, что отсортирован, но если совершим * хоть одну перестановку, то значит ещё не конца отсортирован. * Этот приём, упрощающий сортировку, называется критерием Айверсона. */ boolean sorted = true; /* Во внутреннем цикле мы проходимся по фрагменту массива, который * определяется внешним циклом. В этом фрагменте мы устанавливаем * правильный порядок между соседними элементами, так попарно * обрабатывая весь фрагмент. */ for (int j = 0; j < i; j++) { /* Если порядок соседних элементов не правильный, то их * надо обменять местами. И запомнить, что была перестановка. */ if (a[j] > a[j+1]) { int temp = a[j]; a[j] = a[j+1]; a[j+1] = temp; sorted = false; } } /* Если массив отсортирован (т.е. не было ни одной перестановки * во внутреннем цикле, значит можно прекращать работу внешнего * цикла. */ if(sorted) { break; } }

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

Массив может состоять не только из элементов какого-то встроенного типа (int, double и пр.), но и, в том числе, из объектов какого-то существующего класса и даже из других массивов.

Массив который в качестве своих элементов содержит другие массивы называется многомерным массивом.

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

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

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

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

int[] d1; //Обычный, одномерный int[][] d2; //Двумерный double[][] d3; //Трёхмерный int[][][][][] d5; //Пятимерный

При создании массива можно указать явно размер каждого его уровня:

d2 = int[3][4]; // Матрица из 3 строк и 4 столбцов

Но можно указать только размер первого уровня:

int[][] dd2 = int[5][]; /* Матрица из 5 строк. Сколько элементов будет в каждой строке пока не известно. */

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

for(int i=0; i<5; i++) { dd2[i] = new int[i+2]; }

В результате получим такой вот массив:

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Мы могли создать массив явно указав его элементы. Например так:

int[][] ddd2 = {{1,2}, {1,2,3,4,5}, {1,2,3}};

При этом можно обратиться к элементу с индексом 4 во второй строке ddd2[1][4], но если мы обратимся к элементу ddd2[0][4] или ddd2[2][4] — произойдёт ошибка, поскольку таких элементов просто нет. Притом ошибка это будет происходить уже во время исполнения программы (т. е. компилятор её не увидит).

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

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

Пример (заполняем двумерный массив случайными числами от 0 до 9 и выводим его на жкран в виде матрицы):

int[][] da = new int[6][4]; for(int i=0; i<da.length; i++) { for(int j=0; j<da[i].length; j++) { da[i][j] = (int)(Math.random()*10); } } for(int i=0; i<da.length; i++) { for(int j=0; j<da[i].length; j++) { System.out.print(da[i][j] + "\t"); } System.out.println(); // Переходим на следующую строку }

Задачи

1. Создать двумерный массив из 8 строк по 5 столбцов в каждой из случайных целых чисел из отрезка [10;99].

   Вывести массив на экран.

2. Создать двумерный массив из 5 строк по 8 столбцов в каждой из случайных целых чисел из отрезка [-99;99]. Вывести массив на экран. После на отдельной строке вывести на экран значение максимального элемента этого массива (его индекс не имеет значения).

3. Cоздать двумерный массив из 7 строк по 4 столбца в каждой из случайных целых чисел из отрезка [-5;5]. Вывести массив на экран. Определить и вывести на экран индекс строки с наибольшим по модулю произведением элементов. Если таких строк несколько, то вывести индекс первой встретившейся из них.

4. Создать двумерный массив из 6 строк по 7 столбцов в каждой из случайных целых чисел из отрезка [0;9]. Вывести массив на экран. Преобразовать массив таким образом, чтобы на первом месте в каждой строке стоял её наибольший элемент. При этом изменять состав массива нельзя, а можно только переставлять элементы в рамках одной строки. Порядок остальных элементов строки не важен (т.е. можно соврешить только одну перестановку, а можно отсортировать по убыванию каждую строку). Вывести преобразованный массив на экран.

5. Для проверки остаточных знаний учеников после летних каникул, учитель младших классов решил начинать каждый урок с того, чтобы задавать каждому ученику пример из таблицы умножения, но в классе 15 человек, а примеры среди них не должны повторяться. В помощь учителю напишите программу, которая будет выводить на экран 15 случайных примеров из таблицы умножения (от 2*2 до 9*9, потому что задания по умножению на 1 и на 10 — слишком просты). При этом среди 15 примеров не должно быть повторяющихся (примеры 2*3 и 3*2 и им подобные пары считать повторяющимися).