For (int a: num) { for (int i: a) { System.out.println(i); } }

Type variableName = new Type; Type variableName = {comma-delimited values}; Type variableName = new Type; Type variableName = {comma-delimited values};

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

Ниже показано объявление массива, но массив не инициализирован:

Int myIntArray = new int;

Ниже показано объявление, а также инициализация массива:

Int myIntArray = {1,2,3};

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

Int myIntArray = new int{1,2,3};

Но этот третий показывает свойство анонимного создания массива-объекта, которое указывается ссылочной переменной "myIntArray", поэтому, если мы пишем только "new int {1,2,3};" то это может быть анонимный массив-объект.

Если мы просто напишем:

Int myIntArray;

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

MyIntArray=new int;

Я считаю полезным, если вы понимаете каждую часть:

Type name = new Type;

Type - это тип переменной, называемой именем ("имя" называется идентификатором). Литеральный "Тип" - это базовый тип, а скобки означают, что это тип массива этой базы. Типы массивов в свою очередь являются собственными, что позволяет создавать многомерные массивы типа Type (тип массива Type ). Ключевое слово new говорит о распределении памяти для нового массива. Число между скобкой говорит о том, насколько большой будет новый массив и сколько памяти будет выделено. Например, если Java знает, что базовый тип Type занимает 32 байта, и вам нужен массив размером 5, ему необходимо внутренне выделить 32 * 5 = 160 байт.

Вы также можете создавать массивы с уже имеющимися значениями, такими как

Int name = {1, 2, 3, 4, 5};

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

Кроме того, если вы хотите что-то более динамичное, есть интерфейс List. Это не будет работать, но более гибко:

List listOfString = new ArrayList(); listOfString.add("foo"); listOfString.add("bar"); String value = listOfString.get(0); assertEquals(value, "foo");

Существует два основных способа создания массива:

Этот, для пустого массива:

Int array = new int[n]; // "n" being the number of spaces to allocate in the array

И этот, для инициализированного массива:

Int array = {1,2,3,4 ...};

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

Int array2d = new int[x][y]; // "x" and "y" specify the dimensions int array2d = { {1,2,3 ...}, {4,5,6 ...} ...};

Возьмите примитивный тип int , например. Существует несколько способов объявления и массив int:

Int i = new int; int i = new int {value1, value2, value3, etc}; int i = {value1, value2, value3, etc};

где во всех этих случаях вы можете использовать int i вместо int i .

С отражением вы можете использовать (Type) Array.newInstance(Type.class, capacity);

Обратите внимание, что в параметрах метода... отображается variable arguments . По сути, любое количество параметров в порядке. Это проще объяснить с помощью кода:

Public static void varargs(int fixed1, String fixed2, int... varargs) {...} ... varargs(0, "", 100); // fixed1 = 0, fixed2 = "", varargs = {100} varargs(0, "", 100, 200); // fixed1 = 0, fixed2 = "", varargs = {100, 200};

Внутри метода varargs рассматривается как нормальный int . Type... может использоваться только в параметрах метода, поэтому int... i = new int {} не будет компилироваться.

Обратите внимание, что при передаче int методу (или любому другому Type) вы не можете использовать третий способ. В заявлении int i = *{a, b, c, d, etc}* компилятор предполагает, что {...} означает int . Но это потому, что вы объявляете переменную. При передаче массива методу декларация должна быть либо new Type , либо new Type {...} .

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

Многомерные массивы гораздо сложнее справиться. По существу, 2D-массив представляет собой массив массивов. int означает массив int s. Ключ состоит в том, что если int объявлен как int[x][y] , максимальный индекс равен i . По существу, прямоугольник int равен:

Объявление массива ссылок на объекты:

Class Animal {} class Horse extends Animal { public static void main(String args) { /* * Array of Animal can hold Animal and Horse (all subtypes of Animal allowed) */ Animal a1 = new Animal; a1 = new Animal(); a1 = new Horse(); /* * Array of Animal can hold Animal and Horse and all subtype of Horse */ Animal a2 = new Horse; a2 = new Animal(); a2 = new Horse(); /* * Array of Horse can hold only Horse and its subtype (if any) and not allowed supertype of Horse nor other subtype of Animal. */ Horse h1 = new Horse; h1 = new Animal(); // Not allowed h1 = new Horse(); /* * This can not be declared. */ Horse h2 = new Animal; // Not allowed } }

Массив - это последовательный список элементов

Int item = value; int one_dimensional_array = { value, value, value, .., value }; int two_dimensional_array = { { value, value, value, .. value }, { value, value, value, .. value }, .. .. .. .. { value, value, value, .. value } };

Если это объект, то это же понятие

Object item = new Object(); Object one_dimensional_array = { new Object(), new Object(), .. new Object() }; Object two_dimensional_array = { { new Object(), new Object(), .. new Object() }, { new Object(), new Object(), .. new Object() }, .. .. .. { new Object(), new Object(), .. new Object() } };

В случае объектов вам нужно либо назначить его null для инициализации с помощью new Type(..) , классы, такие как String и Integer , являются особыми случаями, которые будут обрабатываться как следующие

String a = { "hello", "world" }; // is equivalent to String a = { new String({"h","e","l","l","o"}), new String({"w","o","r","l","d"}) }; Integer b = { 1234, 5678 }; // is equivalent to Integer b = { new Integer(1234), new Integer(5678) };

В общем случае вы можете создавать массивы, которые M мерные

Int .. array = // ^ M times brackets {{..{ // ^ M times { bracket // this is array.. // ^ M times }}..} // ^ M times } bracket ;

Стоит отметить, что создание размерного массива M является дорогостоящим с точки зрения Space. Поскольку при создании массива M с N во всех измерениях общий размер массива больше, чем N^M , так как каждый массив имеет ссылку, а в M-размерности есть (M -1) -мерный массив ссылок. Общий размер выглядит следующим образом

Массивы (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}