Создать новый массив в java. Изучаем Java. Что такое массив

Последнее обновление: 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(); }

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

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

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

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

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

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

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

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

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

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

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

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

intarr = newint;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Заключение

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

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

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

Статья разделена на три части:

Небольшое замечание с самого начала. Массив, какого бы типа и размерности он ни был, является объектом. Это значит, что он обладает всеми свойствами и методами объекта.

Итак, начнем мы с простейших случаев, а именно –

Одномерные массивы примитивных типов

Эти массивы практически не отличаются от того, к чему привыкли программисты, использующие другие языки. Создание массива производится с помощью все того же оператора new:

// creating array of integers with 5 elements: int array = new int ;

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

int array = new int ; System.out.println("Array size: "+array.length); // will print: Array size: 5

Свойство это является final , потому выставить через него новый размер массива, увы, не получится.

Вторая мелочь – контроль выхода за границы массива. Это делает интерпретатор, в случае выхода индекса за пределы массива будет инициировано исключение java.lang.ArrayIndexOutOfBoundsException . Перехватывать его не обязательно, и, я бы даже сказал, нежелательно, т.к. это RuntimeException и сигнализирует оно о том, что программа работает неправильно. И уж совсем не стоит проектировать приложение в расчете на то, что после прохождения всего массива будет брошено это исключение, и это будет сигналом к завершению цикла обработки. Это очень плохая идея.

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

Есть одна тонкость. При создании размер массива может быть задан равным 0 . Это будет вполне полноценный массив, содержащий 0 элементов. Его свойство.length равно 0. Такая конструкция временами оказывается весьма полезной.

Пара слов о копировании. Тривиальный способ – создать массив такого же размера и в цикле перенести содержимое. Хорошо, надежно, но не очень быстро. Есть способ быстрее – использовать метод System.arraycopy(...) . В этом методе после всех проверок происходит просто копирование области памяти. Сигнатура этого метода такая:

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

Копирование происходит из массива src , начиная с позиции srcPos , в массив dest , начиная с позиции destPos . Всего копируется length элементов. Обратите внимание, что src и dest имеют тип Object . Это сделано для того, чтобы этот метод мог обрабатывать массивы любого типа. Если src или dest не является массивом, будет инициировано исключение java.lang.ArrayStoreException .

Собственно, о массивах примитивных типов сказать больше нечего. Потому плавно переходим к следующему разделу:

Одномерные массивы объектов

Бо льшая часть из того, что сказано о массивах примитивных типов, верна и для массивов объектов. Их размер может быть получен через.length , выход за границы контролируется. Создаются они через оператор new:

// array of java.awt.Point with 10 elements: java.awt.Point points = new java.awt.Point;

Заметьте, вызова конструктора тут НЕТ. java.awt.Point после оператора new указывает лишь на тип элементов создаваемого массива.

После создания массив точно так же инициализируется значением по умолчанию... И вот тут есть большой подводный камень. Вопрос на засыпку. А каково это значение по умолчанию? Объект, созданный вызовом конструктора без параметров? А если такого конструктора нет? Ответ кроется в ответе на другой вопрос: а что, собственно, хранится в этом массиве?

А хранятся в этом массиве не объекты. Там хранятся ссылки на них. Как любая переменная объектного типа является ссылкой на объект, так и любой элемент массива тоже является ссылкой. А для ссылки значение по умолчанию – null !

Эта ошибка чуть ли не классическая. Очень часто приходится встречать вопросы "откуда тут берется NullPointerException " по отношению к коду следующего вида:

Java.awt.Point points = new java.awt.Point; points.x = 1; // <-- here is a NullPointerException

Теперь, думаю, понятно, откуда берется эта ошибка. Массив создан и его элементы инициализированы значением null . Однако сами объекты не созданы. Ситуация в точности аналогична использованию переменной со значением null . Правильный фрагмент выглядит так:

Java.awt.Point points = new java.awt.Point; for (int i=0; inew java.awt.Point(); } // now you can use array points.x = 1; // <-- NO NullPointerException here!

Хочу специально коснуться вопроса копирования элементов массива объектов. Поскольку содержит он ссылки, именно они и копируются. Т.е. после копирования новый массив будет указывать на тот же самый набор объектов! И если изменить внутреннее состояние какого-либо из объектов – это будет видно при доступе к нему через любой из массивов.

Итак, мы потихоньку подобрались к самому интересному разделу –

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

Это наиболее отличающийся от других языков класс массивов. Честно говоря, такого я нигде больше не видел. Для простоты начнем с двумерных массивов, а потом уже перейдем к n-мерным.

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

Рассмотрим вот этот двумерный массив. Его длина по первому индексу равна 3 . Ее можно получить через a.length . Элементами этого массива являются ссылки на массивы с данными. Длина каждого из этих массивов может быть получена так же через.length . Доступ к каждому из этих массивов осуществляется через его индекс – первый индекс в массиве a .

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

// 2d array of ints with 10 rows of 5 elements each int array2d = new int;

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

Есть, однако, и другой способ. Для примера создадим массив, приведенный выше на рисунке:

int a = new int ; // line 1 a = new int ; // line 2 a = new int ; // line 3 a = new int ; // line 4

Обратите внимание, в строке 1 при инициализации массива не указана размерность по второму индексу!

Что происходит в этом коде? В строке 1 создается массив по первому индексу, размером 3 . Это означает, что выделяется память под три ссылки на массивы-строки. Сами массивы не создаются, выделенная память инициализирована значениями null .

В строке 2 создается массив длиной 2 . Ссылка на этот массив сохраняется в первом элементе массива по первому индексу. Точно так же в строках 3 и 4 создаются массивы, ссылки на которые сохраняются во втором и третьем элементах массива по первому индексу.

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

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

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

N-мерный массив является одномерным массивом, элементами которого являются ссылки на массивы размерности N-1.

Соответственно, N-мерные массивы можно создавать одним выражением, с использованием оператора new и указанием размеров по всем измерениям. А можно и последовательно – создать массив, указав размерность по одному или нескольким индексам, а оставшиеся неинициализированными ссылки проинициализировать вручную, создавая массивы нужной мерности, но произвольного размера/формы. Однако для массивов большой мерности это довольно сложная задача, на мой взгляд. Собственно, как и вообще работа с многомерными массивами.

Отдельно несколько слов о копировании многомерных массивов с помощью System.arraycopy . Массивы будут копироваться ТОЛЬКО по первому индексу. Иначе говоря, во второй массив будут перенесены ссылки на массивы размерности N-1 из первого массива. В случае двумерного массива – это ссылки на массивы-строки. Это обстоятельство весьма облегчает копирование массивов, скажем, при добавлении новой строки – память нужно выделять только под массив по первому индексу. Далее ссылки на все строки будут скопированны в новый массив, а последняя ссылка, которая должна указывать на новую строку, будет проинициализирована вручную:

int initArray; // initial array int newArrayLength = initArray.length+1; int newArray = new int ; for (int i=0; inew int [];

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

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

Всем спасибо! Надеюсь, кому-то эта информация оказалась полезной и интересной.

Учеба на "Разработчика игр" + трудоустройство

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 нет арифметики указателей - нельзя увеличить указатель а, чтобы обратиться к следующему элементу массива.