Что такое массивы в Java и как с ними работать

В реальной жизни массивы — это просто группы похожих объектов. Например, жилой массив — это много домов, а лесной — много деревьев. Чтобы различать их, часто используют нумерацию: так у каждого дома есть номер. Это справедливо и в программировании: массив — это набор элементов одного типа, которые хранятся в памяти друг за другом.

Что такое массивы данных и зачем они нужны

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

С циклами и массивами студентов знакомят в первом блоке курса Skypro «Java-разработчик». Это необходимый минимум теории, чтобы начать писать код. Дальше начнете применять знания на практике, разработаете собственное приложение, которое сможете положить в портфолио. А центр карьеры подскажет, как лучше составить резюме, и подготовит к собеседованию, чтобы найти работу по новой профессии еще до окончания курса.

Как объявить массив

Как и при работе с обычной переменной, массив нужно объявить. Это выглядит так:

double[] myFancyArray;

Открывающая и закрывающая квадратные скобки идут подряд и сообщают компилятору, что переменная — массив. Тип элементов задает стоящий перед скобками оператор. Это может быть любой из поддерживаемых в Java примитивных типов данных, например int, byte, char, название класса или перечисления — enum. В нашем примере массив будет состоять из вещественных чисел.

Допустима форма объявления, где скобки ставят после названия переменной:

double myFancyArray[];

Такая форма объявления массива пришла в Java из языка C, но ее используют редко.

Как создать массив в Java

После объявления массива его нужно создать. На этом этапе сообщают компилятору необходимый размер. С точки зрения компилятора, Java-массив — это объект. Поэтому его, как и объект, создают при помощи ключевого слова new. Общий синтаксис:

new имя_массива[длина_массива];

Объявить и создать массив можно одной строкой:

double[] myFancyArray = new double[5];

Или с помощью отдельных операторов:

double[] myFancyArray;
myFancyArray = new double[5];

Чтение и запись элементов

Массив — это пронумерованный набор. Каждый элемент доступен по его номеру (индексу). Нумерация элементов массива начинается с нуля, а не с единицы, поэтому первый элемент массива будет с индексом 0, а последний — «длина_массива — 1».

Нумерация элементов массива

Общий синтаксис оператора доступа к элементу массива:

имя_массива[индекс элемента]

Пример чтения значения элемента:

System.out.println(myFancyArray[3]);

Пример записи значения элемента:

myFancyArray[4] = 1.5;

Инициализация массива в Java

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

• ✔️Поочередно записывать значения в каждый элемент массива:
  myFancyArray[0] = 0.5;
myFancyArray[1] = 1.0;
myFancyArray[2] = 1.5;
myFancyArray[3] = 2.0;
• ✔️Использовать цикл:
  for (int i=0; i<5; i++) {
myFancyArray[i] = i * 2;
}
• ✔️Создать массив:
  double[] myFancyArray = new double[] {0.5, 1.0, 1.5, 2.0};
• ✔️Создать массив без new:
  double[] myFancyArray = {0.5, 1.0, 1.5, 2.0};

Длина массива

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

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

Статический метод arraycopy из утилитарного класса System немного упростит операцию. Синтаксис метода:

System.arraycopy(src, srcPos, dest, destPos, length);

Где:

• src — старый массив;
• srcPos — позиция в старом массиве, с которой начинают чтение;
• dest — новый массив;
• destPos — позиция в новом массиве, с которой начинают запись;
• length — количество элементов, которые надо прочитать из старого массива.

Увеличить длину массива можно так:

double[] values = new double[2];
values[0] = 1.0;
values[1] = 1.5;

double[] tmpValues = new double[3];
System.arraycopy(values, 0, tmpValues, 0, values.length);
values = tmpValues;

Нужно прочитать значение переменной length, чтобы узнать длину массива:

int arrayLength = myFancyArray.length;
System.out.printLn(arrayLength);

Значение длины поможет в работе с циклом for:

double[] myFancyArray = new double[5];
for (int i = 0; i < myFancyArray.length; i++) {
myFancyArray[i] = i * 2;
}

В Skypro на курсе «Java-разработчик» вы научитесь писать программы для игр и приложений, освоите все нужные инструменты: Git, GitHub, Docker, Swagger, PostgreSQL и другие. Потренируетесь под руководством опытных наставников и соберете сильное портфолио. На курсе действует гарантия трудоустройства: поможем вам найти работу или вернем деньги за курс.

Вывод массива

Удобно пользоваться оператором цикла for, чтобы вывести массивы:

String[] weekDays = {“Понедельник”, “Вторник”, “Среда”, “Четверг”, “Пятница”, “Суббота”, “Воскресенье”};
for (int i = 0; i < weekDays.length; i++) { System.out.println(weekDays[i]); } В версиях Java после 1.6 доступен оператор foreach: String[] weekDays = {“Понедельник”, “Вторник”, “Среда”, “Четверг”, “Пятница”, “Суббота”, “Воскресенье”}; for (String weekDay: weekDays) { System.out.println(weekDay); } В Java после версии 1.8 появились Stream API — стримы, которые тоже упрощают работу.

Преобразовать массив в стрим поможет статический метод stream в утилитарном классе Arrays
String[] weekDays = {“Понедельник”, “Вторник”, “Среда”, “Четверг”, “Пятница”, “Суббота”,

“Воскресенье”}; Arrays.stream(weekDays).forEach(weekDay ->
System.out.println(weekDay)
);

Результат после вывода массива

Одномерные и многомерные Java-массивы

Типом элемента массива может быть любой тип данных, который поддерживает язык программирования. В случае с Java тип элемента — объект. Массив — это тоже объект. Поэтому ничто не мешает объявить в качестве переменной массив массивов:
double[][] myMatrixArray;
Такой массив называют двумерным, или матрицей. Простой же массив, где элемент — не другой массив, считают одномерным. Структуру двумерного массива можно представить в виде таблицы:

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

Можно получить доступ к элементу такого массива, если указать номер строки и столбца этой таблицы. Здесь i — номер строки, а j — номер столбца.
myMatrixArray[i][j] = 3.4;

Ошибка компиляции при попытке объявить массив, у которого слишком много измерений

При этом выражение myMatrixArray.length вернет количество строк в таблице. А с помощью выражения myMatrixArray[0].length можно узнать количество столбцов в строке.
Двумерный массив, в котором элементы опять будут массивом, объявляют так:
double[][][] myCubeArray;
Такой массив называют трехмерным, или кубом. Для доступа к элементу надо указать уже три индекса.
Можно объявлять и четырех-, пяти- и десятимерные массивы. Максимальное количество измерений ограничено спецификацией Java — 255. Это объявление переменной выдаст ошибку компиляции:
double[][][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][][]
[][][][][][][][][][][][][][][][] myUberArray;
Ошибка появится, потому что количество измерений объявленного массива равно 256.

Методы для работы с массивами

Методы массивов Java можно посмотреть в стандартной библиотеке. Они представлены как статические методы в утилитарном классе Arrays.

Сортировка массива

Arrays.sort(a) отсортирует массив a в порядке возрастания значений элементов.

Метод Arrays.sort(a, Comparator c) поможет отсортировать в другом порядке.

Здесь Comparator c — экземпляр класса Comparator, который позволяет сравнивать два соседних элемента.

Пример:

int[] myArray = new int[] { 6, 4, 3, 5 };
Arrays.sort( myArray );
System.out.println( Arrays.toString( myArray ) );

Поиск в массиве нужного элемента

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

int[] myArray = {6, 4, 3, 5};
int target = 3;
int index = -1;

for (int i = 0; i < myArray.length; i++) {
if (myArray[i] == target) {
index = i;
break;
}
}

System.out.println("Индекс элемента " + target + ": " + index);

Можно использовать бинарный поиск с помощью метода Arrays.binarySearch(). Он работает гораздо быстрее линейного поиска, но только при условии, что массив был отсортирован.

Пример:

int[] myArray = {3, 4, 5, 6};
int target = 5;

int index = Arrays.binarySearch(myArray, target);

System.out.println("Индекс элемента " + target + ": " + index);

Преобразование массива к строке

Нужно использовать Arrays.toString(a), чтобы вывести массив на печать. Он преобразует массив в строку со значениями всех элементов массива, разделенных запятой. Начало и конец будут обозначены квадратными скобками.

Пример:

int[] myArray = new int[] {4, 3, 5, 6};
System.out.println(Arrays.toString(myArray));

Результат преобразования массива к строке

Удаление элементов из массива

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

✔️Создать новый массив и скопировать в него все элементы кроме того, что надо удалить.

Пример:
import java.util.Arrays;

public class Main {
public static void main(String[] args) {
int[] numbers = {10, 20, 30, 40, 50};
int indexToRemove = 2;

int[] newArray = new int[numbers.length - 1];

System.arraycopy(numbers, 0, newArray, 0, indexToRemove);

System.arraycopy(numbers, indexToRemove + 1, newArray, indexToRemove,
numbers.length - indexToRemove - 1);

System.out.println("Исходный массив: " + Arrays.toString(numbers));
System.out.println("После удаления: " + Arrays.toString(newArray));
}

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

✔️Использовать метод ArrayList, который умеет динамически изменять размер.
Пример:
import java.util.ArrayList;
import java.util.Arrays;

public class Main {
public static void main(String[] args) {
ArrayList list = new ArrayList<>(Arrays.asList(10, 20, 30, 40, 50));

System.out.println("До удаления: " + list);

list.remove(2);

System.out.println("После удаления: " + list);
}
}
✔️Заменить удаляемый элемент на 0 или другое значение-метку.
Пример:
int[] numbers = {10, 20, 30, 40, 50};
int indexToRemove = 2;

numbers[indexToRemove] = 0;

System.out.println("Массив после 'удаления': " + Arrays.toString(numbers));

Освойте Java в онлайн-университете Skypro. Изучите теорию в формате понятных текстовых шпаргалок и 40-минутных видеоуроков. Получите много практики в среде коммерческой разработки и два проекта в портфолио. Преподаватели — эксперты в области Java-разработки. Научат думать как разработчик, а не просто копировать и вставлять код.

Главное о массивах в Java

• Массив — набор однотипных элементов, расположенных друг за другом. Доступ к ним осуществляют по порядковому номеру.
• Длину массива задают во время его создания. После изменить длину уже не получится — нужно создавать новый и копировать значения старого.
• В Java можно объявлять массивы, элементами которых тоже будут массивы. Одномерные массивы Java — это когда элемент не другой массив.
• Стандартная библиотека Java предоставляет большой набор методов, которые упрощают работу. Например, позволяют отсортировать массив, преобразовать к строке или найти нужный элемент.