Продвинутая работа с массивами

1. Массив типа String

Ну и вкратце хотелось бы рассказать о массиве типа String.

Как мы уже говорили, массив может быть любого типа. А значит, можно создать массив типа String. Вот как бы выглядел код, если бы нам нужно было написать программу, которая «вводит с клавиатуры 10 строк и выводит их на экран в обратном порядке».

Scanner console = new Scanner(System.in);
String[] array = new String[10];
for (int i = 0; i < 10; i++)
{
   array[i] = console.nextLine();
}
for (int i = 9; i >= 0; i--)
{
   System.out.println(array[i]);
}

Код практически не изменился! Пришлось только при создании массива заменить тип int на String. Ну и при чтении строки с клавиатуры заменить метод nextInt() на nextLine().

2. Массив типа String в памяти

И еще один полезный факт. Рассмотрим 3 картинки:

Картинка 1. Как объект String располагается в памяти:

Эта картинка взята из предыдущих лекций.

Обращаем ваше внимание, что текст строки не хранится прямо в переменной: для него выделяется отдельный блок памяти. А в переменной типа String хранится адрес(ссылка) на объект с текстом.

Картинка 2. Как массив целых чисел располагается в памяти:

Тоже известна картинка.

Картинка 3. Как в памяти располагается массив строк:

Слева мы видим переменную-массив типа String[] (хранит адрес объекта-массива).

В середине — объект-массив типа String.

А справа — объекты-строки, которые хранят какие-то тексты.

В ячейках объекта-массива типа String хранятся не сами строки(тексты), а их адреса (ссылки). Точно так же, как в переменных типа String хранятся адреса строк(текста).

Учитывайте этот факт, когда будете сравнивать ячейки массива:

String[] array = new String[10];
 array[1] = "Привет";
array[2] = array[1];
array[3] = new String("Привет");
// сравниваем
array[1] == array[2];
array[1] == array[3];
array[1].equals(array[3]);
array[1].equalsIgnoreCase(array[3]);

3. Быстрая инициализация массива в Java

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

И первое, что они сделали — это упростили инициализацию массива, занесение в него стартовых значений.

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

int[] months = new int[12];
months[0] = 31; // январь
months[1] = 28; // февраль
months[2] = 31; // март
months[3] = 30; // апрель
months[4] = 31; // май
months[5] = 30; // июнь
months[6] = 31; // июль
months[7] = 31; // август
months[8] = 30; // сентябрь
months[9] = 31; // октябрь
months[10] = 30; // ноябрь
months[11] = 31; // декабрь

Но есть способ записать его короче — спасибо создателям Java:

// длины месяцев года
int[] months = new int[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

Можно просто перечислить через запятую все значения массива!

Удобно, да? Но и это еще не все.

Оказывается компилятор может определить тип контейнера (объекта-массива) на основе типа переменной-массива. А для определения длины массива — банально подсчитать количество элементов, написанных в фигурных скобках.

Поэтому этот код можно записать еще короче:

// длины месяцев года
int[] months = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

Разве не красота? 🙂

Такая запись называется «быстрая инициализация массива». Она, кстати, работает не только для типа int...

// имена месяцев года
String[] months = { "Январь", "Февраль", "Март", "Апрель", "Май", "Июнь", "Июль", "Август", "Сентябрь", "Октябрь", "Ноябрь", "Декабрь"};