Программирование • 16 августа 2024 • 5 мин чтения

Массивы в Java: создаём, заполняем, применяем

Массивы — одна из основных структур данных для любого языка программирования. Рассказываем, чем они полезны в Java.

Что такое массивы в Java

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

Размер массива в Java

Основные особенности массивов:

● Однородность данных. Массивы могут содержать элементы только одного типа: как примитивные типы данных (int, char, double и т. д.), так и ссылочные типы (объекты классов).
● Фиксированный размер. Размер массива задаётся при его создании и впоследствии не меняется. Массив на десять элементов всегда будет содержать не более десяти значений.
● Индексация с нуля. Доступ к элементам массива осуществляется с помощью индексов, начинающихся с 0 и заканчивающихся на (n-1), где n — количество элементов в массиве.

Преимущества использования массивов:

● Простота доступа. Элементы массива легко доступны по индексу, что позволяет быстро и эффективно извлекать данные и изменять их.
● Упрощённое управление памятью. В отличие от динамических структур данных, таких как списки и множества, массивы занимают непрерывный блок памяти, что увеличивает скорость доступа к элементам и упрощает управление памятью.
● Поддержка стандартных библиотек. Java предоставляет множество встроенных методов для работы с массивами (сортировка, поиск, копирование и т. д.).

Зачем нужны массивы в Java

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

● Упростить код и сделать код более читабельным. Вместо многократного использования одинакового кода для работы с несколькими переменными вы можете использовать цикл для обработки элементов массива.

int[ ] scores = {1, 5, 5, 3, 2};

for (int i = 0; i < scores.length; i++) {
System.out.println("Score " + i + ": " + scores[i]);
}

Этот цикл проходит по всем элементам массива и выводит их значения в терминал

● Легко манипулировать данными с помощью сортировки, поиска, фильтрации и т. д. Java располагает мощными библиотеками и методами для работы с массивами.

import java.util.Arrays;

Arrays.sort(scores);
System.out.println("Sorted scores: " + Arrays.toString(scores));

Метод Arrays.sort сортирует массив scores по возрастанию, а метод Arrays.toString преобразует массив в строку для удобного вывода

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

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

Массив bigArray может хранить миллион элементов, и доступ к каждому из них происходит быстро благодаря последовательному расположению в памяти

На курсе «Java-разработчик» наставники рассказывают о массивах в Java и о других преимуществах языка, которые сейчас особо востребованы в индустрии. Кроме языка Java, студенты курса изучают базы данных, Git, Maven, а также Mock-тестирование и Unit-тестирование.

Объявление переменной массива в Java

Чтобы объявить массив в Java, нужно указать тип данных элементов, которые будут храниться в массиве, за которым следует пара квадратных скобок [ ]. После этого пишется имя переменной массива:

тип_данных[ ] имя_массива;

Примеры объявления массива:

int[ ] numbers; // массив целых чисел java
String[ ] strings; // массив строк java
double[ ] values; // массив вещественных чисел java
char[ ] characters; // массив символов java

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

Объявление массива не создаёт сам массив, а только резервирует место для переменной, которая будет ссылаться на массив. Для создания массива необходимо использовать оператор new, который выделяет память для массива и инициализирует его:

имя_массива = new тип_данных[размер];

Примеры создания массива:

numbers = new int[5]; // Создание массива из пяти целых чисел
strings = new String[3]; // Создание массива из трёх строк
values = new double[10]; // Создание массива из десяти вещественных чисел
letters = new char[4]; // Создание массива из четырёх символов

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

int[ ] numbers = {1, 2, 3, 4, 5}; // Объявление и инициализация массива целых чисел
String[ ] names = {"Alice", "Bob", "Eve"}; // Объявление и инициализация массива строк
double[ ] values = {1.1, 3.14, 9.9}; // Объявление и инициализация массива вещественных чисел
char[ ] characters = {'A', 'B', 'C', '.'}; // Объявление и инициализация массива символов

Часто бывает нужно заполнить массив данными в процессе выполнения программы. Для этого удобно использовать циклы, такие как for или while:

int[ ] squares = new int[10];
for (int i = 0; i < squares.length; i++) {
squares[i] = i * i;
}

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

import java.util.Scanner;

public class Main {
public static void main(String[ ] args) {
Scanner scanner = new Scanner(System.in);

System.out.print("Введите количество элементов: ");
int size = scanner.nextInt();

int[] array = new int[size];

for (int i = 0; i < size; i++) {
System.out.print("Введите элемент " + (i + 1) + ": ");
array[i] = scanner.nextInt();
}

System.out.println("Элементы массива:");
for (int i : array) {
System.out.println(i);
}
}
}

Типы данных массива в Java

Массивы Java могут содержать элементы различных типов данных — от примитивных типов до объектов классов. Примитивные типы — это, к примеру, int, char, boolean, float, double, byte, short и long. Массивы примитивных типов данных часто используются для выполнения простых и высокопроизводительных операций.

Массив логических значений (boolean):

boolean[ ] flags = {true, false, true};

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

Массив строк (String):

String[ ] names = {"Alice", "Bob", "Eve"};

Массив объектов класса (Person):

class Person {
String name;
int age;

Person(String name, int age) {
this.name = name;
this.age = age;
}
}

Person[ ] people = {
new Person("Alice", 30),
new Person("Bob", 25)
};

Для массивов примитивных типов данные инициализируются значениями по умолчанию: 0 для чисел, false для boolean и '\u0000' для char. Для массивов ссылочных типов элементы инициализируются значением null:

int[ ] intArray = new int[5]; // Все элементы равны 0
String[ ] stringArray = new String[5]; // Все элементы равны null

В Java возможно преобразование типов данных при работе с массивами. Наиболее распространёнными являются автоматическое расширение и явное приведение типов:

int[ ] intArray = {1, 2, 3, 4, 5};
double[ ] doubleArray = new double[intArray.length];
for (int i = 0; i < intArray.length; i++) {
doubleArray[i] = intArray[i]; // Автоматическое расширение int до double
}

double[ ] doubleArray = {1.1, 2.2, 3.3};
int[ ] intArray = new int[doubleArray.length];
for (int i = 0; i < doubleArray.length; i++) {
intArray[i] = (int) doubleArray[i]; // Явное приведение double к int
}

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

Одномерный массив представляет собой линейную последовательность элементов одного типа, доступ к которым осуществляется с помощью индексов:

тип_данных[ ] имя_массива;
имя_массива = new тип_данных[размер];

int[ ] numbers = new int[5];
int[ ] numbers = {1, 2, 3, 4, 5};

Доступ к элементам массива осуществляется с использованием индексов, начинающихся с 0:

int firstNumber = numbers[0];
numbers[2] = 10;

Многомерные массивы — это массивы массивов. Наиболее часто используются двумерные массивы, которые можно представить как таблицу или матрицу. Элементы многомерных массивов также инициализируются значениями по умолчанию для их типа (например, 0 для int, null для объектов).

тип_данных[ ][ ] имя_массива;
имя_массива = new тип_данных[количество_строк][количество_столбцов];

int[ ][ ] matrix = new int[3][3];

Структура многомерных массивов в Java

Можно инициализировать двумерный массив java сразу при его создании:

int[ ][ ] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};

Доступ к элементам двумерного массива осуществляется с использованием двух индексов — строки и столбца:

int element = matrix[1][2];
matrix[0][0] = 10;

Трёхмерные массивы представляют собой массивы двумерных массивов, и т. д. Их объявление и использование аналогичны двумерным массивам:

int[ ][ ][ ] cube = new int[3][3][3];

В Java многомерные массивы могут иметь разное количество элементов в каждой строке:

int[ ][ ] jaggedArray = {
{1, 2, 3},
{4, 5},
{6, 7, 8, 9}
};

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

Java предоставляет много классов и методов для работы с массивами, которые делают код лаконичнее и эффективнее, включая класс Arrays, методы сортировки, копирования и поиска, а также полезные утилиты для работы с массивами.

Метод Arrays.sort позволяет отсортировать элементы массива в порядке возрастания:

import java.util.Arrays;

public class Main {
public static void main(String[ ] args) {
int[] numbers = {9, 3, 5, 6, 7};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers)); // Вывод: [3, 5, 6, 7, 9]
}
}

Метод Arrays.binarySearch используется для поиска элемента в отсортированном массиве. Если элемент найден, возвращается его индекс, в противном случае — отрицательное значение:

import java.util.Arrays;

public class Main {
public static void main(String[ ] args) {
int[] numbers = {9, 3, 5, 6, 7};
int index = Arrays.binarySearch(numbers, 5);
System.out.println("Индекс 5: " + index); // Вывод: Индекс 5: 2
}
}

Метод Arrays.copyOf позволяет создать копию массива с указанной длиной:

import java.util.Arrays;

public class Main {
public static void main(String[ ] args) {
int[ ] original = {1, 2, 3, 4, 5};
int[ ] copy = Arrays.copyOf(original, 3);
System.out.println(Arrays.toString(copy)); // Вывод: [1, 2, 3]
}
}

Метод Arrays.fill заполняет массив или его часть указанным значением:

import java.util.Arrays;

public class Main {
public static void main(String[ ] args) {
int[] numbers = new int[5];
Arrays.fill(numbers, 9);
System.out.println(Arrays.toString(numbers)); // Вывод: [9, 9, 9, 9, 9]
}
}

Метод Arrays.toString преобразует массив в строку, что удобно для вывода и отладки:

import java.util.Arrays;

public class Main {
public static void main(String[ ] args) {
int[] numbers = {1, 2, 3, 4, 5};
String arrayString = Arrays.toString(numbers);
System.out.println(arrayString); // Вывод: [1, 2, 3, 4, 5]
}
}