1. Массив — это контейнер элементов
Скорее всего, вы слышали, что компьютеры могут обрабатывать громадные объемы информации. Условный оператор (if-else) и циклы (for, while), конечно, в этом помогают. Но далеко на них не уедешь, ведь обрабатываемые данные нужно как-то хранить.
На этот случай в Java, как и практически во всех языках программирования, есть такая отличная вещь, как массивы (Array). Их еще называют таблицами.
Массив — это специальный объект, в котором можно хранить не одно значение, а несколько.
Если раньше мы сравнивали переменную с коробкой (где можно хранить какое-нибудь значение), то массив — это скорее коробка, внутри разделенная на секции. У каждой секции в «коробке-массиве» есть ее номер. Нумерация, конечно же, с нуля...
Ну или можно провести еще одну аналогию. Давайте сравним обычный жилой дом и многоэтажку. Обычный дом занимает одна семья, а многоэтажка разделена на квартиры. Чтобы написать письмо семье, которая живет в обычном доме, надо указать его уникальный адрес. А чтобы написать письмо семье, которая живет в квартире, надо указать уникальный адрес дома и еще номер квартиры.
Так вот, переменная-массив — это переменная-многоэтажка. В ней можно хранить не одно значение, а несколько. В такой переменной есть несколько квартир (ячеек), к каждой из которых можно обратиться по ее номеру (индексу).
Для этого после имени переменной в квадратных скобках надо указать индекс ячейки, к которой обращаемся. Это довольно просто:
array[индекс] = значение;Где аrray — это имя переменной-массива, индекс — номер ячейки в массиве, а значение — значение, которое мы хотим занести в указанную ячейку.
Но давайте для начала разберемся, как создавать массивы.
2. Создание массива элементов в Java
Допустим, вашей программе нужно где-то хранить 100 целых чисел. Скорее всего, для этого подошел бы массив. И как же его создать?
Если бы мы хотели хранить одно целое число, нам бы подошел тип int, ну а если мы хотим хранить 100 целых чисел, вероятно, нам нужен массив типа int. Вот как будет выглядеть код по его созданию:
int[] array = new int[100];Давайте разберемся, что тут написано.
Как вы уже, возможно, догадались, слева от знака равенства у нас находится объявление переменной по имени array и типа int[]. После типа int следуют квадратные скобки, которые как бы намекают, что в «коробках» этого типа можно будет хранить не одно значение, а несколько.
Справа от знака равенства у нас написано «создание объекта» (слово new) на 100 элементов (ячеек) типа int. Тоже не слишком сложно.
Если бы мы хотели, например, создать массив на 20 ячеек для хранения вещественных чисел, код его создания выглядел бы примерно так:
double[] vals = new double[20];Количество ячеек в массиве называют размером массива или длиной массива. А из-за способности хранить много значений массивы еще называют контейнерами.
Важный факт: размер контейнера массива нельзя изменить после создания.
Можно создать новый, но длину уже созданного контейнера поменять нельзя.
3. Работа с ячейками массива
Хорошо, создавать массивы мы научились, а как правильно с ними работать?
Да практически так же, как и с обычными переменными, только после имени переменной-массива обязательно нужно указывать номер ячейки, с которой мы работаем.
Нумерация ячеек массива всегда начинается с нуля. Если у нас массив на 10 элементов, то номера (индексы) его ячеек 0..9, если массив на 200 элементов, то 0..199. И дальше по аналогии.
Примеры:
int[] a = new int[10]; // Создаем массив на 10 элементов типа int.
a[2] = 4; // В ячейку с индексом 2 записываем значение 4.
a[7] = 9; // В ячейку с индексом 7 записываем значение 9.
a[9] = a[2] + a[5]; // В ячейку с индексом 9 записываем сумму значений, которые хранятся в ячейках 2
// (хранится 4) и 5 (хранится 0).
Вот что будет храниться в памяти после выполнения данного кода:
Колонка слева от массива (серым цветом) — это номера (индексы) ячеек. В ячейках хранятся внесенные значения: 4, 9 и 4. Сразу после создания ячейки массива заполнены нулями.
Важно. Все ячейки массива имеют одинаковый тип данных. Если мы создали массив строк String, в его ячейках можно хранить только строки. Тип данных массива задается при его создании. Ни тип данных, ни длину массива в дальнейшем поменять нельзя.
4. Массивы в памяти
Картинки в предыдущих примерах немного неточны.
При создании массивов (как и при создании строк) в памяти выделяются два блока памяти: один для хранения самого массива (контейнера), а второй — под переменную, которая хранит его адрес. Уточненная ситуация изображена на картинке ниже:
Зеленым цветом изображен массив на 10 элементов типа int и переменная типа int[], которая хранит адрес (ссылку) массива типа int в памяти.
Для сравнения синим цветом обозначена обычная переменная типа int, которая хранит значение 199.
Чем-то напоминает хранение строк в памяти, не находите?
Верно, строки. И как при работе со строками, «переменные типа массив» можно присваивать друг другу:
int[] a = new int[10]; // Создаем массив на 10 элементов типа int.
a[2] = 4; // В ячейку с индексом 2 записываем значение 4.
a[7] = 9; // В ячейку с индексом 7 записываем значение 9.
int[] b = a; // В переменную b сохраняем адрес, который есть в переменной a.
// Теперь a и b указывают на один и тот же объект-массив в памяти.
a[9] = b[2] + a[7]; // В ячейку с индексом 9 объекта-массива записываем сумму значений,
// которые хранятся в ячейках 2 (хранится 4) и 7 (хранится 9).
При этом объект-массив будет оставаться там, где и был, а переменные a и b будут хранить одинаковые адреса (ссылки) на один и тот же объект. Смотрите картинку:
5. Работа с массивом более детально
Массив можно создать из абсолютно любого типа. Для этого лишь нужно после имени типа написать квадратные скобки. Общий вид создания массива будет такой:
тип[] имя = new тип[количество];Где тип — это тип элементов (ячеек) массива, которые мы будем хранить в массиве. Имя — это имя переменной, по которой мы будем к массиву обращаться, а количество — это количество ячеек в массиве.
В примере выше приведена каноническая форма: создание переменной-массива и создание объекта-массива. На самом деле это две независимые конструкции. Можно создать переменную-массив и объект-массив отдельно:
тип[] имя;
имя = new тип[количество];И еще один немаловажный момент
В качестве индекса массива и в качестве количества элементов массива могут выступать переменные и даже целые выражения.
Примеры:
int n = 100;
int[] a = new int[n]; // Создание массива из n элементов
int n = 100;
int[] a = new int[n * 2 + 3]; // Создание массива на 203 элемента
int n = 100;
int[] a = new int[n];
a[n-1] = 2; // a[99] = 2;
a[n-2] = 3; // a[98] = 3;
a[n/5] = a[n-1] + a[n-2] // a[20] = a[99] + a[98];
Выход за границы массива
Кстати, обращаем ваше внимание, что если попробовать обратиться к ячейке массива по индексу, которого в массиве нет (в нашем случае это все целые числа, кроме чисел 0..99), программа аварийно завершится с ошибкой ArrayIndexOutOfBoundsException — индекс за границами массива.
6. Длина массива
Как мы увидели в предыдущем примере, можно отдельно создать переменную типа массив и потом где-то в коде присвоить ей значение (ссылку на объект-массив). Можно сделать даже так:
int[] array; // Создаем переменную-массив типа int[]
if (a < 10) // Если переменная a меньше 10,
array = new int[10]; // то создать массив из 10 элементов.
else // Иначе
array = new int[20]; // создать массив из 20 элементов
И как работать дальше с таким массивом? Как узнать, сколько в нем элементов?
Для этого у массива есть специальное свойство (переменная) — length. И узнать длину массива можно с помощью такого выражения:
array.length;Где array — это имя переменной-массива, а length — это имя свойства у объекта-массива. Значение в свойстве length поменять нельзя: само свойство length можно присваивать другим переменным, но ему ничего присваивать нельзя (программа просто не скомпилируется).
Вот как можно продолжить предыдущий пример:
int[] array; // Создаем переменную-массив типа int[]
if (a < 10) // Если переменная a меньше 10,
array = new int[10]; // то создать массив из 10 элементов.
else // Иначе
array = new int[20]; // создать массив из 20 элементов
for (int i = 0; i < array.length; i++) // Цикл по всем элементам массива: от 0 и до длины array.length — 1
{
System.out.println(array[i]);
}
7. Факты о массивах в Java
Давайте резюмируем известные факты о массивах:
- Факт 1. Массив состоит из множества ячеек.
- Факт 2. Доступ к конкретной ячейке идёт через указание её номера.
- Факт 3. Все ячейки одного типа.
- Факт 4. Начальное значение для всех ячеек — 0 и null (если в ячейке хранится адрес), false (для типа boolean).
- Факт 5. String[] list — это просто объявление переменной: сам контейнер (объект-массив) еще не создан. Чтобы с ним можно было работать, нужно создать массив (контейнер) и положить его в эту переменную, а потом уже им пользоваться. См. пример ниже.
- Факт 6. Когда мы создаём объект-массив (контейнер), нужно указать, какой он длины — сколько в нем ячеек. Это делается командой вида: new TypeName[n];
- Факт 7. Длину массива можно узнать через свойство .length.
- Факт 8. После создания массива нельзя поменять ни тип его элементов, ни их количество.
String s; // s равно null
String[] list; // list равно null
list = new String[10]; // Переменная list хранит ссылку на объект – массив строк из 10 элементов.
int n = list.length; // n равно 10
list = new String[0]; // Теперь list содержит массив из 0 элементов.
// Массив есть, но хранить элементы он не может.
list = null;
System.out.println(list[1]); // Будет сгенерирована ошибка программы — программа аварийно завершится.
// list содержит пустую ссылку — null
list = new String[10];
System.out.println(list[10]); // Будет сгенерирована ошибка — выход за границы массива.
// Если list содержит 10 элементов/ячеек, то их разрешённые индексы: 0 1 2 3 4 5 6 7 8 9 — всего 10 штук.
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ