Массивы. Java Array

Массив (англ. 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 присутствуют массивы. Эти массивы типизированы. Декларация

Point myPoints;

описывает переменную myPointsкак массив объектов типаPoint. Завести массив определенного размера можно с помощью инструкции вида

myPoints = new Point;

Значения элементов массива при этом устанавливаются равными специальной величине null.

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

howMany = myPoints.length;

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

int nAnotherNumbers;

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

При определении массивов в языке Java нельзя указывать их размер. Приведенные выше две строки не вызывают резервирования памяти для массива. Здесь просто создаются ссылки на массивы, которые без инициализации использовать нельзя.

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

int nAnotherNumbers;

nAnotherNumbers = new int;

Как выполнить инициализацию ячеек таблицы?

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

int nColorRed = {255, 255, 100, 0, 10};

Динамическая инициализация выполняется с использованием индекса массива, например, в цикле:

int nInitialValue = 7;

int nAnotherNumbers;

nAnotherNumbers = new int;

for(int i = 0; i < 15; i++)

Возможно создавать массивы не только из переменных базовых типов, но и из произвольных объектов. Каждый элемент такого массива должен инициализироваться оператором new.

Массивы могут быть многомерными и, что интересно, несимметричными.

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

int nDim = new int;

nDim = new int ;

nDim = new int ;

nDim = new int ;

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

Массивы в языке Java являются объектами некоторого встроенного класса. Для этого класса существует возможность определить размер массива, обратившись к элементу данных класса с именем length, например:

int nAnotherNumbers;

nAnotherNumbers = new int;

for(int i = 0; i < nAnotherNumbers.length; i++)

nAnotherNumbers[i] = nInitialValue;

Для определения размера массива вам не нужен такой оператор, как sizeof из языка программирования С, потому что существует другой способ определения этого размера.

Других структурных типов (не являющихся объектами) в языке Java нет, то есть нет структур, объединений и т.п. Нет в Java и указателей.

Строки символов являются объектами типа String(текстовые константы) илиStringBuffer(изменяемые строки). Пример:

String hello = "Hello world!";

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

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

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

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

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

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

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

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

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

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

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

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

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

Копирование происходит из массива 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, массив будет прямоугольным.

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

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

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

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

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

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

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

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

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

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

new int [];

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

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

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

Массив - это структура данных, в которой хранятся величины одинакового типа. Доступ к отдельному элементу массива осуществляется с помощью целого индекса. Например, если а - массив целых чисел, то значение выражения а [ i ] равно i-му целому числу в массиве. Массив объявляется следующим образом: сначала указывается тип массива, т.е тип элементов, содержащихся в массиве, за которым ставится пара пустых квадратных скобок, а затем - имя переменной. Например, вот как объявляется массив, состоящий из целых чисел: int a; Однако этот оператор лишь объявляет переменную а, не инициализируя ее настоящим массивом. Чтобы создать массив, нужно применить оператор new . int a = new int [ 100 ] ; Этот оператор создает массив, состоящий из 100 целых чисел. Элементы этого массива нумеруются от 0 до 99 (а не от 1 до 100). После создания массив можно заполнять, например, с помощью цикла. int а = new int [ 100 ] ; 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 } ; smallPrimes = anonymous; Можно создать массив нулевого размера. Такой массив может оказаться полезным при написании метода, вычисляющего некий массив, который оказывается пустым. Массив нулевой длины объявляется следующим образом: new тип Элементов Заметим, что такой массив не эквивалентен объекту null .

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

Один массив можно скопировать в другой, но при этом обе переменные будут ссылаться на один и тот же массив. int luckyNumbers = smallPrimes; luckyNumbers[ 5 ] = 12 ; //Теперь элемент smallPrimesтакже равен 12 Результат показан на рис. 3.1. Если необходимо скопировать все элементы одного массива в другой, следует использовать метод arraycopy из класса System . Его вызов выглядит следующим образом: System. arraycopy (from, fromlndex, to, tolndex, count) ; Массив to должен иметь достаточный размер, чтобы в нем поместились все копируемые элементы. Рис.3.1. Копирование массива Например, показанные ниже операторы, результаты работы которых изображены на рис. 3.2, создают два массива, а затем копируют последние четыре элемента первого массива во второй. Копирование начинается со второй позиции в исходном массиве, а копируемые элементы помещаются в целевой массив, начиная с третьей позиции. int smallPrimes = { 2 , 3 , 5 , 7 , 11 , 13 } ; int luckyNumbers = { 1001 , 1002 , 1003 , 1004 , 1005 , 1006 , 1007 } ; System. аrrаусору(smallPrimes, 2 , luckyNumbers, 3 , 4 ) ; for (int i = 0 ; i < luckyNumbers. length; i++ ) System. out. println (i + ": " + luckyNumbers[ i] ) ; Выполнение этих операторов приводит к следующему результату. 0 : 1001 1 : 1002 2 : 1003 3 : 5 4 : 7 5 : 11 6 : 13 Рис. 3.2. Копирование элементов массива Массив в языке Java значительно отличается от массива в языке C++. Однако он практически совпадает с указателем на динамический массив. Это значит, что оператор int a = new int [ 100 ] ; //Java эквивалентен оператору int * = new int [ 100 ] ; //C++, а не int a[ 100 ] ; //C++ В языке Java оператор пo умолчанию проверяет диапазон изменения индексов. Кроме того, в языке Java нет арифметики указателей - нельзя увеличить указатель а, чтобы обратиться к следующему элементу массива. Ссылка на перво