Массивы #

Массив - это структура данных, которая хранит фиксированное количество элементов одного типа. Представь, что тебе нужно сохранить 100 оценок студентов. Создавать 100 переменных int mark1, mark2, … - это безумие. Массив позволяет хранить все значения под одним именем и обращаться к ним по индексу.

Объявление и создание массива #

Объявление #

Объявление массива мало чем отличается от объявления переменной. Единственное отличие - наличие квадратных скобок.

Синтаксис:

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

int[] numbers;
String[] words;

// Также допустима (но нежелательна) запись вида:
int numbers[];

На этом этапе массив ещё не создан, памяти под элементы не выделено. Мы просто говорим, что в обозримом будущем тут появится массив.

Создание с помощью new #

int[] numbers;
numbers = new int[10]; // создаём массив из 10 целых чисел

// Или, по аналогии с переменными, объявление и создание можно объединить:
String[] words = new String[10];

// Также размер можно передать в виде переменной:
int n = 15;
double[] digits = new double[n]; // массив размером в 15 элементов

После создания массива все элементы автоматически инициализируются значениями по умолчанию:

• числовые типы - 0;
• для boolean - false;
• для ссылочных типов (например, String) - null;

Свойство length #

У каждого массива есть свойство length - это количество элементов.

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

Доступ к элементам и индексация #

Индексация (нумерация элементов, если простыми словами) начинается с нуля. Последний элемент любого массива имеет индекс length - 1.

int[] numbers = new int[5]; 
number[0] = 10; // обращение к элементу массива с индексом 0 (т.е. первому элементу)
numbers[4] = 20; // последний элемент
System.out.println(numbers[0]); 

Если же попытаться обратиться по индексу, выходящему за пределы массива, программа упадёт с ошибкой:

numbers[5] = 0; // ArrayIndexOutOfBoundsException

Базовые операции с массивами #

Заполнение через цикл #

Самый распространенный способ обойти массив - использовать цикл for:

int[] numbers = new int[10];
for (int i = 0; i < numbers.length; i++) {
	numbers[i] = i * 2; // заполняем чётными числами
}

Вывод массива в консоль #

В Java даже вывод массива в консоль по-человечески не работает. Если просто написать:

System.out.println(numbers);

то в выводе будет что-то вроде [I@77556fd - это хэш-код объекта, а не содержимое объекта.

Чтобы вывести элементы, нужно либо явно пройтись по ним в цикле:

// Вариант с классическим for
for (int i = 0; i < numbers.length; i++) {
	System.out.print(numbers[i] + " ");
}

// вариант с for-each
for (int i : numbers) { 
	System.out.print(i + " "); // здесь i - не индекс элемента, а сам элемент!
}

Либо использовать Arrays.toString():

import java.util.Arrays;

System.out.println(Arrays.toString(numbers)); 

// Вместо:
System.out.println("Hello World!");
// Можно написать:
IO.println("Hello World!");

// А для чтения ввода:
String a = IO.readln();

// Или с подсказкой
String b = IO.readln("Введите что-нибудь:"); // Никаких лишних импортов и создания сканнеров!

Способы инициализации #

Явное перечисление элементов #

Самый простой способ - заполнить массив значениями при создании:

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

Но так можно делать только при объявлении переменной. Если массив уже объявлен, такой синтаксис не сработает:

int[] numbers;
numbers = {1, 2, 3, 4, 5}; // Ошибка компиляции!

Если массив уже объявлен, то синтаксис заполнения меняется:

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

Многомерные массивы #

Их не будет. Они мне не нравятся.

Класс Arrays - служебные методы #

Этот класс находится в пакете java.util.Arrays и содержит множество полезных методов для работы с массивами.

Arrays.toString() #

Обсуждался выше, но продублирую. Преобразует массив в строку для удобного вывода:

int[] arr = {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(arr)); // [3, 1, 4, 1, 5]

Arrays.sort() #

Сортирует массив по возрастанию:

int[] arr = {5, 2, 8, 1, 9};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); // [1, 2, 5, 8, 9]

Arrays.binarySearch() #

Бинарный поиск элемента в массиве. Работает только на отсортированном массиве. Возвращает индекс элемента или отрицательное число, если элемент не найден:

int[] arr = {1, 2, 5, 8, 9};
int index = Arrays.binarySearch(arr, 5);
System.out.println(index); // 2

int notFound = Arrays.binarySearch(arr, 7);
System.out.println(notFound); // -4 (точка вставки: -index - 1)

Arrays.copyOf() #

Копирует массив (Почему нельзя просто написать int[] copy = numbers?). Можно изменить размер:

int[] original = {1, 2, 3};
// указываем массив, который хотим копировать, и размер нового массива
int[] copy = Arrays.copyOf(original, 5); 
// Если размер нового массива больше исходного, то недостающие элементы заменяются на 0
System.out.println(Arrays.toString(copy)); // [1, 2, 3, 0, 0]

Если новый размер меньше исходного, лишние элементы отбрасываются:

int[] truncated = Arrays.copyOf(original, 2);
System.out.println(Arrays.toString(truncated)); // [1, 2]

Arrays.fill() #

Заполняет все элементы массива указанным значением:

int[] arr = new int[5];
Arrays.fill(arr, 42);
System.out.println(Arrays.toString(arr)); // [42, 42, 42, 42, 42]

Arrays.equals() #

Сравнивает содержимое двух массивов:

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
int[] c = {1, 2, 4};

System.out.println(Arrays.equals(a, b)); // true
System.out.println(Arrays.equals(a, c)); // false

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
System.out.println(a == b); // false

Копирование массивов: в чём разница? #

Дан массив. Мы хотим создать его копию. Первое, что приходит в голову:

int[] a = {1, 2, 3}; // данный массив
int[] copy = a; // копия
System.out.println(Arrays.toString(copy)); // [1, 2, 3]

И вроде копия готова. Верно? Не совсем. Мы скопировали не содержимое массива, а ссылку на массив. Что это значит:

a[0] = 100; // Меняем первый элемент исходного массива
System.out.println(Arrays.toString(copy)); // [100, 2, 3]. Копия также изменилась.

Здесь copy и a ссылаются на один и тот же объект в памяти. Изменения через b видны через a. Это не копия, а просто ещё одна ссылка.

Если мы хотим создать независимую копию массива, необходимо использовать clone():

int[] a = {1, 2, 3};
int[] b = a.clone();
b[0] = 100; // меняем копию
System.out.println(Arrays.toString(a)); // [1, 2, 3]. Исходный массив не изменился
System.out.println(Arrays.toString(b)); // [100, 2, 3]

Практическая работа №3 #

1. Сумма элементов массива #

Напишите программу, которая создаёт массив из 10 целых чисел, заполняет его случайными числами от 0 до 100 и выводит сумму всех элементов. (Как получить случайное число описано в четвёртом задании второй практической работы)

2. Поиск второго максимума #

Вводится массив (сначала пользователь указывает кол-во элементов, потом сами элементы). После заполнения массива найдите второй по величине элемент.

3. Уникальные элементы #

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

4. Развернуть массив #

Напишите метод, который берёт массив целых чисел (массив заполняется либо случайными числами, как в первом задании, либо пользователем, как во втором) и возвращает новый массив, в котором элементы идут в обратном порядке. Не используйте встроенные методы копирования.

5. Перестановка соседних элементов #

Вводится массив. Переставьте соседние элементы списка (A[0] c A[1], A[2] c A[3] и т.д.). Если элементов нечетное число, то последний элемент остается на своем месте.

6*. Транспонирование матрицы #

Дана квадратная матрица (двумерный массив (массив массивов)) размером N×N (квадратная). Напишите программу, которая транспонирует матрицу (меняет строки и столбцы местами). Транспонирование нужно выполнить на месте (в том же массиве), не создавая новый.

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