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

Java ,

Алгоритмы

• Tutorial

Думаю, мало кто из готовящихся к своему первому интервью, при приеме на первую работу в должности (pre)junior программиста, ответит на этот вопрос отрицательно. Или хотя бы усомнится в положительном ответе. Конечно, такая простая структура данных с прямым доступом по индексу - никаких подвохов! Нет, в некоторых языках типа JavaScript или PHP массивы, конечно, реализованы очень интересно и по сути являются много большим чем просто массив. Но речь не об этом, а о «традиционной» реализации массивов в виде «сплошного участка памяти». В этом случае на основании индексов и размера одного элемента просто вычисляется адрес и осуществляется доступ к соответствующему значению. Что тут сложного?
Давайте разберемся. Например, на Java. Просим ничего не подозревающего претендента создать массив целых чисел n x n . Человек уверено пишет что-то в духе:
int g = new int[n][n];
Отлично. Теперь просим инициализировать элементы массива чем-нибудь. Хоть единицами, хоть суммой индексов. Получаем:
for(int i = 0; i < n; i++) { for(int j = 0; j < n; j++) { g[i][j] = i + j; } }
Даже чаще пишут
for(int i = 0; i < g.length; i++) { for(int j = 0; j < g[i].length; j++) { g[i][j] = i + j; } }
что тоже повод для беседы, но сейчас речь о другом. Мы ведь пытаемся выяснить, что человек знает и посмотреть, как он думает. По этому обращаем его внимание на тот факт, что значения расположены симметрично и просим сэкономить на итерациях циклов. Конечно, зачем пробегать все значения индексов, когда можно пройти только нижний треугольник? Испытуемый обычно легко соглашается и мудро выделяя главную диагональ старательно пишет что-то в духе:
for(int i = 0; i < n; i++) { g[i][i] = 2* i; for(int j = 0; j < i; j++) { g[j][i] = g[i][j] = i + j; } }
Вместо g[i][i] = 2* i; часто пишут g[i][i] = i + i; или g[i][i] = i << 1; и это тоже повод поговорить. Но мы идем дальше и задаем ключевой вопрос: На сколько быстрее станет работать программа? . Обычные рассуждения такие: почти в 2 раза меньше вычислений индексов; почти в 2 раза меньше вычислений значений (суммирование); столько же присваиваний. Значит быстрее процентов на 30. Если у человека за плечами хорошая математическая школа, то можно даже увидеть точное количество сэкономленных операций и более аргументированную оценку эффективности оптимизации.
Теперь самое время для главного удара. Запускаем оба варианта кода на каком-нибудь достаточно большом значении n (порядка нескольких тысяч), например, так .

Код с контролем времени

class A { public static void main(String args) { int n = 8000; int g = new int[n][n]; long st, en; // one st = System.nanoTime(); for(int i = 0; i < n; i++) { for(int j = 0; j < n; j++) { g[i][j] = i + j; } } en = System.nanoTime(); System.out.println("\nOne time " + (en - st)/1000000.d + " msc"); // two st = System.nanoTime(); for(int i = 0; i < n; i++) { g[i][i] = i + i; for(int j = 0; j < i; j++) { g[j][i] = g[i][j] = i + j; } } en = System.nanoTime(); System.out.println("\nTwo time " + (en - st)/1000000.d + " msc"); } }

Что же мы видим? Оптимизированный вариант работает в 10-100 раз медленнее! Теперь самое время понаблюдать за реакцией претендента на должность. Какая будет реакция на необычную (точнее обычную в практике разработчика) стрессовую ситуацию. Если на лице подзащитного изобразился азарт и он стал жать на кнопочки временно забыв о Вашем существовании, то это хороший признак. До определенной степени. Вы ведь не хотите взять на работу исследователя, которому плевать на результат проекта? Тогда не задавайте ему вопрос «Почему?». Попросите переделать второй вариант так, чтобы он действительно работал быстрее первого.
Теперь можно смело заниматься некоторое время своими делами. Через пол часа у Вас будет достаточно материала, для того, чтобы оценить основные личностные и профессиональные качества претендента.
Кстати, когда я коротко описал эту задачку на своем рабочем сайте, то наиболее популярный комментарий был «Вот такая эта Ваша Java кривая». Специально для них выкладываю код на Великом и Свободном. А счастливые обладатели Free Pascal под Windows могут заглянуть

под спойлер

program Time; uses Windows; var start, finish, res: int64; n, i, j: Integer; g: Array of Array of Integer; begin n:= 10000; SetLength(g, n, n); QueryPerformanceFrequency(res); QueryPerformanceCounter(start); for i:=1 to n-1 do for j:=1 to n-1 do g := i + j; QueryPerformanceCounter(finish); writeln("Time by rows:", (finish - start) / res, " sec"); QueryPerformanceCounter(start); for i:=1 to n-1 do for j:=1 to n-1 do g := i + j; QueryPerformanceCounter(finish); writeln("Time by cols:", (finish - start) / res, " sec"); end.

В приведенном коде на Паскале я убрал «запутывающие» моменты и оставил только суть проблемы. Если это можно назвать проблемой.
Какие мы в итоге получаем вопросы к подзащитному?
1. Почему стало работать медленнее? И поподробнее…
2. Как сделать инициализацию быстрее?

Если есть необходимость копнуть глубже именно в реализацию Java, то просим соискателя понаблюдать за временем выполнения для небольших значений n . Например, на ideone.com для n=117 «оптимизированный» вариант работает вдвое медленнее. Но для следующего значения n=118 он оказывается уже в 100 (сто) раз быстрее не оптимизированного! Предложите поэкспериментировать на локальной машине. Пусть поиграет с настройками.
Кстати, а всем понятно, что происходит?

Несколько слов в оправдание

Хочу сказать несколько слов в оправдание такого способа собеседования при найме. Да, я не проверяю знание синтаксиса языка и владение структурами данных. Возможно, при цивилизованном рынке труда это все работает. Но в наших условиях тотальной нехватки квалифицированных кадров, приходится оценивать скорее перспективную адекватность претендента той работе с которой он столкнется. Т.е. способность научиться, прорваться, разобраться, сделать.
По духу это похоже на «собеседованию» при наборе легионеров в древнем Риме. Будущего вояку сильно пугали и смотрели краснеет он или бледнеет. Если бледнеет, то в стрессовой ситуации у претендента кровь отливает от головы и он склонен к пассивной реакции. Например, упасть в обморок. Если же соискатель краснел, то кровь у него к голове приливает. Т.е. он склонен к активным действиям, бросаться в драку. Такой считался годным.
Ну и последнее. Почему я рассказал об этой задаче всем, а не продолжаю использовать её на собеседованиях? Просто, эту задачу уже «выучили» потенциальные соискатели и приходится использовать другие.
Собственно на этот эффект я обратил внимание именно в связи с реальной задачей обработки изображений. Ситуация была несколько запутанная и я не сразу понял почему у меня так просел fps после рефакторинга. А вообще таких чуднЫх моментов наверное много накопилось у каждого.

Пока лидирует версия, что «виноват» кэш процессора. Т.е. последовательный доступ в первом варианте работает в пределах хэша, который обновляется при переходе за определенную границу. При доступе по столбцам хэш вынужден постоянно обновляться и это занимает много времени. Давайте проверим эту версию в самом чистом виде. Заведем массив и сравним, что быстрее - обработать все элементы подряд или столько же раз обработать элементы массива со случайным номером? Вот эта программа - ideone.com/tMaR2S . Для 100000 элементов массива случайный доступ обычно оказывается заметно быстрее. Что же это означает?
Тут мне совершенно справедливо указали (Big_Lebowski), что перестановка циклов меняет результаты в пользу последовательного варианта. Пришлось для чистоты эксперимента поставить цикл для разогрева. Заодно сделал несколько повторов, чтобы вывести среднее время работы как советовал leventov. Получилось так ideone.com/yN1H4g . Т.е. случайный доступ к элементам большого массива на ~10% медленнее чем последовательный. Возможно и в правду какую-то роль может сыграть кэш. Однако, в исходной ситуации производительность проседала в разы. Значит есть еще что-то.

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

Теги:

• Программирование
• массивы
• память

Добавить метки

Мы научились создавать одномерные массивы. Подобным образом в 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. Отсортируйте элементы в строках двумерного массива по возрастанию

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

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

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

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

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

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

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

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

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

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

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

intarr = newint;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Заключение

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

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

Массивы (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) a[i] = max; mySecond[i] = a[i]; System.out.println("a[" + i + "]=" + a[i]); } myArray = a; // установка ссылки на массив a } }

В результате выполнения будет выведено:

>java FindReplace a=5 a=10 a=0 a=5 a=16 a=5

Присваивание mySecond[i] = a[i] приведет к тому, что части элементов массива mySecond , а именно шести, будут присвоены значения элементов массива a . Остальные элементы mySecond сохранят значения, полученные при инициализации, то есть нули. Если же присваивание организовать в виде mySecond = a или myArray = a , то оба массива участвующие в присваивании получат ссылку на массив a , то есть оба будут содержать по шесть элементов и ссылаться на один и тот же участок памяти.
Массивы можно инициализировать во время их объявления. Процесс во многом аналогичен тому, что используется при инициализации простых ти­пов. Инициализатор массива – это список разделенных запятыми выражений, окруженный фигурными скобками. Массив будет автоматически создаваться достаточно большим, чтобы содержать столько элементов, сколько вы определяете в инициализаторе массива. Нет необходимости использовать операцию new . Например, чтобы хранить число дней в каждом месяце, сле­дующий код создает инициализированный массив целых чисел:

Public class MonthDays { public static void main(String args) { int month_days = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; System.out.println("Апрель содержит " + month_days + " дней."); } }

В результате выполнения программы на экран будет выведено:

Апрель содержит 30 дней.

Замечание: Java делает строгие проверки, чтобы удостовериться, что вы случайно не пробуете сохранять или читать значения вне области хранения массива. Исполнительная система Java тоже делает тщательные проверки, чтобы убедиться, что все индексы массивов находятся в правильном диапазоне. (В этом отношении Java существенно отличается от языков C/C++ , которые не обеспечивают проверки границ во время выполнения).

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

В Java многомерные массивы – это, фактически, массивы массивов. Они выглядят и действуют подобно регулярным многомерным массивам. Однако имеется пара тонких различий. Чтобы объявить многомерную переменную массива, определите каждый дополнительный индекс, используя другой набор квадратных скобок. Например, следующее утверждение объявляет переменную двумерного массива с именем twoD:
int twoD = new int;
Оно распределяет память для массива 4x5 и назначает ее переменной twoD . Внутренне эта матрица реализована как массив массивов целых чисел тип int .
Многомерные массивы возможно инициализировать. Для этого просто включают инициализатор каждого измерения в его собственный набор фи­гурных скобок.
В следующей программе создаются и инициализируются массивы массивов равной длины (матрицы), и выполняется произведение одной матрицы на другую:

Public class Matrix { private int a; Matrix(int n, int m) { // создание и заполнение с random a = new int[n][m]; for (int i = 0; i < n; ++i) for (int j = 0; j < m; ++j) a[i][j] = (int) (Math.random()*5); show(); } public Matrix(int n, int m, int k) { // создание и заполнение с random a = new int[n][m]; for (int i = 0; i < n; ++i) for (int j = 0; j < m; ++j) a[i][j] = k; if (k != 0) show(); } public void show() { System.out.println("Матрица:" + a.length + " на " + a.length); for (int i = 0; i < a.length; ++i) { for (int j = 0; j < a.length; ++j) System.out.print(a[i][j] + " "); System.out.println(); } } public static void main(String args) { int n = 2, m = 3, z = 4; Matrix p = new Matrix(n, m); Matrix q = new Matrix(m, z); Matrix r = new Matrix(n, z, 0); for (int i = 0; i < p.a.length; ++i) for (int j = 0; j < q.a.length; ++j) for (int k = 0; k < p.a[i].length; ++k) r.a[i][j] += p.a[i][k]*q.a[k][j]; System.out.println("Произведение матриц: "); r.show(); } }

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

> javac Matrix.java > java Matrix Матрица:2 на 3 3 2 0 3 3 1 Матрица:3 на 4 1 2 2 3 3 2 3 2 1 2 3 2 Произведение матриц: Матрица:2 на 4 9 10 12 13 13 14 18 17

Следующий пример демонстрирует копирование массива:

Public class ArrayCopyDemo { public static void main(String args) { int mas1 = {1,2,3}, mas2 = {4,5,6,7,8,9}; System.out.print("mas1: "); show(mas1); System.out.print("mas2: "); show(mas2); // копирование массива mas1 в mas2 System.arraycopy(mas1, 0, mas2, 2, 3); /* 0 - mas1 копируется начиная с нулевого элемента * 2 - элемент, с которого начинается замена * 3 - количество копируемых элементов */ System.out.println("\n после arraycopy(): "); System.out.print("mas1: "); show(mas1); System.out.print("\nmas2: "); show(mas2); } private static void show(int mas) { for (int i = 0; i < mas.length; ++i) System.out.print(" " + mas[i]); } }

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

> javac ArrayCopyDemo.java > java ArrayCopyDemo mas1: 1 2 3mas2: 4 5 6 7 8 9 после arraycopy(): mas1: 1 2 3 mas2: 4 5 1 2 3 9

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

Существует иная форма, которая может использоваться для объявления массива:
type var-name;
Здесь квадратные скобки следуют за спецификатором типа, а не именем переменной массива. Например, следующие два объявления эквивалентны:

Int al = new int; int a2 = new int;
Представленные здесь объявления также эквивалентны:
char twodi = new char; char twod2 = new char;
Эта альтернативная форма объявления включена, главным образом, для удобства.