Работа с массивами в Java: как его объявить, заполнить и вывести

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

Ещё более подробно о массивах в Java и других особенностях синтаксиса одного из самых популярных языков программирования вы можете узнать на курсах от ProductStar и Skypro. 

Массив в Java — что это

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

В работе с набором данных одного типа без массивов нужно было бы объявлять для каждого элемента свою переменную. А также устанавливать правила именования, чтобы отличать их. Это и долго, и запомнить такой объём информации довольно сложно. Благодаря массивам можно представить списки или строки в виде единой структуры, а затем работать с ними как с единым целым. Перед тем, как начинать работу с массивом, его, как и другие переменные, необходимо объявить.

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

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

int[ ] inds

double[ ] numbers

char[ ] letters

На первом месте располагается тип переменных в массиве, скобки обязательно должны быть квадратными, а пробел перед ними не ставится. Тип массива может быть любым (Integer, String, Date). Одна пара скобок указывает на то, что переменная предназначена для одномерного массива. Иногда скобки размещаются иначе:

int [] myArray1 — с пробелом

int myArray1[] — после названия переменной.

Второй вариант пришёл из языка С, но его применяют гораздо реже. Если вы пишите код, лучше использовать привычный способ и не изменить его на протяжении всей работы. Обычно название переменной указывается во множественном числе. Это может быть существительное (apples, horses,cars), прилагательное или местоимение. В примере выше мы использовали общее обозначение array, которое означает множество. Лучше давать массивам более точные названия, чтобы точно понимать, что находится внутри. Например, players или students. Массив также может хранить в себе ссылочные типы данных. 

На курсе «Java-разработчик с нуля» вначале изучают типы данных в Java, а затем одномерные и многомерные массивы. Обучение на 80 процентов состоит из практики — так разобраться в синтаксисе гораздо проще.

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

После того, как мы объявили массив, можно переходить к его созданию. Здесь мы должны сообщить компилятору размер объекта. Ведь с его точки зрения массив является объектом. Для создания мы используем слово new.

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

или

int[ ] students = new int[7]

Мы объявили массив целых чисел с именем students и сообщили, что в него входят 7 ячеек. В каждой из них будет находиться определённое число. Можно сделать и другой вид (они будут равнозначны, но лучше всё использовать вариант выше, чтобы сократить код):

int[ ] students;

students = new int[7]

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

У каждого элемента в массиве есть свой индекс. Общая длина может быть как положительной, так и нулевой. Важно помнить, что длину уже нельзя изменить после создания массива — это значит, что и размер его не меняется. в Java нумерация элементов начинается с нуля. Если наш массив состоит из 7 элементов, то у первого будет индекс 0, а у последнего — 6. Длину поможет узнать переменная length:

int[ ] students = new int[7]; — создание массива на 7 элементов с названием students

System.out.println(student.length); — вывод длины массива.

Рассмотрим ещё несколько примеров, чтобы разобраться с длиной и номером каждого из элементов массива.

int[ ] array1 = { 1,4,8} — у цифры 1 будет индекс 0, у 4 будет 2, у 8 — 3

string[ ] array2 = { «Hot», «cold»} — первое слово имеет индекс 0, а второе — 1

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

Для запуска массива нужно заполнить его значениями или инициализировать. Вы можете использовать разные варианты.

Быстрая инициализация

String[ ] colors = new String[ ]{«Blue», «Yellow», «Grey»}

или без new

String[ ] colors = {«Blue», «Yellow», «Grey»}

Удобный вариант для случаев, когда известно, какие значения будут находиться в массиве. Мы просто перечисляем их через запятую, как и делали это выше. Java устроен так, что в массиве хранятся не объекты, а ссылки на них. Они же ведут на место, где и находится этот объект. Чаще всего такой способ инициализации применяют, когда количество значений невелико и вы заранее знаете их.

Помимо курсов по Java-разработке на сайте tutortop есть и другие варианты для будущих или практикующих программистов. Например, обучение по веб-разработке или курс для новичков по С++.

Инициализация по индексу

Как вы помните, нумерация значений начинается с нуля. А длина массива length — 1. Так происходит потому, что длина массива всегда на одну единицу больше последнего индекса — ведь считать начинаем с 0. Пример:

int[ ] numbers = new int[2];

numbers[0] = 5;

numbers[1] = 8;

int a = numbers[0];

int b = numbers[1];

System.out.println(a);

System.out.println(b);

Вывод:

5

8

Здесь мы вручную указали значения для каждого элемента массива. В примере это цифры 5 и 8. Потом они считались из него и разместились в переменных a и b. Этот способ похож на первый, но является многосоставным по сравнению с быстрым вариантом. Так массив может быть более гибким, если инициализация осуществляется в разных местах программы, когда поставлена такая задача.

Цикл

Работа с массивом вручную не всегда подходит для инициализации. Код становится массивнее, а времени уходит больше. Для автоматизации процесса применяют циклы. Чтобы использовать цикл, нужно знать первичное значение индекса, длину массива, конечное значение индекса. Для массивов больше всего подходит цикл for. Тип данных в таком случае может быть int, short, byte или char.

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

for (int i = 0; i < numbers.length; i++) {

System.out.println(numbers[i])

Ещё один пример с оценками:

int[ ] marks = {3, 5, 4};

String[ ] names = {«Коля», «Арина», «Маша»};

for (int i = 0; i < marks.length; i++) {

System.out.printf(«%s получает оценку %d%n», names[i], marks[i]);

}

Коля получает оценку 3

Арина получает оценку 5

Маша получает оценку 4

Переменная i применяется в качестве счётчика, обозначающего индекс. Её начальное значение равно 0, но пока циклы работают, переменная меняется на 1, когда проходит один цикл. Цикл прекращается, когда условие i < marks.length больше не может выполняться. Если вы выйдите за границы массива, то произойдёт ошибка. Можно сделать это слева при отрицательном индексе или справа, если он больше или равен длине массива. Ошибочный код выглядит так. Проблема в том, что массив не содержит ячейку с индексом 4. Получается numbers[4] = 4 + 1.

int[ ] numbers = new int[4];

for (int i = 0; i <= numbers.length; i++) {

numbers[i] = i + 1

Вывод массива и цикл foreach

Вывести цикл можно с помощью описанного выше цикла for. Но есть его упрощённая версия под названием foreach. В нём есть две секции, которые отделяются двоеточием. Справа будет название массива, слева — переменная типа, схожего с элементами. По стандарту каждый из элементов берётся из массива и переносится в переменную, постепенно они выводятся с этапом прохождения цикла. По сути он отличается внешне, но для исполняющей машины они одинаковы. Сравните два варианта:

for

String[ ] colors = {“Белый”, “Красный”, “Чёрный”, “Зелёный”, “Оранжевый”, “Синий”, “Фиолетовый”};

for (int i = 0; i < colors.length; i++) {

System.out.println(colors[i])

foreach

String[ ] colors = {“Белый”, “Красный”, “Чёрный”, “Зелёный”, “Оранжевый”, “Синий”, “Фиолетовый”};

for (String color: colors) {

System.out.println(color)

Благодаря второму варианту можно получить доступ к элементам. Но при этом нельзя использовать индексацию или обратиться к значению не по указанному порядку. Также у вас не получится поменять или удалить значение. Foreach больше подходит именно для вывода. А если речь идёт о более сложных операциях, лучше применять for.

Ещё пример:

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

for (int element : array) {

System.out.println(element)

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

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

double[ ][ ] myArray

Объявим двумерный массив:

int[ ][ ] two = new int[3][4]

Присвоим значение индексам:

int[ ][ ] two = new int[3][4];

two[0][1] = 2

Двумерный массив может выглядеть и так:

int [ ][ ] twomasArray = {{5,8,9,4}, {9,4,1,3}, {9,8,2,3}}

Быстрый вывод:

int [ ][ ] twomasArray = {{5,8,9,4}, {9,4,1,3}, {9,8,2,3}}

System.out.printLn(Arrays.deepToString(twomasArray))

[[5,8,9,4], [9,4,1,3], [9,8,2,3]]

В чём плюс двумерных массивов? Рассмотрим на примере. Допустим, нам нужно найти среднее арифметическое оценок по школьным предметам. При наличии четырёх одномерных массивов нужно писать 4 цикла, где в каждом надо считать среднее арифметическое по каждому из предметов. С двумерным массивом всё проще. Достаточно пройтись по элементам, добавляя 2 цикла for. Так может выглядеть использование двух циклов for для вывода двумерного массива:

for (int i = 0; i < array.length; i++) {

for (int j = 0; j < array[i].length; j++) {

System.out.print(array[i][j] + «\t»)

Хотите стать backend-разработчиком, но не знаете, с чего начать? Попробуйте пройти вводные уроки на онлайн-курсах от проверенных школ с нашего сайта:

• Backend-разработка на Java с нуля — Skypro
• Backend-разработка на Node.js — Нетология

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

Рассмотрим несколько методов и способов, которые облегчат работу с массивами.

Сортировка

Если нужно отсортировать элементы в порядке возрастания, используйте Arrays.sort(a). В других случаях поможет Arrays.sort(a, Comparator c), вторая составная часть сравнивает два рядом стоящих элемента.

int[ ] mynumbers = new int[ ] { 8, 6, 3, 1 };

Arrays.sort(mynumbers);

System.out.println( Arrays.toString( mynumbers ) )

1,3,6,8

Наполнение

Для заполнения массивами одинаковыми элементами необязательно писать цикл, вам пригодится Arrays.fill(a, val). Он рассмотрит элементы массива a и присвоит значение val.

int[] mynumbers = new int[ 8 ];

Arrays.fill( mynumbers, 5 );

System.out.println( Arrays.toString( mynumbers ) )

5,5,5,5,5,5,5,5

Чётные и нечётные элементы

Если нужно отдельно вывести чётные цифры, следуйте примеру:

double[ ] myNumbers = {2, 2.9, 3, 18, 25.9};

System.out.print(«Четные элементы массива myNumbers: «);

for (int i = 0; i < myNumbers.length; i++) {

if(myNumbers[i]%2 == 0){

System.out.print(myNumbers[i] + «, «)

Четные элементы массива myNumbers: 2.0,18.0

Нечётные:

double[ ] myNumbers = {2, 2.9, 3, 18, 25.9}

System.out.print(«Нечетные элементы массива myNumbers: «);

for (int i = 0; i < myNumbers.length; i++) {

if(myNumbers[i]%2 != 0){

System.out.print(myNumbers[i] + «, «)

Четные элементы массива myNumbers: 2.9, 3, 25.9

Сумма всех элементов

Пример расчёта суммы элементов массива в Java:

double[ ] myNumbers = {4, 19, 1.3, 3, 25.7};

double total = 0;

for (int i = 0; i < myNumbers.length; i++) {

total += myNumbers[i];

System.out.println(«Сумма элементов массива myNumbers: » + total)

Сумма элементов массива myNumbers: 53

с циклом foreach:

double[ ] myNumbers = {4, 19, 1.3, 3, 25.7};

double total = 0;

for(double element : myNumbers) {

total += element; 

System.out.println(«Сумма массива myNumbers: » + total)

Сумма массива myNumbers: 53

Итоги

• Массив состоит из однотипных элементов, которые располагаются друг за другом. Доступ к каждому из элементов можно получить с помощью индекса.
• Длина массива не меняется после его создания.
• В Java элементы в массивах нумеруются с нуля.
• Можно создавать массивы, элементами которых будут другие массивы. Их называют многомерными.
• В Java есть множество удобных методов для работы с массивами, которые делают процесс написания кода ещё более удобным.