Урок 10. Массивы Java

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

Массивы

Массив - это особый тип объекта в Java. Представьте себе его как контейнер, который может содержать ряд примитивных типов данных или объектов. Он хранит каждый из них в своем собственном "отсеке" и позволяет получить к ним доступ, предоставляя расположение "отсека", называемого индексом.

Допустим, мы хотели создать массив объектов Person. Вы бы сделали это вот так:

Person[] persons = new Person[4];

Первая часть Person[] persons определяет ссылочную переменную Person - массив с именем persons. Вторая часть, = new Person[4] создает объект Person - массив и присваивает его нашей ссылочной переменной persons. [4] указывает, что массив сможет ссылаться на максимальное число объектов из четырех человек. Вы не можете изменить размер массива после его создания. Поэтому, как только вы инициализировали массив, вот и все, он застрял на этом размере.

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

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



А теперь давайте заполним наш массив. Когда мы делаем это, мы заполняем его ссылочными переменными на объекты Person.

persons[0] = new Person();
persons[1] = new Person();
persons[2] = new Person();
persons[3] = new Person();

Синтаксически можно также поставить квадратные скобки переменной массива persons после объявления переменной, как показано ниже:

Person persons[] = new Person[4];

Код выше является недостатком языка программирования Java, и настоятельно рекомендуется никогда этого не делать. Чтение кода менее понятно – так как если Вы читаете только часть строки, вы можете прийти к неправильному выводу, что он создает ссылочную переменную типа Person. Поставьте квадратные скобки непосредственно после класса Person, чтобы четко указать, что это ссылочная переменная типа person array, а не Person.

Мы также можем создать массив для хранения примитивного типа данных, например int:

int[] numbers = new int[3];

Вы, вероятно, не привыкли видеть new перед примитивным типом int. Однако это синтаксически правильно; он создает объект array, который может содержать три значения типа int, а не примитивный тип. Однако если в массиве объектов хранятся пространства для ссылок, то в массиве примитивов хранятся сами значения примитивов. Таким образом, после инициализации ячейки массива будут предварительно заполнены 0, значением по умолчанию для int, а не null:



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

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

Вы также можете создать многомерный массив. Многомерный массив - это массив массивов:

int[][] numbers = new int[2][3];

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



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

Person [][][] persons = new Person[2][4][3];

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

Сокращенная запись для массивов

Кроме того, существует альтернативный способ создания массивов. Самая основная его форма-это:

Person[] persons2 = {};

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

Мы также можем использовать этот метод для фактического заполнения массива без установки размера. Когда вы создаете массив, вы помещаете столько объектов и / или нулевых значений, сколько хотите, и это решает, насколько большим будет массив.

Person[] persons = new Person[3];

Индексирование в массиве

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

persons[0] = new Person();

Массивы начинают индексироваться с 0, поэтому наш массив из четырех отсеков имеет индексы 0, 1, 2 и 3. Мы могли бы создать четыре ссылки и назначить их каждому новому объекту. Кроме того, мы можем назначить наши новые ссылочные переменные существующим объектам или даже объектам, на которые ссылаются другие ячейки массива. Очевидно, что в таком простом примере, возможно, нет необходимости вводить эти сложности, но я делаю это, чтобы продемонстрировать концепции.

@Test
public void demonstrateArrays() {
     Person[] persons = new Person[4];
     persons[0] = new Person();
     persons[1] = new Person();
     persons[2] = persons[1];
     Person myPerson = new Person();
     persons[3] = myPerson;
}

Циклы и массивы

Циклы и массивы всегда идут рядом. Чтобы массив был эффективным, ему нужен цикл, а циклы хорошо оснащены для работы с массивами. Допустим, мы хотели бы индексировать каждый отдельный "отсек" в нашем массиве и применить один и тот же код к каждому из них. Мы можем создать цикл for-loop, чтобы сделать это. Наша переменная i, будет использоваться в качестве значения для нашего индекса. Теперь, внутри этого цикла, мы могли бы создать объекты типа person и получить к ним доступ.

@Test
public void demonstrateArrays() {
     Person[] persons = new Person[4];
     for(int i = 0; i < 4; i++){
          persons[i] = new Person();
          person[i].helloWorld();
     }
}

Внутри этого цикла мы могли бы использовать каждого человека в массиве и заставить их вызвать метод helloWorld (). Циклы - это чрезвычайно удобный способ многократно выполнять операцию на каждой ячейке массива, не дублируя код.

for(int i = 0; i < persons.length; i++){
     persons[i] = new Person();
}

Person myPerson = new Person();

Person myPerson2 = null;
Person[] persons2 = {persons[0], null, myPerson, myPerson2};

Сокращённая запись многомерных массивов

Вы также можете использовать эту сокращенную нотацию для многомерных массивов. Для этого вы окружаете каждый "внутренний массив" фигурными скобками и отделяете каждый набор значений запятыми:

int[][] numbers = {
     {0,42,3, },
     {6,6,-33, },
};

Person[][] persons = {
     {person1, person2, },
     {person3, person4, },
};

А вот как это будет выглядеть в памяти:



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

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

@Test
public void demonstrateTwoDimensonalArrays() {

     Person[] persons = new Person[4][4];
     for(int i = 0; i < 4; i++) {
          for(int j = 0; j < 4; i++) {
               persons[i][j] = new Person();
               person[i][j].helloWorld();
          }
     }
}

Использование цикла For-Each

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

for(Person person: persons) {
     // обходим все объекты массива
}

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