Создать новый массив в java. Java Array. Массивы в Java. Java для начинающих

Массивы (arrays) _ это упорядоченные наборы элементов одного типа. Элементами массива могут служить объекты простых и ссылочных типов, в том Числе и ссылки на другие массивы. Массивы сами по себе являются объектами и

наследуют класс Object. Объявление

int ia = new int;

Определяет массив с именем ia, который изначально указывает на набор из трех Элементов типа int.

В объявлении массива его размерность не указывается. Количество элементов массива задается при его создании посредством оператора new. Длина массива фиксируется в момент создания и в дальнейшем изменению не поддается. Впрочем, переменной типа массива (в нашем примере – ia) в любой момент может быть поставлен в соответствие новый массив с другой размерностью.

Доступ к элементам массива осуществляется по значениям их номеров-индексов.

Первый элемент массива имеет индекс, равный нулю (0), а последний – length – 1. Обращение к элементу массива выполняется посредством задания имени массива и значения индекса, заключенного в квадратные скобки, [ и ]. в предыдущем примере первым элементом массива ia будет ia, а последним – ia. При каждом обращении к элементу массива по индексу исполняющая система Java проверяет, находится ли значение индекса в допустимых пределах, и генерирует исключение типа ArraylndexOutOfBoundsException, если результат проверки ложен. 6 Выражение индекса должно относиться к типу int – только этим и ограничивается максимальное количество элементов массива.

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

for (int i = о; i < ia.length; i++)

system.out.println(i + ": " + ia[i]);

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

Допускается и иная форма объявления массива, в которой квадратные скобки задаются после идентификатора массива, а не после наименования его типа:

int ia = new int;

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

Модификаторы в объявлениях массивов

Правила употребления в объявлениях массивов тех или иных модификаторов обычны и зависят только от того, к какой категории относится массив – к полям или Локальным переменным. Существует единственная особенность, которую важно помнить, – модификаторы применяются к массиву как таковому, но не к его отдельным элементам. Если в объявлении массива указан признак final, это значит только то, что ссылка на массив не может быть изменена после его создания, но никак не запрещает возможность изменения содержимого отдельных элементов массива. Язык не позволяет задавать каких бы то ни было модификаторов (скажем, final или уоlatilе) для элементов массива.

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

В Java поддерживается возможность объявления многомерных массивов (multidimensional arrays) (т.е. массивов, элементами которых служат другие массивы), Код, предусматривающий объявление двумерной матрицы и вывод на экран содержимого ее элементов, может выглядеть, например, так:

float mat = new float;

setupMatrix(mat);

for (int у = о; у < mat.length; у++) {

for (int х = о; х < mat[y].length; х++)

system.out.print(mat[y][x] + " ");

system.out.println();

При создании массива должна быть указана, по меньшей мере, его первая, "самая левая", размерность. Другие размерности разрешается не задавать – в этом случае их придется определить позже. Указание в операторе new единовременно всех размерностей – это самый лаконичный способ создания массива, позволяющий избежать необходимости использования дополнительных операторов new. Выражение объявления и создания массива mat, приведенное выше, равнозначно следующему фрагменту кода:

float mat = new float;

for (int у = о; у < mat.length; у++)

mat[y] = new float;

Такая форма объявления обладает тем преимуществом, что позволяет наряду с получением массивов с одинаковыми размерностями (скажем, 4 х 4) строить и массивы массивов различных размерностей, необходимых для хранения тех или иных последовательностей данных.

Инициализация массивов

При создании массива каждый его элемент получает значение, предусмотренное по умолчанию и зависящее от типа массива: нуль (0) – для числовых типов, ‘\u0000′ _ для char, false – для boolean и null – для ссылочных типов. Объявляя массив ссылочного типа, мы на самом деле определяем массив переменных этого типа. Рассмотрим следующий фрагмент кода:

Attr attrs = new Attr;

for (int i = о; i < attrs.length; i++)

attrs[i] = new Attr(names[i], values[i]);

После выполнения первого выражения, содержащего оператор new, переменная attrs получит ссылку на массив из 12 переменных, которые инициализированы значением null, Объекты Attr как таковые будут созданы только в процессе про хождения цикла.

Массив может инициализироваться (одновременно с объявлением) посредством конструкции в фигурных скобках, в которой перечислены исходные Значения его элементов:

String dangers = { "Львы", "Тигры", "Медведи" };

Следующий фрагмент кода даст тот же результат:

String dangers = new String; dangers = "Львы";

dangers = "Тигры";

dangers = "Медведи";

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

String dangers = new String { "Львы", "Тигры", "Медведи" };

Подобную форму объявления и инициализации массива разрешается применять в любом месте кода, например в выражении вызова метода:

printStringsCnew String { "раз", "два", "три" });

Массив без названия, который создается таким образом, называют анонимным (anonymous).

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

int pascalsTriangle = {

{ 1, 4, 6, 4, 1 },

Индексы многомерных массивов следуют в порядке от внешнего к внутренним. Так, например, pascalsTriangle<0) a[i] = max; mySecond[i] = a[i]; System.out.println("a[" + i + "]=" + a[i]); } myArray = a; // установка ссылки на массив a } }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Массив (англ. 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:

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

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

Массивы относятся к ссылочным типам данных , собственно как и все остальные типы, кроме примитивных. Напомню еще раз, что в 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) массива

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

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

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

Индексы можно задавать любыми целочисленными выражениями, кроме типа 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, дабы избежать ошибки во время исполнения программы.

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

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

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

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

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

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