Неровные массивы 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

Объявим массив, для хранения элементов типа int:

Здесь объявлена переменная arr, которая является массивом. Чтоб использовать эту переменную нужно её определить.

Определение массива в Java

Для определения массива в Java следует указать его длину, т.е. количество элементов, которые могут в нём храниться:

В нашем массиве бедет храниться 5 элементов.

Массив - это набор элементов. К каждому элементу массива можно обратиться по его номеру. Номер принято называть индексом. Нумерация элементов массива в Java идёт с нуля.

Как загрузить элементы в массив?

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

Присвоим значение второму элементу массива, а второй элемент имеет индекс один:

for(int inn = 0; inn < 5; inn++)
{
arr = 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 можно так:

Как получить длину массива в Java?

Длину массива в Java получаем так:

int arrLength = arr.length;

Как получить первый элемент массива в Java?

int firstElem = arr;

Как получить полследний элемент массива в Java?

int lastElem = arr;

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

Как в Java задать массив переменной длины? Никак. Когда вы определяете массив, тогда и задаёте его длину, изменить её в дальнейшем нельзя. В таких случаях используют коллекции, например: Vector, ArrayList и др.

Итак, перемнной длина массива быть не может. Но можно использовать переменную при определении массива. Если так:

int cd;
int ab = new int;//Error.

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

Надо задать значение cd:

int cd = 10;
int ab = new int;

Теперь нормально. Если после определения массива изменить переменную 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;
int elem = arr;
var = 2;
elem = arr;

Массив символов в Java

Пример массива символов в Java и его вывода:

Char charArr = {"S", "B", "P"}; for(int inn = 0; inn < charArr.length; inn++) { System.out.println("charArr[" + inn + "] = " + charArr); }

Как заполнить массив в Java?

Заполнить массив можно с помощью статического метода fill.

Массив - это структура данных, в которой хранятся величины одинакового типа. Доступ к отдельному элементу массива осуществляется с помощью целого индекса. Например, если а - массив целых чисел, то значение выражения а [ 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 нет арифметики указателей - нельзя увеличить указатель а, чтобы обратиться к следующему элементу массива. Ссылка на перво

• 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% медленнее чем последовательный. Возможно и в правду какую-то роль может сыграть кэш. Однако, в исходной ситуации производительность проседала в разы. Значит есть еще что-то.

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

Теги: Добавить метки

Массив - это структура данных, в которой хранятся величины одинакового типа. Доступ к отдельному элементу массива осуществляется с помощью целого индекса. Например, если а - массив целых чисел, то значение выражения а [ 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 нет арифметики указателей - нельзя увеличить указатель а, чтобы обратиться к следующему элементу массива. Ссылка на перво