Вредоносное ПО (malware) - это назойливые или опасные программы,...
Мы научились создавать одномерные массивы. Подобным образом в 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, следующего за ним - 1 и т. д. Индекс последнего элемента в массиве - на единицу меньше, чем размер массива. В Java массивы являются объектами. Это значит, что имя, которое даётся каждому массиву, лишь указывает на адрес какого-то фрагмента данных в памяти. Кроме адреса в этой переменной ничего не хранится. Индекс массива, фактически, указывает на то, насколько надо отступить от начального элемента массива в памяти, чтоб добраться до нужного элемента. Чтобы создать массив надо объявить для него подходящее имя, а затем с этим именем связать нужный фрагмент памяти, где и будут друг за другом храниться значения элементов массива.Возможные следующие варианты объявления массива:
тип имя;
тип имя;
Где тип
- это тип элементов массива, а имя
- уникальный (незанятый другими переменными или объектами в этой части программы) идентификатор, начинающийся с буквы. Примеры:
int a;
double ar1;
double ar2;
В примере мы объявили имена для трёх массивов. С первом именем a
сможет быть далее связан массив из элементов типа int, а с именами ar1
и ar2
далее смогут быть связаны массивы из вещественных чисел (типа double). Пока мы не создали массивы, а только подготовили имена для них. Теперь создать (или как ещё говорят инициализировать) массивы можно следующим образом:
a = new int; // массив из 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;
Чтобы обратиться к какому-то из элементов массива для того, чтобы прочитать или изменить его значение, нужно указать имя массива и за ним индекс элемента в квадратных скобках. Элемент массива с конкретным индексом ведёт себя также, как переменная. Например, чтобы вывести последний элемент массива mas1 мы должны написать в программе: System.out.println("Последний элемент массива " + mas1);
А вот так мы можем положить в массив mas2 тот же набор значений, что хранится в mas1: Mas2 = 10;
mas2 = 20;
mas2 = 30;Уже из этого примера видно, что для того, чтоб обратиться ко всем элементам массива, нам приходится повторять однотипные действия. Как вы помните для многократного повторения операций используются циклы. Соответственно, мы могли бы заполнить массив нужными элементами с помощью цикла:
for(int i=0; iПонятно, что если бы массив у нас был не из 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) потому, что нам заранее известно сколько раз должен повториться цикл (столько же раз, сколько элементов в массиве). Создайте массив из всех чётных чисел от 2 до 20 и выведите элементы массива на экран сначала в строку, отделяя один элемент от другого пробелом, а затем в столбик (отделяя один элемент от другого началом новой строки). Перед созданием массива подумайте, какого он будет размера. 2 4 6 … 18 20 Создайте массив из всех нечётных чисел от 1 до 99, выведите его на экран в строку, а затем этот же массив выведите на экран тоже в строку, но в обратном порядке (99 97 95 93 … 7 5 3 1). Создайте массив из 15 случайных целых чисел из отрезка . Выведите массив на экран. Подсчитайте сколько в массиве чётных элементов и выведете это количество на экран на отдельной строке. Создайте массив из 8 случайных целых чисел из отрезка . Выведите массив на экран в строку. Замените каждый элемент с нечётным индексом на ноль. Снова выведете массив на экран на отдельной строке. Создайте 2 массива из 5 случайных целых чисел из отрезка каждый, выведите массивы на экран в двух отдельных строках. Посчитайте среднее арифметическое элементов каждого массива и сообщите, для какого из массивов это значение оказалось больше (либо сообщите, что их средние арифметические равны). Создайте массив из 4 случайных целых чисел из отрезка , выведите его на экран в строку. Определить и вывести на экран сообщение о том, является ли массив строго возрастающей последовательностью. Создайте массив из 20-ти первых чисел Фибоначчи и выведите его на экран. Напоминаем, что первый и второй члены последовательности равны единицам, а каждый следующий - сумме двух предыдущих. Создайте массив из 12 случайных целых чисел из отрезка [-15;15]. Определите какой элемент является в этом массиве максимальным и сообщите индекс его последнего вхождения в массив. Создайте два массива из 10 целых случайных чисел из отрезка и третий массив из 10 действительных чисел. Каждый элемент с i-ым индексом третьего массива должен равняться отношению элемента из первого массива с i-ым индексом к элементу из второго массива с i-ым индексом. Вывести все три массива на экран (каждый на отдельной строке), затем вывести количество целых элементов в третьем массиве. Создайте массив из 11 случайных целых чисел из отрезка [-1;1], выведите массив на экран в строку. Определите какой элемент встречается в массиве чаще всего и выведите об этом сообщение на экран. Если два каких-то элемента встречаются одинаковое количество раз, то не выводите ничего. Пользователь должен указать с клавиатуры чётное положительное число, а программа должна создать массив указанного размера из случайных целых чисел из [-5;5] и вывести его на экран в строку. После этого программа должна определить и сообщить пользователю о том, сумма модулей какой половины массива больше: левой или правой, либо сообщить, что эти суммы модулей равны. Если пользователь введёт неподходящее число, то программа должна требовать повторного ввода до тех пор, пока не будет указано корректное значение. Программа должна создать массив из 12 случайных целых чисел из отрезка [-10;10] таким образом, чтобы отрицательных и положительных элементов там было поровну и не было нулей. При этом порядок следования элементов должен быть случаен (т. е. не подходит вариант, когда в массиве постоянно выпадает сначала 6 положительных, а потом 6 отрицательных чисел или же когда элементы постоянно чередуются через один и пр.). Вывести полученный массив на экран. Пользователь вводит с клавиатуры натуральное число большее 3, которое сохраняется в переменную n. Если пользователь ввёл не подходящее число, то программа должна просить пользователя повторить ввод. Создать массив из n случайных целых чисел из отрезка и вывести его на экран. Создать второй массив только из чётных элементов первого массива, если они там есть, и вывести его на экран. Иллюстрация: For (int i = 0; i
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 a) {
int temp = a[j];
a[j] = a;
a = temp;
sorted = false;
}
}
/* Если массив отсортирован (т.е. не было ни одной перестановки
* во внутреннем цикле, значит можно прекращать работу внешнего
* цикла.
*/
if(sorted) {
break;
}
}
Массив может состоять не только из элементов какого-то встроенного типа (int, double и пр.), но и, в том числе, из объектов какого-то существующего класса и даже из других массивов. Массив который в качестве своих элементов содержит другие массивы называется многомерным массивом.Чаще всего используются двумерные массивы. Такие массивы можно легко представить в виде матрицы. Каждая строка которой является обычным одномерным массивом, а объединение всех строк - двумерным массивом в каждом элементе которого хранится ссылка на какую-то строку матрицы.Трёхмерный массив можно представить себе как набор матриц, каждую из которых мы записали на библиотечной карточке. Тогда чтобы добраться до конкретного числа сначала нужно указать номер карточки (первый индекс трёхмерного массива), потому указать номер строки (второй индекс массива) и только затем номер элемент в строке (третий индекс).
Соответственно, для того, чтобы обратиться к элементу n-мерного массива нужно указать n индексов. Объявляются массивы так:
int d1; //Обычный, одномерный
int d2; //Двумерный
double d3; //Трёхмерный
int d5; //Пятимерный
При создании массива можно указать явно размер каждого его уровня:
d2 = int; // Матрица из 3 строк и 4 столбцов
Но можно указать только размер первого уровня:
int dd2 = int; /* Матрица из 5 строк. Сколько элементов будет в каждой строке пока не известно. */
В последнем случае, можно создать двумерный массив, который не будет являться матрицей из-за того, что в каждой его строке будет разное количество элементов. Например:
for(int i=0; i<5; i++) {
dd2[i] = new int;
}
В результате получим такой вот массив:
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
, но если мы обратимся к элементу ddd2 или ddd2
- произойдёт ошибка, поскольку таких элементов просто нет. Притом ошибка это будет происходить уже во время исполнения программы (т. е. компилятор её не увидит). Обычно всё же используются двумерные массивы с равным количеством элементов в каждой строке.Для обработки двумерных массивов используются два вложенных друг в друга цикла с разными счётчиками.Пример (заполняем двумерный массив случайными числами от 0 до 9 и выводим его на жкран в виде матрицы):
int da = new int;
for(int i=0; i Создать двумерный массив из 8 строк по 5 столбцов в каждой из случайных целых чисел из отрезка . Вывести массив на экран. Создать двумерный массив из 5 строк по 8 столбцов в каждой из случайных целых чисел из отрезка [-99;99]. Вывести массив на экран.
После на отдельной строке вывести на экран значение максимального элемента этого массива (его индекс не имеет значения). Cоздать двумерный массив из 7 строк по 4 столбца в каждой из случайных целых чисел из отрезка [-5;5].
Вывести массив на экран. Определить и вывести на экран индекс строки с наибольшим по модулю произведением элементов.
Если таких строк несколько, то вывести индекс первой встретившейся из них. Создать двумерный массив из 6 строк по 7 столбцов в каждой из случайных целых чисел из отрезка . Вывести массив на экран.
Преобразовать массив таким образом, чтобы на первом месте в каждой строке стоял её наибольший элемент.
При этом изменять состав массива нельзя, а можно только переставлять элементы в рамках одной строки.
Порядок остальных элементов строки не важен (т.е. можно соврешить только одну перестановку, а можно отсортировать по убыванию каждую строку).
Вывести преобразованный массив на экран. Для проверки остаточных знаний учеников после летних каникул, учитель младших классов решил начинать каждый урок с того,
чтобы задавать каждому ученику пример из таблицы умножения, но в классе 15 человек,
а примеры среди них не должны повторяться. В помощь учителю напишите программу,
которая будет выводить на экран 15 случайных примеров из таблицы умножения (от 2*2 до 9*9, потому что задания по умножению
на 1 и на 10 - слишком просты). При этом среди 15 примеров не должно быть повторяющихся (примеры 2*3 и 3*2 и им
подобные пары считать повторяющимися). 2010, Алексей Николаевич Костин. Кафедра ТИДМ математического факультета МПГУ. Массив в Java - это набор элементов одного типа, обратиться к которым можно по индексу. Элементы массивов в Java расположены друг за другом в памяти компьютера. Ниже разбирается пример массива в Java. Объявим массив, для хранения элементов типа int: Здесь объявлена переменная arr, которая является массивом. Чтоб использовать эту переменную нужно её определить. Для определения массива в Java следует указать его длину, т.е. количество элементов, которые могут в нём храниться: В нашем массиве бедет храниться 5 элементов. Массив - это набор элементов. К каждому элементу массива можно обратиться по его номеру. Номер принято называть индексом. Нумерация элементов массива в Java идёт с нуля. Присвоим значение первому элементу массива, а первый элемент имеет индекс ноль: Присвоим значение второму элементу массива, а второй элемент имеет индекс один: for(int inn = 0; inn < 5; 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 получаем так: int arrLength = arr.length; int firstElem = arr; int lastElem = arr; Как в Java задать массив переменной длины? Никак. Когда вы определяете массив, тогда и задаёте его длину, изменить её в дальнейшем нельзя. В таких случаях используют коллекции, например: Vector, ArrayList и др. Итак, перемнной длина массива быть не может. Но можно использовать переменную при определении массива. Если так: int cd; то получим ошибку, длина массива не может быть переменной. Надо задать значение cd: int cd = 10; Теперь нормально. Если после определения массива изменить переменную 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; Пример массива символов в Java и его вывода: Char charArr = {"S", "B", "P"};
for(int inn = 0; inn < charArr.length; inn++)
{
System.out.println("charArr[" + inn + "] = " + charArr);
}
Заполнить массив можно с помощью статического метода fill. Для примера рассмотрим двумерный массив в Java. Двумерные массивы Java - это прямоугольная или не прямоугольная таблица чисел. Двумерный массив Java состоит из рядов и столбцов. Первый индекс двумерного массива Java - это число рядов. Пример двумерного прямоугольного массива Java: Int multyArr;
multyArr = new int;
/*
* multyArr structure
* | (0,0) | (0,1) |
* | (1,0) | (1,1) |
*/
Здесь объявлен и определен двумерный массив, имеющий две строки и два столбца. Загрузим массив элементами: MultyArr = 1;
multyArr = 2;
multyArr = 3;
multyArr = 4;
Вывод двумерного массива (перебираем массив): System.out.println("multyArr");
for(int inn = 0; inn < 2; inn++)
{
for(int jnn = 0; jnn < 2; jnn++)
{
System.out.println("multyArr[" + inn + "][" + jnn + "] = " + multyArr );
}
}
Получаем:
for(int inn = 0; inn < 2; inn++) мы проходим по рядам, а в цикле for(int jnn = 0; jnn < 2; jnn++) по столбцам. Можно объявить и определить многомерный массив одновременно: int multyArr = {{1,2}, {3,4}}; Int multyArr = {{1,2}, {3,4}, {5,6}};
/*
* multyArr structure
* | 1 | 2 |
* | 3 | 4 |
* | 5 | 6 |
*/
System.out.println("Array length = " + multyArr.length);
Array length = 3 Здесь три ряда по два элемента каждый. Первая размерность - три, это и есть длина двумерного массива. Пример трехмерного массива в Java: int triArray; Здесь объявлен и определен трехмерный массив. Его можно представит как куб, состоящий из двух слоёв (layer), каждый слой состоит из двух рядов и двух столбцов, т.е. каждый слой - это двумерный массив. Как заполнить трехмерный массив? Можно в цикле, но мы для примера вручную заполним: Как вывести трехмерный массив? Или как перебрать трехмерный массив? Так. Массивы
(arrays) _ это упорядоченные наборы элементов одного типа. Элементами массива могут служить объекты простых и ссылочных типов, в том Числе и ссылки на другие массивы. Массивы сами по себе являются объектами и наследуют класс Object. Объявление int ia = new int; Определяет массив с именем ia, который изначально указывает на набор из трех Элементов типа int. В объявлении массива его размерность не указывается. Количество элементов массива задается при его создании посредством оператора new. Длина массива фиксируется в момент создания и в дальнейшем изменению не поддается. Впрочем, переменной
типа массива (в нашем примере – ia) в любой момент может быть поставлен в соответствие новый массив с другой размерностью. Доступ к элементам массива осуществляется по значениям их номеров-индексов. Первый элемент массива имеет индекс, равный нулю (0), а последний – length – 1. Обращение к элементу массива выполняется посредством задания имени массива и значения индекса, заключенного в квадратные скобки, [ и ]. в предыдущем примере первым элементом массива ia будет ia, а последним – ia. При каждом обращении к элементу массива по индексу исполняющая система Java проверяет, находится ли значение индекса в допустимых пределах, и генерирует исключение типа ArraylndexOutOfBoundsException, если результат проверки ложен. 6 Выражение индекса должно относиться к типу int – только этим и ограничивается максимальное количество элементов массива. Длину массива легко определить с помощью поля length объекта массива (которое неявно снабжено признаками publiс и final). Ниже приведен дополненный код прежнего примера, в котором предусмотрено выполнение Цикла, обеспечивающего вывод на экран содержимого каждого элемента массива ia: for (int i = о; i < ia.length; i++) system.out.println(i + ": " + ia[i]); Массив нулевой длины (т.е. такой, в котором нет элементов) принято называть пустым.
Обратите внимание, что ссылка на массив, равная значению null, и ссылка на пустой массив – это совершенно разные вещи. Пустой массив это реальный массив, в котором попросту отсутствуют элементы. Пустой массив представляет собой удобную альтернативу значению null при возврате из метода. Если метод способен возвращать null, прикладной код, в котором выполняется обращение к методу, должен сравнить возвращенное значение с null прежде, чем перейти к выполнению оставшихся операций. Если же метод возвращает массив (возможно, пустой), никакие дополнительные проверки не нужны – разумеется, помимо тех, которые касаются длины массива и должны выполняться в любом случае. Допускается и иная форма объявления массива, в которой квадратные скобки задаются после идентификатора массива, а не после наименования его типа: int ia = new int; Прежний синтаксис, однако, считается более предпочтительным, поскольку описание типа в таком случае выглядит более компактным. Модификаторы в объявлениях массивов
Правила употребления в объявлениях массивов тех или иных модификаторов
обычны и зависят только от того, к какой категории относится массив – к полям или Локальным переменным. Существует единственная особенность, которую важно помнить, – модификаторы применяются к массиву как таковому, но не к его отдельным элементам. Если в объявлении массива указан признак final, это значит только то, что ссылка на массив не может быть изменена после его создания, но никак не запрещает возможность изменения содержимого отдельных элементов массива. Язык не позволяет задавать каких бы то ни было модификаторов (скажем, final или уоlatilе) для элементов массива. Многомерные массивы
В Java поддерживается возможность объявления многомерных массивов
(multidimensional arrays) (т.е. массивов, элементами которых служат другие массивы), Код, предусматривающий объявление двумерной матрицы и вывод на экран содержимого ее элементов, может выглядеть, например, так: float mat = new float; setupMatrix(mat); for (int у = о; у < mat.length; у++) { for (int х = о; х < mat[y].length; х++) system.out.print(mat[y][x] + " "); system.out.println(); При создании массива должна быть указана, по меньшей мере, его первая, "самая левая", размерность. Другие размерности разрешается не задавать – в этом случае их придется определить позже. Указание в операторе new единовременно всех размерностей – это самый лаконичный способ создания массива, позволяющий избежать необходимости использования дополнительных операторов new. Выражение объявления и создания массива mat, приведенное выше, равнозначно следующему фрагменту кода: float mat = new float; for (int у = о; у < mat.length; у++) mat[y] = new float; Такая форма объявления обладает тем преимуществом, что позволяет наряду с получением массивов с одинаковыми размерностями (скажем, 4 х 4) строить и массивы массивов различных размерностей, необходимых для хранения тех или иных последовательностей данных. Инициализация массивов
При создании массива каждый его элемент получает значение, предусмотренное по умолчанию и зависящее от типа массива: нуль (0) – для числовых типов, ‘\u0000′ _ для char, false – для boolean и null – для ссылочных типов. Объявляя массив ссылочного типа, мы на самом деле определяем массив переменных
этого типа. Рассмотрим следующий фрагмент кода: Attr attrs = new Attr; for (int i = о; i < attrs.length; i++) attrs[i] = new Attr(names[i], values[i]); После выполнения первого выражения, содержащего оператор new, переменная attrs получит ссылку на массив из 12 переменных, которые инициализированы значением null, Объекты Attr как таковые будут созданы только в процессе про хождения цикла. Массив может инициализироваться (одновременно с объявлением) посредством конструкции в фигурных скобках, в которой перечислены исходные Значения его элементов: String dangers = { "Львы", "Тигры", "Медведи" }; Следующий фрагмент кода даст тот же результат: String dangers = new String; dangers = "Львы"; dangers = "Тигры"; dangers = "Медведи"; Первая форма, предусматривающая задание списка инициализаторов в фигурных скобках, не требует явного использования оператора new – он вызывается косвенно исполняющей системой. Длина массива в этом случае определяется Количеством значений-инициализаторов. Допускается и возможность явного задания оператора new, но размерность все равно следует опускать она, как и раньше, определяется исполняющей системой: String dangers = new String { "Львы", "Тигры", "Медведи" }; Подобную форму объявления и инициализации массива разрешается применять в любом месте кода, например в выражении вызова метода: printStringsCnew String { "раз", "два", "три" }); Массив без названия, который создается таким образом, называют анонимным
(anonymous). Массивы массивов могут инициализироваться посредством вложенных последовательностей исходных значений. Ниже приведен пример объявления массива, содержащего несколько первых строк так называемого треугольника Паскаля,
где каждая строка описана собственным массивом значений. int pascalsTriangle = { { 1, 4, 6, 4, 1 }, Индексы многомерных массивов следуют в порядке от внешнего к внутренним. Так, например, pascalsTriangle}
0 0
0 0 0
0 0 0 0
0 0 0 0 0Упражнения на тему многомерные массивы в Java:
Задачи
2
4
6
…
20Сортировка массива
Сортировкой называется такой процесс перестановки элементов массива, когда все его элементы выстраиваются по возрастанию или по убыванию.Сортировать можно не только числовые массивы, но и, например, массивы строк (по тому же принципу, как расставляют книги на библиотечных полках). Вообще сортировать можно элементы любого множества, где задано отношение порядка.Существуют универсальные алгоритмы, которые выполняют сортировку вне зависимости от того, каким было исходное состояние массива. Но кроме них существуют специальные алгоритмы, которые, например, очень быстро могут отсортировать почти упорядоченный массив, но плохо справляются с сильно перемешанным массивом (или вообще не справляются). Специальные алгоритмы нужны там, где важна скорость и решается конкретная задача, их подробное изучение выходит за рамки нашего курса.
Сортировка выбором
Рассмотрим пример сортировки по возрастанию. То есть на начальной позиции в массиве должен стоять минимальный элемент, на следующей - больший или равный и т. д., на последнем месте должен стоять наибольший элемент.Суть алгоритма такова. Во всём отыскиваем минимальный элемент, меняем его местами с начальным. Затем в оставшейся части массива (т. е. среди всех элементов кроме начального) снова отыскиваем минимальный элемент, меняем его местами уже со вторым элементом в массиве. И так далее.
Сортировка методом пузырька
Суть алгоритма такова. Если пройдёмся по любому массиву установив правильный порядок в каждой паре соседних элементов, то после того прохода на последнем месте массива гарантированно будет стоять нужный элемент (самый большой для сортировки по возрастанию или самый маленький для сортировки по убыванию). Если ещё раз пройтись по массиву с такими же преобразованиями, то и на предпоследнем месте гарантированно окажется нужный элемент. И так далее.Пример:
Многомерные массивы
Задачи
Что такое массив?
Объявление массива в Java
Определение массива в Java
Как загрузить элементы в массив?
{
arr = inn;
}Как получить элементы из массива?
Как удалить массив в Java?
Как получить длину массива в Java?
Как получить первый элемент массива в Java?
Как получить полследний элемент массива в Java?
Как в Java задать массив переменной длины?
int ab = new int;//Error.
int ab = new int;
int elem = arr;
var = 2;
elem = arr;Массив символов в Java
Как заполнить массив в Java?
Многомерные массивы в Java
Длина многомерного массива в Java
Трехмерный массив в Java
triArray = new int;
