18 мая 2015 г.

Массивы. Часть 3 – многомерные массивы.

В Java многомерные массивы представляют собой массивы массивов.

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

int twoD[][] = new int[4][5];

Этот оператор распределяет память для массива размерностью 4×5 и присваивает ссылку на  него переменной twoD. Внутренне эта матрица реализована как массив массивов значений типа int. С точки зрения логической организации этот массив будет выглядеть так:

A00011

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

Допустим, вы хотите представить таблицу умножения в виде многомерного массива:

int[][] multiplicationTable;

Каждая пара квадратных скобок представляет одно измерение, поэтому данный массив является двухмерным. Чтобы получить доступ к одиночному элементу int двухмерного массива, нужно указать два значения индекса, по одному для каждого измерения. Если допустить, что данный массив был задан как таблица умножения, то значение int, находящееся в любом элементе, есть произведение этих индексов. Таким образом, значение products[2][4]  равно 8, а значением products[3][7]  будет 21.

Новый многомерный массив создается при помощи ключевого слова new с указанием размеров обоих измерений массива. Например:

int[][] multiplicationTable = new int[10][10];

В некоторых языках такой массив создается в виде единого блока из 100 значений int. Java поступает иначе. Эта строка кода выполняет три действия:

  • Объявляет переменную с именем multiplicationTable, которая содержит ссылку на массив ссылок, которые в свою очередь будут указывать на массивы int.
  • Создает массив из 10 элементов (первый индекс), который будет содержать ссылки на 10 одномерных массивов int. Вот от сюда собственно и понятие – массив массивов.
    На этой стадии создания массив ссылок заполняется значениями по умолчанию, то есть значениями null.
  • Создает еще 10 массивов, каждый из которых в свою очередь является массивом из 10 элементов int. Присваивает ссылки на каждый из этих 10 новых массивов элементам массива, созданного на втором шаге. По умолчанию каждый элемент int каждого из этих 10 новых массивов получает значение 0.

Другими словами, представленную выше строку кода, можно записать так:

int[][] multiplicationTable = new int[10][]; // первый индекс содержит ссылки на массивы int
  
for (int i = 0; i < 10; i++)
      
multiplicationTable[i] = new int[10]; // создаем 10 массивов int

Графически это можно изобразить так:

A00012

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

int[][] a = new int[10][1000];
int[][] b = new int[1000][10];

В случае массива a, количество порождаемых в памяти объектов равно 11, а в случае массива b – 1001. Создание и обслуживание каждого объекта в памяти виртуальной машины имеет свои накладные расходы, так как виртуальная машина считает ссылки для каждого объекта, хранит его атрибуты и т.д. и т.п. Таким образом массив b может занимать в памяти в полтора, а то и в два раза больше места чем массив a.

Чтобы все еще стало понятней, лучше немного попрактиковаться Smile

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

A00013

По существу шаги 1 и 2 выполняются в 9 строке программы.

Строки 12-15 лишь выводят значения элементов первого индекса массива, где содержаться указатели на массивы значений int. Но на данный момент там еще значения null, так как им еще не были присвоены ссылки на массивы со значениями int.

После создания массивов int (строки 18-21), на третьем шаге мы видим что теперь в первом индексе, то есть в массиве содержащем ссылки на массивы int уже находятся ссылки на эти массивы.

И теперь если обратиться по обоим индексам массива multiplicationTable, то мы увидим что массивы int были заполнены значениями по умолчанию для данного типа, то есть нулями.

Ключевое слово new автоматически выполняет инициализацию элементов массива значениями по умолчанию.

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

При работе с многомерными массивами в Java очень важно понять, что первые индексы многомерных массивов содержат только массивы ссылок, и только последний (самый правый) индекс содержит непосредственно элемент данных типа объявленного для массива.

То есть в Java можно объявить и более чем двумерные массивы. Например:

int[][][] dim3D;

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

То есть если в данном случае мы попробуем вывести на консоль значение int[1][1], то мы получим адрес ссылки, то есть примерно то же, что и на шаге 3 в предыдущем примере. И только по полному индексу int[1][1][1] мы сможем получить значение элемента массива типа int.

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

int[][] multiplicationTable = new int[10][];
multiplicationTable[0] = 10; // ошибка компиляции

Не смотря на то что 10 является значением int, данный код не будет скомпилирован и будет выдана ошибка: cannot convert from int to int[]. Это произошло потому, что ожидается, что данный элемент массива будет хранить ссылку на объект, а не сам объект. Строка 12 в следующем примере, как раз и демонстрирует этот момент, как сделать чтобы не было ошибки.

В тоже время нижеприведенный код не вызовет ошибки компиляции, но вызовет ошибку во время исполнения: NullPointerException.

int[][] multiplicationTable = new int[10][];
multiplicationTable[0][0] = 10; // ошибка во время исполнения

Это происходит потому, что не был создан объект, в данном случае массив int-ов. То есть мы создали массив хранящий ссылки, на массивы int-ов, но сами эти массивы мы еще не создали, поэтому обращение к несуществующему объекту вызывает данную ошибку. Строка 19 из предыдущего примера, как раз показывает пример правильного создания объектов (массивов), на которые ссылается первый индекс. Ключевое слово new, так же служит и для создания и инициализации вложенных массивов.

В последнем примере, мы создали массив ссылок, но не создали массив int-ов, поэтому к нему и не возможно обратиться. Это можно исправить следующим кодом:

int[][] multiplicationTable = new int[10][];
multiplicationTable[0] = new int [10];
multiplicationTable[0][0] = 10; // нет ошибки

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

Как уже упоминалось в Java можно создавать массивы любой размерности:

float[][][] globalTemperatureData = new float[360][180][100];

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

float[][][] globalTemperatureData = new float[360][][];
float[][][] globalTemperatureData = new float[360][180][];

Но такие варианты ошибочны:

float[][][] globalTemperatureData = new float[360][][100]; // Ошибка!
float[][][] globalTemperatureData = new float[][180][100]; // Ошибка!

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

Подобно одномерным массивам, многомерные массивы можно инициализировать при помощи массива-литерала. Нужно просто вложить массивы в другие массивы, применяя множество вложенных фигурных скобок. Пример ниже создает массив products[5][5]:

int[][] products = { { 0, 0, 0, 0, 0 },
                            
{ 0, 1, 2, 3, 4 },
                            
{ 0, 2, 4, 6, 8 },
                            
{ 0, 3, 6, 9, 12 },
                            
{ 0, 4, 8, 12, 16 } };

Напомню, что такой синтаксис инициализации, можно использовать только при объявлении массива или при использовании анонимного массива, то есть массива без имени:

boolean response = bilingualQuestion( question, new String[][] {{ "Yes", "No" },{ "Oui", "Non" } } );

Поскольку в Java многомерные массивы реализуются как массивы массивов,  вы можете использовать не только прямоугольные массвы. Например:

int[][] triangle = {{1, 2, 3, 4, 5},
                         
{6, 7, 8, 9},
                         
{10, 11, 12},
                         
{13, 14},
                         
{15}};

Приведу еще одни пример небольшой магии с массивами в Java, чтобы углубить понимание данной темы.

A00014

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

A00015

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

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

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

А пока добавлю еще немножко магии к предыдущей программе Smile

A00016

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

Кроме этого были добавлены строки создания массива int-ов, для второго индекса массива twoD, то есть для индекса 1, а так же заполнения его значениями. Это строки 23-25.

Далее, строка 26, просто вывод массива twoD на консоль.

В 27 строке небольшая магия, мы присвоили ссылку на массив int-ов, которые только что создали в массиве twoD, массиву oneD.

Затем вывели содержимое массива oneD на консоль. И уже после этого адреса ссылок на массивы.

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

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

A00017

А теперь поколдуем немножко с не прямоугольными массивами, дабы понять тему многомерных массивов в Java еще глубже.

A00018

Это пример работы с треугольным или ступенчатым массивом. На самом деле массивы int-ов могут быть произвольной длинны.

В 16 строке мы воспользовались стандартной библиотечным методом (Arrays.deepToString) SDK для вывода многомерных массивов на консоль, но как видно из вывода, данный метод выводит любой многомерный массив в строку, разделяя его размерности квадратными скобкам, что не очень наглядно.

Затем в цикле (строки 18-23) мы выводим треугольный массив более наглядным образом.

A00019

 

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

A00020В данной программе мы изначально имеем три массива: один одномерный и два двумерных, но с разным количеством элементов в строках – 2 и 3 соответственно.

Как видно на примере вывода данной программы справа, сперва мы выводим все три массива в их изначальном состоянии.

В строках 31 и 32 мы колдуем с массивом three и затем выводим результат нашего шаманства на консоль.

В результате, как-бы, получаем честный треугольный массив.

Как-бы, это потому, что на самом деле последние два индекса ссылаются массивы two и one.

А честный он потому, что нам придется с ним работать уже как с треугольным, так как, например, после магии мы уже не сможем обратиться к индексу three[2][2], поскольку получим ошибку во время исполнения программы ArrayIndexOutOfBoundsException. А как-бы он потому, что работая с индексами three[1] и three[2] мы на самом деле будем работать с массивами two и one соответственно.

Теперь рассмотрим простенький пример трехмерного массива. Следующая программа создает трехмерный массив размерности 3×4×5. Затем она инициализирует каждый элемент произведением его индексов и выводит все это дело на консоль.

A00021

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

A00022

Вот такое у нас 3D Smile

 

Ну и в завершение данного поста приведу программу сортировки двумерного массива пузырьком.

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

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

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

A00009

A00010

Тут приведены примеры запусков без аргументов и с аргументами из командной строки.

Как видите разница между количеством итераций и перестановок в алгоритмах различается от двух и более раз.

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

Объяснять отличие работы второго алгоритма немного ленно. Постарайтесь разобраться сами.

Если не получится и если сильно интересно, пишите вопросы в комментариях, дабы мне не тратить понапрасну время на объяснения тут.

В следующем посте разберем некоторые методы работы с массивами из стандартной библиотеки.

4 комментария:

  1. Столкнулся с проблемой: в jdk1.8.0 класс Array (rt.jar>java.util.Array.class) пустой (в Eclipse). Скачал библиотеку rt.jar 1.5.0 все норм. Что это может быть?

    ОтветитьУдалить
    Ответы
    1. Вообще не понял про что вы говорите. что за rt.jar ?

      Удалить
  2. В стандартной библиотеке нет такого класса java.util.Array есть класс java.util.Arrays

    ОтветитьУдалить
  3. float[][][] globalTemperatureData = new float[][180][100]; // Ошибка!
    "Еще раз напомню, что очень важно понять, что первые индексы (измерения) массивов содержат только ссылки, и не могут содержать объекты объявленного для массива типа, их содержит только крайнее левое измерение (индекс)." - нет ли тут опечатки - их содержит только крайнее ПРАВОЕ измерение ?

    ОтветитьУдалить