Многомерные массивы на java android. Массивы в Java — определение и создание, инициализация и заполнение

Массив (англ. Array) это объект, хранящий в себе фиксированное количество значений одного типа. Другими словами, массив — это нумерованный набор переменных. Переменная в массиве называется элементом массива , а ее позиция в массиве задается индексом . Например, нам нужно хранить 50 различных имен, согласитесь, неудобно для каждого имени создавать отдельную переменную, поэтому мы будем использовать массив. Нумерация элементов массива начинается с 0, а длинна массива устанавливается в момент его создания и фиксируется.

Для наглядности картинка, взятая мною с The Java Tutorial .

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

Объявление массива в Java

При создании массива в Java первым делом его нужно объявить. Это можно сделать следующим образом:

Int myFirstArray;

Можно также объявить массив так:

Int mySecondArray;

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

Исходя из данного примера, мы объявили 2 массива с именами myFirstArray и mySecondArray . Оба массива будут содержать элементы типа int .

Подобным образом можно объявить массив любого типа:

Byte anArrayOfBytes; short anArrayOfShorts; long anArrayOfLongs; float anArrayOfFloats; double anArrayOfDoubles; boolean anArrayOfBooleans; char anArrayOfChars; String anArrayOfStrings; ...

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

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

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

Резервация памяти для массива и его инициализация.

Int myFirstArray; myFirstArray = new int;

В нашем примере мы создали массив из 15 элементов типа int и присвоили его ранее объявленной переменной myFirstArray .

Объявлять имя массива и резервировать для него память также можно на одной строке.

Int myArray = new int;

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

MyFirstArray = 10; // инициализация первого элемента myFirstArray = 20; // инициализация второго элемента myFirstArray = 30; // и т.д.

так и в цикле, с помощью индекса проходя все элементы массива и присваивая им значения.

For(int i = 0; i < 15; i++){ myFirstArray[i] = 10; }

Как видно из предыдущих примеров, для того, чтобы обратиться к элементу массива, нужно указать его имя и, затем, в квадратных скобках — индекс элемента. Элемент массива с конкретным индексом ведёт себя также, как и переменная.

Рассмотрим создание и инициализацию массива на следующем примере. В нем мы создаем массив, содержащий цифры 0-9 и выводим значения на консоль.

//создание и инициализация массива int numberArray = new int; for(int i = 0; i < 10; i++){ numberArray[i] = i; } //вывод значений на консоль for(int i = 0; i < 10; i++){ System.out.println((i+1) + "-й элемент массива = " + numberArray[i]); }

Упрощенная форма записи

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

Int myColor = {255, 255, 0};

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

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

Размер массива не всегда очевиден, поэтому для того, чтобы его узнать следует использовать свойство length, которое возвращает длину массива.

MyColor.length;

Данный код поможет нам узнать, что длина массива myColor равна 3.

Пример: Задано 4 числа, необходимо найти минимальное

Int numbers = {-9, 6, 0, -59}; int min = numbers; for(int i = 0; i < numbers.length; i++){ if(min>numbers[i]) min = numbers[i]; } System.out.println(min);

Упражнения на тему одномерные массивы в Java:

1. Создайте массив, содержащий 10 первых нечетных чисел. Выведете элементы массива на консоль в одну строку, разделяя запятой.
2. Дан массив размерности N, найти наименьший элемент массива и вывести на консоль (если наименьших элементов несколько — вывести их все).
3. В массиве из задания 2. найти наибольший элемент.
4. Поменять наибольший и наименьший элементы массива местами. Пример: дан массив {4, -5, 0, 6, 8}. После замены будет выглядеть {4, 8, 0, 6, -5}.
5. Найти среднее арифметическое всех элементов массива.

Представьте себе ячейки в камере хранения. Каждая из них имеет свой номер, и в каждой из них хранится какой-то объект “Багаж”. Или винная карта, в которой все виды вина пронумерованы и когда вы делаете заказ, вам достаточно назвать номер напитка. Или список студентов группы, в котором в первой ячейке будет записан студент “Андреев”, а в последней - “Яковлев”. Или список пассажиров самолёта, за каждым из которых закреплено место с определённым номером. В Java чтобы работать с подобными структурами, то есть множеством однородных данных, часто используют массивы.

Что такое массив?

Объявление массива

Как объявить массив?

Создание массива

Как создать массив?

Длина массива в Java

Инициализация массива и доступ к его элементам

Как вывести массив в Java на экран?

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

Полезные методы для работы с массивами

Сортировка массива

Поиск в массиве нужного элемента

Преобразование массива к строке

Пример на sort, binarySearch и toString

Главное о массивах

Главные характеристики массива: тип помещённых в него данных, имя и длина.
Последнее решается при инициализации (выделении памяти под массив), первые два параметра определяются при объявлении массива.

Размер массива (количество ячеек) нужно определять в int

Изменить длину массива после его создания нельзя.

Доступ к элементу массива можно получить по его индексу.

В массивах, как и везде в Java, элементы нумеруются с нуля.

После процедуры создания массива он наполнен значениями по умолчанию.

Массив в языке Java значительно отличается от массива в языке C++. Однако он практически совпадает с указателем на динамический массив.

Полезные материалы о массивах

Кое-что о массивах - хорошая подробная статья о массивах

Класс Arrays и его использование - в статье описаны некоторые методы класса Array

Массивы первая лекция JavaRush, посвящённая массивам.

Возвращайте массив нулевой длины, а не null - автор “Эффекктивного программирования” Джошуа Блох рассказывает о том, как лучше возвращать пустые массивы

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

Перебор многомерных массивов в цикле

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

Массив - это структура данных, которая предназначена для хранения однотипных данных. Массивы в Java работают иначе, чем в C/C++. Особенности:

• Поскольку массивы являются объектами, мы можем найти их длину. Это отличается от C/C++, где мы находим длину с помощью sizeof.
• Переменная массива может также быть .
• Переменные упорядочены и имеют индекс, начинающийся с 0.
• Может также использоваться как статическое поле, локальная переменная или параметр метода.
• Размер массива должен быть задан значением int, а не long или short.
• Прямым суперклассом типа массива является Object.
• Каждый тип массива реализует интерфейсы Cloneable and java.io.Serializable.

Инициализация и доступ к массиву

Одномерные Массивы: общая форма объявления

Type var-name; или type var-name;

Объявление состоит из двух компонентов: типа и имени. type объявляет тип элемента массива. Тип элемента определяет тип данных каждого элемента.

Кроме типа int, мы также можем создать массив других типов данных, таких как char, float, double или определяемый пользователем тип данных (объекты класса).Таким образом, тип элемента определяет, какой тип данных будет храниться в массиве. Например:

// both are valid declarations int intArray; or int intArray; byte byteArray; short shortsArray; boolean booleanArray; long longArray; float floatArray; double doubleArray; char charArray; // an array of references to objects of // the class MyClass (a class created by // user) MyClass myClassArray; Object ao, // array of Object Collection ca; // array of Collection // of unknown type

Хотя приведенное выше первое объявление устанавливает тот факт, что intArray является переменной массива, массив фактически не существует. Он просто говорит компилятору, что эта переменная типа integer.

Чтобы связать массив int с фактическим физическим массивом целых чисел, необходимо обозначить его с помощью new и назначить int.

Как создать массив в Java

При объявлении массива создается только ссылка на массив. Чтобы фактически создать или предоставить память массиву, надо создать массив следующим образом: общая форма new применительно к одномерным и выглядит следующим образом:
var-name = new type ;

Здесь type указывает тип данных, size — количество элементов в массиве, а var-name-имя переменной массива.

Int intArray; //объявление intArray = new int; // выделение памяти

Int intArray = new int; // объединение

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

Литералы массива

В ситуации, когда размер массива и переменные уже известны, можно использовать литералы.

Int intArray = new int{ 1,2,3,4,5,6,7,8,9,10 }; // Declaring array literal

• Длина этого массива определяет длину созданного массива.
• Нет необходимости писать int в последних версиях Java

Доступ к элементам массива Java с помощью цикла for

Доступ к каждому элементу массива осуществляется через его индекс. Индекс начинается с 0 и заканчивается на (общий размер)-1. Все элементы могут быть доступны с помощью цикла for.

For (int i = 0; i < arr.length; i++) System.out.println("Element at index " + i + " : "+ arr[i]);

// Пример для иллюстрации создания array
// целых чисел, помещает некоторые значения в массив,
// и выводит каждое значение.

class GFG
{
{
int arr;

// allocating memory for 5 integers.
arr = new int;

arr = 10;

arr = 20;

//so on...
arr = 30;
arr = 40;
arr = 50;

// accessing the elements of the specified array
for (int i = 0; i < arr.length; i++)
System.out.println("Element at index " + i +
" : "+ arr[i]);
}
}
В итоге получаем:

Element at index 0: 10 Element at index 1: 20 Element at index 2: 30 Element at index 3: 40 Element at index 4: 50

Массивы объектов

Массив объектов создается так же, как элементов данных следующим образом:

Student arr = new Student;

StudentArray содержит семь элементов памяти каждый из класса student, в котором адреса семи объектов Student могут быть сохранены. Student объекты должны быть созданы с помощью конструктора класса student и их ссылки должны быть присвоены элементам массива следующим образом:

Student arr = new Student;

// Java program to illustrate creating an array of
// objects

class Student
{
public int roll_no;
public String name;
Student(int roll_no, String name)
{
this.roll_no = roll_no;
this.name = name;
}
}

// Elements of array are objects of a class Student.
public class GFG
{
public static void main (String args)
{
// declares an Array of integers.
Student arr;

// allocating memory for 5 objects of type Student.
arr = new Student;

// initialize the first elements of the array
arr = new Student(1,"aman");

// initialize the second elements of the array
arr = new Student(2,"vaibhav");

// so on...
arr = new Student(3,"shikar");
arr = new Student(4,"dharmesh");
arr = new Student(5,"mohit");

// accessing the elements of the specified array
for (int i = 0; i < arr.length; i++)
System.out.println("Element at " + i + " : " +
arr[i].roll_no +" "+ arr[i].name);
}
}

Получаем:

Element at 0: 1 aman Element at 1: 2 vaibhav Element at 2: 3 shikar Element at 3: 4 dharmesh Element at 4: 5 mohit

Что произойдет, если мы попытаемся получить доступ к элементу за пределами массива?
Компилятор создает исключение ArrayIndexOutOfBoundsException, указывающее, что к массиву был получен доступ с недопустимым индексом. Индекс либо отрицательный, либо больше или равен размеру массива.

Многомерные

Многомерные массивы — это массивы массивов, каждый элемент которых содержит ссылку на другой массив. Создается путем добавления одного набора квадратных скобок () для каждого измерения. Рассмотрим пример:

Int intArray = new int; //a 2D array or matrix int intArray = new int; //a 3D array

Class multiDimensional
{
public static void main(String args)
{
// declaring and initializing 2D array
int arr = { {2,7,9},{3,6,1},{7,4,2} };

// printing 2D array
for (int i=0; i< 3 ; i++)
{
for (int j=0; j < 3 ; j++)
System.out.print(arr[i][j] + " ");

System.out.println();
}
}
}

Output: 2 7 9 3 6 1 7 4 2

Передача массивов в метод

Как и переменные, мы можем передавать массивы в методы.

// Java program to demonstrate // passing of array to method class Test { // Driver method public static void main(String args) { int arr = {3, 1, 2, 5, 4}; // passing array to method m1 sum(arr); } public static void sum(int arr) { // getting sum of array values int sum = 0; for (int i = 0; i < arr.length; i++) sum+=arr[i]; System.out.println("sum of array values: " + sum); } }

На выходе получим:

sum of array values: 15

Возврат массивов из методов

Как обычно, метод также может возвращать массив. Например, ниже программа возвращает массив из метода m1.

// Java program to demonstrate // return of array from method class Test { // Driver method public static void main(String args) { int arr = m1(); for (int i = 0; i < arr.length; i++) System.out.print(arr[i]+" "); } public static int m1() { // returning array return new int{1,2,3}; } }

Объекты класса

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

// Java program to demonstrate // Class Objects for Arrays class Test { public static void main(String args) { int intArray = new int; byte byteArray = new byte; short shortsArray = new short; // array of Strings String strArray = new String; System.out.println(intArray.getClass()); System.out.println(intArray.getClass().getSuperclass()); System.out.println(byteArray.getClass()); System.out.println(shortsArray.getClass()); System.out.println(strArray.getClass()); } }

class +" "); } } }

Клон многомерного массива (например, Object ) является копией и это означает, что он создает только один новый массив с каждым элементом и ссылкой на исходный массив элементов, но вложенные массивы являются общими.

// Java program to demonstrate // cloning of multi-dimensional arrays class Test { public static void main(String args) { int intArray = {{1,2,3},{4,5}}; int cloneArray = intArray.clone(); // will print false System.out.println(intArray == cloneArray); // will print true as shallow copy is created // i.e. sub-arrays are shared System.out.println(intArray == cloneArray); System.out.println(intArray == cloneArray); } }

false
true
true

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

Массивы относятся к ссылочным типам данных , собственно как и все остальные типы, кроме примитивных. Напомню еще раз, что в Java все является объектом, исключение составляют лишь примитивные типы.

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

Процесс создания массива можно разделить на три этапа:

• Объявление (declaration )
• Создание (instantation )
• Инициализация (initialization )

Объявление (declaration) массива

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

numbers ; // numbers ссылка на массив int-ов
String str ; // str ссылка на массив строк
byte twoBytes ; // twoBytes ссылка на двумерный массив байтов
char letters , digits ; //letters и digits ссылки на массивы символов

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

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

arrayOfBytes ; // То же, что и byte arrayOfBytes
byte arrayOfArrayOfBytes ; // То же, что и byte arrayOfArrayOfBytes
byte arrayOfArrayOfBytes ; // То же, что и byte arrayOfArrayOfBytes

Однако зачастую такой синтаксис сбивает с толку, поэтому его следует избегать. В следующем примере, легко спутать что имелось в виду:

rates , maxRate ; // может хотели объявить два массива?

Такой синтаксис не рекомендуется использовать, так как уже говорилось, что он сбивает с толку, кроме того, в соглашения по оформлению Java кода, рекомендуется синтаксис, который был приведен первым, то есть квадратные скобки следуют сразу за типом объявляемого массива.

В данном случае объявлены массив значений типа float с именем rates и переменная типа float – maxRate.

То есть, если квадратные скобки стоят сразу после типа объявляемого массива, то все переменные которые объявлены в этой строке являются ссылками на массивы объявляемого типа, а если же скобки стоят справа от переменной, то только она является ссылкой на массив объявленного типа.

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

Пока объявленная переменная массива не определена, она может содержать (если вы присвоите) значение null . И только после определения она будет содержать ссылку на конкретный объект.

Указать длину массива при объявлении переменной массива невозможно, поскольку размер является строго функцией объекта массива, а не ссылки на него .

Создание (instantation) массива

На этом этапе указывается количество элементов массива, называемое его размером, выделяется место для массива в оперативной памяти, переменной-ссылке присваивается оператором = адрес массива. Все эти действия производятся оператором new за которым следует тип элементов массива. Например:

= new char [ 10 ] ;

Но стоит еще раз заметить, что до этого переменная letters, должна быть объявлена как массив. Чтобы было более понятно, это можно представить вот так:

letters ; // объявили letters как ссылку на массив символов char
letters = new char [ 10 ] ; // создали массив char-ов размеров в 10 элементов

При создании массива с таким синтаксисом все элементы массива автоматически инициализируются значениями по умолчанию . Это false для значений boolean, "\u0000" для значений char, 0 для целых значений, 0.0 для значений с плавающей точкой и null для объектов или массивов.

В Java размер массива фиксирован. Созданный массив нельзя увеличить или уменьшить. Желаемый размер создаваемого массива задается неотрицательным целым числом . Но в любое время переменной типа массива может быть сопоставлен новый массив другого размера. То есть может быть присвоена ссылка на другой массив того же типа что и объявленная переменная.

Индексы массивов всегда начинаются с 0 .

Первые две операции: объявление и создание массива можно объединить в один оператор. Например:

letters = new char [ 10 ] ;

Этот оператор эквивалентен двум приведенным выше.

После данной операции переменная letters будет уже содержать ссылку на массив и если попробовать вывести ее значение то мы получим значение, что то вроде ;
int b = a ;

Но надо иметь в виду, что переменные a и b указывают на один и тот же массив. По началу это может сбивать с толку, но если помнить что мы имеем дело с ссылочными типами данных, то все становится на свои места. Если этот момент не понятен, то чуть позже мы все это разберем на примерах.

= null ;

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

Размер или длину массива можно получить при помощи константы length , которая определена для каждого массива и возвращает его длину. Мы ей уже не раз пользовались в примерах когда работали с аргументами переданной в командной строке.

Можно создавать и использовать массивы нулевой длины (пустой массив). Например:

bits = new boolean [ 0 ] ;

Инициализировать такой массив нельзя, так как у него просто нет элементов которые можно инициализировать. Сразу же возникает вопрос, а на кой ляд они тогда вообще нужны эти пустые массивы? Но они нужны и даже очень полезны!

Пустой массив принято использовать в тех местах программы, где заранее неизвестно, будут элементы или нет. Если элементы будут, то возвращается непустой массив, если элементов нет - пустой массив. Примером может служить массив строк который передается в метод main() и содержит аргументы командной строки, а если их нет, то возвращается пустой массив.

Пустой массив лучше, чем null , потому что не требует отдельного if"а для обработки. То же верно для списков и других коллекций. Именно поэтому существуют методы Collections.emptyList, emptySet, emptyMap.

Инициализация (initialization) массива

На этом этапе элементы массива получают начальные значения. Инициализировать элементы массива значениями можно несколькими способами:

1. Присвоить каждому элементу массива конкретное значение (это можно сделать например в цикле, но до этого массив уже должен быть объявлен и создан)
2. Инициализировать массив при помощи перечисления значений его элементов в фигурных скобках (это можно сделать как на этапе объявления, так и на этапе создания, но синтаксис при этом разный)

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

Индексы можно задавать любыми целочисленными выражениями, кроме типа long , например a , a , a[++i] . Исполняющая система Java следит за тем, чтобы значения этих выражений не выходили за границы длины массива. Если же выход все же произойдет интерпретатор Java в таком случае прекратит выполнение программы и выведет на консоль сообщение о выходе индекса массива за границы его определения (ArrayIndexOutOfBoundsException ).

Рассмотрим пример первого способа инициализации:

ar = new int [ 2 ] ;
ar [ 0 ] = 1 ;
ar [ 1 ] = 2 ;

Второй способ инициализации можно реализовать по разному.

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

ar ; // объявление массива
ar = new int { 1 , 2 } ; // создание и инициализация

До создания и инициализации массива ar он уже был объявлен.

Так же инициализировать массив можно на этапе его объявления следующим синтаксисом:

ar = { 1 , 2 } ; // объявление, создание и инициализация массива

Внимание! Этот синтаксис инициализации массива работает только при объявлении массива и совмещает сразу все три операции объявление, создание и инициализацию. Если массив уже объявлен, то такой синтаксис использовать нельзя. Компилятор выдаст ошибку. То есть:

int ar ; // объявление массива
ar = { 1 , 2 } ; // ОШИБКА!!! создание и инициализация массива

Такое действо не прокатит.

Так же можно инициализировать на этапе объявления и чуть чуть по другому:

ar = new int { 1 , 2 } ; // объявление, создание и инициализация

Хотя этот синтаксис более длинный. Если вы заметили, то данный синтаксис это тоже совмещение всех трех операций: объявления, создания и инициализации.

В Java предусмотрен синтаксис, который поддерживает анонимные массивы (они не присваиваются переменным и, следовательно, у них нет имен). Иногда массив нужно задействовать лишь один раз (например, передать его методу), следовательно, вы не хотите тратить время на присваивание его переменной, поэтому можно сразу же использовать результат оператора new . Например:

. out . println ( new char { "H" , "e" , "l" , "l" , "o" }) ;

Синтаксис инициализации массивов с помощью фигурных скобок называется литеральным, поскольку для инициализации используется массив-литерал.

Важно понимать что массивы-литералы создаются и инициализируются во время выполнения программы, а не во время ее компиляции . Рассмотрим следующий массив-литерал:

perfectNumbers = { 6 , 28 } ;

Он компилируется в такой байт-код Java:

perfectNumbers = new int [ 2 ] ;
perfectNumbers [ 0 ] = 6 ;
perfectNumbers [ 1 ] = 28 ;

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

Однако тот факт, что Java инициализирует массив во время выполнения программы, имеет важные последствия. Это означает, что элементы массива-литерала являются произвольными выражениями, вычисляемыми во время выполнения программы, а не постоянными выражениями, вычисляемыми компилятором . Например:

points = { circle1.getCenterPoint () , circle2.getCenterPoint () } ;

Теперь немножко попрактикуемся.

В хорошо нам известном методе main(), как раз и используется возможность возврата массива нулевой длины если в командной строке нет аргументов, что позволяет избежать использования оператора if для проверки на null, дабы избежать ошибки во время исполнения программы.

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

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

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

Данная программа генерирует следующий вывод:

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

Во втором случае мы передали аргументы в командной строке и следовательно массив был обработан в циклах.