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

Для примера рассмотрим двумерный массив в Java.

Двумерные массивы Java - это прямоугольная или не прямоугольная таблица чисел.

Двумерный массив Java состоит из рядов и столбцов.

Первый индекс двумерного массива Java - это число рядов.

Пример двумерного прямоугольного массива Java:

Int multyArr; multyArr = new int; /* * multyArr structure * | (0,0) | (0,1) | * | (1,0) | (1,1) | */

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

Загрузим массив элементами:

MultyArr = 1; multyArr = 2; multyArr = 3; multyArr = 4;

Вывод двумерного массива (перебираем массив):

System.out.println("multyArr"); for(int inn = 0; inn < 2; inn++) { for(int jnn = 0; jnn < 2; jnn++) { System.out.println("multyArr[" + inn + "][" + jnn + "] = " + multyArr ); } }

Получаем:

for(int inn = 0; inn < 2; inn++)

мы проходим по рядам, а в цикле

for(int jnn = 0; jnn < 2; jnn++)

по столбцам.

Можно объявить и определить многомерный массив одновременно:

int multyArr = {{1,2}, {3,4}};

Длина многомерного массива в Java

Int multyArr = {{1,2}, {3,4}, {5,6}}; /* * multyArr structure * | 1 | 2 | * | 3 | 4 | * | 5 | 6 | */ System.out.println("Array length = " + multyArr.length);

Array length = 3

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

Трехмерный массив в Java

Пример трехмерного массива в Java:

int triArray;
triArray = new int;

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

Как заполнить трехмерный массив? Можно в цикле, но мы для примера вручную заполним:

//**************** //THE FIRST LAYER //**************** //the first row of the first layer triArray = 1; triArray = 2; //the second row of the first layer triArray = 3; triArray = 4; //**************** //THE SECOND LAYER //**************** //the first row of the second layer triArray = 5; triArray = 6; //the second row of the second layer triArray = 7; triArray = 8;

Как вывести трехмерный массив? Или как перебрать трехмерный массив? Так.

Массив — это множество однотипных объектов, которые имеют общее название. К каждому элементу массива возможен доступ по его индексу. Рассмотрим реальный пример. Пусть у нас есть некоторый склад, который называется a и пусть в нем есть некоторое количество ящиков, каждый из которых последовательно пронумерован. В каждом ящике лежит некоторый объект, который по своему типу совпадает с объектами в других ящиках. Пример данного склада является классическим массивом, где название склада — это название массива, ящики — это элементы массива, номера ящиков — это индексы элементов, а содержимое ящиков — это значения наших переменных. Представим, что внутри ящиков лежат лимоны, и в каждом ящике лежит определенное количество лимонов. Тогда, значения наших переменных будут показывать количество лимонов. Рассмотрим такой склад, состоящий из трех ящиков, пусть в первом ящике лежит 3, во втором 7, в третьем 273. Тогда, массив, описывающий данный склад можно изобразить следующим образом:

Индекс	0	1	2
Значение	3	7	273

Индексация в массиве всегда начинается с 0. Рассмотрим некоторые операции, которые можно производить с массивом:

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

Тип имяПеременной;
int a;//целочисленный массив
char b;//массив символов
String c;

Выделение памяти:

A = new int;//выделяем память под 10 элементов
b = new char;//выделяем память под 20 элементов
c = new String;//выделяем память под 30 элементов

Таким образом инициализация массива выглядит следующим образом:

Int a = new int;//инициализация массива целых чисел из 10 элементов
char b = new char;//инициализация массива символов из 20 элементов
String c = new String;//инициализация массива строк из 30 элементов

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

Int a = new int{ 3, 7, 273 };

Работа с массивом

Считывание массива:

Import java.util.Scanner;
public class test {
public static void main(String args) {
int a;//массив целых чисел
int n;//количество элементов в массиве
Scanner in = new Scanner(System.in);
n = in.nextInt();
a = new int[n];
for(int i = 0; i Изменение значений массива:

for(int i = 0; i Вывод массива:

Int a;//массив целых чисел, который был как - то обработан
for(int i = 0; i Произвольный доступ к элементу массива по индексу:

System.out.println(a);//Выводим первый элемент массива
a = 1;//Присваиваем второму элементу массива 1
int temp = a;//Сохраняем значение третьего элемента массива в переменную temp

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

Двумерные массивы

Не всегда бывает удобно нумеровать ящики на складе с 0 до определенного числа, иногда хочется привести склад в более упорядоченный вид, например ввести ряды. Теперь каждый ящик имеет свой номер ряда и свой порядковый номер в этом ряду. Пусть на нашем складе есть девять ящиков, которые имеют содержат 1, 2 и так далее 9 апельсинов. Ящики на складе располагаются в три ряда по три ящика, тогда ситуацию на складе можно представить так.

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

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

int nums = new int { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; for (int i = 0; i < nums.length; i++){ for(int j=0; j < nums[i].length; j++){ System.out.printf("%d ", nums[i][j]); } System.out.println(); }

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

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

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

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

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

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

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

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

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

19 ответов

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

Для примитивных типов:

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

Для классов, например String , это то же самое:

String myStringArray = new String; String myStringArray = {"a","b","c"}; String myStringArray = new String{"a","b","c"};

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

String myStringArray; myStringArray = new String{"a","b","c"};

Существует два типа массива.

Один размерный массив

Синтаксис значений по умолчанию:

Int num = new int;

Или (менее предпочтительный)

Int num = new int;

Синтаксис с указанными значениями (инициализация переменной/поля):

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

Или (менее предпочтительный)

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

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

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

Декларация

int num = new int;

Int num = new int;

Int num = new int;

Инициализация

num=1; num=2; num=1; num=2; num=1; num=2; num=1; num=2; num=1; num=2;

Int num={ {1,2}, {1,2}, {1,2}, {1,2}, {1,2} };

Ragged Array (или непрямоугольный массив)

int num = new int; num = new int; num = new int; num = new int; num = new int;

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

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

Для доступа:

for (int i=0; i<(num.length); i++) { for (int j=0;jВ качестве альтернативы:

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) -мерный массив ссылок. Общий размер выглядит следующим образом