Массивы в Java

🔥 🚀 Важно для всех, кто работает с Java! 🔥
На JavaRocks ты найдешь уникальные туториалы, практические задачи и редкие книги, которых не найти в свободном доступе. Присоединяйся к нашему Telegram-каналу JavaRocks — стань частью профессионального сообщества!

Что такое массив?

Массив – это структура данных, в которой хранятся элементы одного типа. Вы можете его себе представить как набор пронумерованных ячеек. В каждую ячейку можно поместить некоторые данные (по одному элементу данных на ячейку). Доступ к конкретной ячейке осуществляется с помощью ее номера.

Номер элемента в массиве называется индексом.
В Java массив является однородным, то есть все его ячейки содержат элементы одного типа. Таким образом, массив целых чисел содержит только целые числа (int), массив строк – только строки, а массив экземпляров созданного нами класса Dog будет содержать только объекты класса Dog.

Другими словами, Java не позволит нам поместить целое число в первую ячейку массива, String – во вторую, а Dog– в третью.

Объявление массива

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

Как и любая переменная, массив должен быть объявлен в Java. Это можно сделать одним из двух способов. Оба способа равнозначны, но первый способ больше соответствует стилю Java. Второй – наследие языка C: многие программисты на C перешли на Java, и для их удобства был сохранен альтернативный метод. В таблице показаны оба способа объявления массива в Java:

No.	Объявление массива, синтаксис Java	Примеры	Комментарий
1.	`dataType[] arrayName;`	`int[] myArray; Object[] arrayOfObjects;`	Массив желательно объявлять именно так. Это Java стиль.
2.	`dataType arrayName[];`	`int myArray[]; Object arrayOfObjects[];`	Метод объявления массива, унаследованный от C/C++

В обоих случаях dataType – это тип переменных в массиве. В примерах мы объявили два массива. В одном будут храниться ints, а в другом – объекты Object. Таким образом, обьявление массива имеет имя и тип (тип элементов массива). ArrayName – это имя массива.

Создание массива

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

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

new typeOfArray[length];

где typeOfArray – тип массива, а length – его длина (т. е. количество ячеек), выраженная целым числом(int). Обратите внимание, что здесь мы только выделили память под массив – мы не связали объявленный массив с какой-либо ранее объявленной переменной. Обычно массив сначала объявляется, а затем добавляется значение, например:

int[] myArray; 
myArray = new int[10];

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

int[] myArray = new int [10];

Обратите внимание: после создания массива с помощью оператора new его ячейки содержат значения по умолчанию. Для числовых типов (как в нашем примере) значением по умолчанию является 0, для булевых – false, а для ссылочных – null. Таким образом, после выполнения этого оператора

int[] myArray = new int[10];

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

Более подробную информацию о массивах вы можете найти в статье“Кое-что о массивах“.

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

Как мы уже говорили выше, длина массива – это количество элементов, на которое он рассчитан. Длина массива не может быть изменена после его создания. Обратите внимание, что в Java элементы массива нумеруются, начиная с нуля. Так, если у нас есть массив из 10 элементов, то индекс первого элемента равен 0, а индекс последнего 9.

Вы можете получить длину массива с помощью переменной length. Например:

int[] myArray = new int[10]; 
System.out.println(myArray.length);

Вывод:

Инициализация массива и доступ к его элементам

Теперь мы знаем, как создать массив в Java. При этом мы получаем не пустой массив, а массив, заполненный значениями по умолчанию. Например, для массива типа int это 0(нули), а если у нас массив любого ссылочного типа, то по умолчанию в каждой ячейке будет null.

Мы обращаемся к элементу массива (например, чтобы установить его значение, вывести на экран или выполнить какую-либо операцию с ним) по его индексу. Инициализация массива – это процесс заполнения массива определенными значениями (отличными от значений по умолчанию).

Пример: создадим строковый массив для 4 пор года и заполним его названиями.

String[] seasons = new String[4]; 

seasons[0] = "Winter"; 
seasons[1] = "Spring"; 
seasons[2] = "Summer"; 
seasons[3] = "Autumn";

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

String[] seasons = new String[] {"Winter", "Spring", "Summer", "Autumn"};

Более того, оператор new может быть опущен:

String[] seasons = {"Winter", "Spring", "Summer", "Autumn"};

Как вывести массив на экран в Java?

Вы можете выводить элементы массива в консоль с помощью цикла for.

String[] seasons = new String {"Winter", "Spring", "Summer", "Autumn"};
for (int i = 0; i < 4; i++) {
System.out.println(seasons[i]);
}

Программа выдаст следующее сообщение:

Winter
Spring
Summer
Autumn

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

Но что, если мы хотим создать не массив чисел, строк или других объектов, а массив массивов?

Массив, с которым мы уже знакомы (int[] myArray = new int[8]), называется одномерным массивом. Массив массивов называется двумерным массивом. Он похож на таблицу, в которой есть номер строки и номер столбца. Или, если вы изучали основы линейной алгебры, вы можете представить это как матрицу.

Зачем нам нужны такие массивы? Чтобы программировать матрицы и таблицы, а также другие объекты, имеющие похожую структуру. Например, шахматную доску можно представить в виде массива 8×8. Пример объявления многомерного массива:

Int[][] myTwoDimentionalArray = new int[8][8];

Этот массив содержит ровно 64 элемента: myTwoDimentionalArray[0][0], myTwoDimentionalArray[0][1], myTwoDimentionalArray[1][0], myTwoDimentionalArray[1][1] и так далее до myTwoDimentionalArray[7][7].

Таким образом, если мы используем его для представления шахматной доски, то A1 соответствует myTwoDimentionalArray[0][0], а E2 – myTwoDimentionalArray[4][1].

Но как далеко мы можем зайти? В Java вы можете задать массив массивов… массив массивов массивов и так далее. Конечно, трехмерные и более объемные массивы используются крайне редко. Тем не менее, вы можете использовать трехмерный массив, например, для программирования кубика Рубика.

Полезные методы для работы с массивами

Для работы с массивами в Java существует класс java.util.Arrays. В целом, наиболее распространенными операциями, выполняемыми с массивами, являются инициализация (заполнение элементами), получение элемента (по индексу), сортировка и поиск.
Поиск и сортировка массивов – это более сложные темы.
С одной стороны, хорошей практикой является самостоятельное написание нескольких алгоритмов поиска и сортировки – для тренировки своих скилов. С другой стороны, все лучшие алгоритмы уже реализованы и включены в стандартные библиотеки Java, и вы можете и должны ими пользоваться а не писать свой велосипед.

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

Метод void sort(int[] myArray, int fromIndex, int toIndex) сортирует целочисленный массив или подмассив в порядке возрастания.

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

int binarySearch(int[] myArray, int fromIndex, int toIndex, int key). Этот метод ищет ключевой элемент в отсортированном массиве или подмассиве myArray от fromIndex до toIndex. Если элемент найден, то возвращается его индекс. В противном случае возвращается (-fromIndex)-1.

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

Метод String toString(int[] myArray) преобразует массив в строку. В Java массивы не переопределяют toString(). Это означает, что если вы попытаетесь вывести на экран весь массив сразу (System.out.println(myArray)), а не по одному элементу за раз, вы получите имя класса и шестнадцатеричный хэш массива.

Пример использования sort, binarySearch и toString

Давайте создадим массив целых чисел, отобразим его с помощью toString, отсортируем с помощью метода sort, а затем найдем в нем какое-нибудь число.

class Main {
    public static void main(String[] args) {
        int[] array = {1, 5, 4, 3, 7}; 
        System.out.println(array); 
        System.out.println(Arrays.toString(array)); 
        Arrays.sort(array, 0, 4); 
        System.out.println(Arrays.toString(array)); 
        int key = Arrays.binarySearch(array, 5); 
        
        System.out.println(key); 
System.out.println(Arrays.binarySearch(array, 0)); 
        

    }
}

Вывод:

[I@1540e19d
[1, 5, 4, 3, 7]
[1, 3, 4, 5, 7]
3
-1

Первая строка – это попытка отобразить массив без использования toString.
Вторая – массив, отображенный с помощью toString.
Третяя- отсортированный массив.
Четвертая – индекс искомого числа (5) в отсортированном массиве (помните, что мы считаем от нуля, поэтому индекс четвертого элемента массива равен 3).
В пятой строке мы видим -1. Это недопустимый индекс массива. Он сигнализирует о том, что искомое число (в данном случае 0) отсутствует в массиве.

Клонирование массивов в Java: Shallow vs. Deep Copies

К этому моменту вы уже разобрались с основами работы с массивами – фантастика! Но что делать, если вы хотите продублировать один массив в другой? Давайте изучим все тонкости клонирования массивов в Java, от одномерных массивов до многомерных, и посмотрим, как использовать Cloneable.

Клонирование одномерных массивов

Когда вам нужен быстрый способ скопировать одномерный массив, вы можете вызвать метод clone() для объекта массива. Например, если у вас есть массив int[] original, вызов int[] copy = original.clone() даст вам другой массив с той же длиной и элементами.

public class SingleDimClone {
    public static void main(String[] args) {
        int[] original = {1, 2, 3};
        int[] clone = original.clone();

        System.out.println("Original: " + java.util.Arrays.toString(original));
        System.out.println("Clone:    " + java.util.Arrays.toString(clone));
    }
}

Это работает, потому что массивы в Java по умолчанию реализуют интерфейс Cloneable, а значит, поддерживают метод clone(). Но есть одна загвоздка: для одномерных массивов примитивных типов метод clone() эффективно выполняет неглубокое копирование(shallow copy) значений.

Клонирование многомерных массивов

Когда вы вызываете clone() для многомерного массива, Java создает новый “внешний” массив, но не создает полностью отдельные подмассивы для каждого измерения. Вместо этого каждая ссылка на подмассив повторно используется из исходного массива. Называется это неглубокая копия(shallow copy).

Если вы попробуете что-то вроде:

public class MultiDimClone {
    public static void main(String[] args) {
        int[][] original = {
            {1, 2, 3},
            {4, 5, 6}
        };

        int[][] clone = original.clone();

        System.out.println("Original[0] == Clone[0]? " + (original[0] == clone[0]));
    }
}

Строка (original[0] == clone[0]) выведет true, указывая на то, что и оригинальный, и клонированный массив указывают на один и тот же подмассив для original[0]. Это означает, что изменение clone[0] или original[0] может повлиять на оба массива, так что будьте осторожны! Это неглубокое копирование(shallow copy), а не глубокое копирование(deep copy) всей структуры.

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

Роль интерфейса `Cloneable` и метода `clone()`

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

Если вам интересно, метод clone() возвращает объект Object, который вы должны привести к соответствующему типу (например, int[] или String[]). Именно это и происходит под капотом, когда вы выполняете int[] clone = original.clone(). Никакого специального кода с вашей стороны, все просто и легко!

Массивы в двух словах

Основные характеристики массива: тип помещаемых в него данных, его имя и длина.
Размер массива (количество ячеек) должен быть числом
Невозможно изменить длину массива после его создания.
Доступ к элементу массива можно получить по индексу.
Элементы в массивах, как и во всем остальном в Java, нумеруются, начиная с нуля.
После создания массива он заполняется значениями по умолчанию.
Массивы в Java – это не то же самое, что массивы в C++. Они можно сказать как указатели на динамические массивы.

Перевод статьи «Массивы в Java».