JavaRush /Курсы /Java Syntax Pro /Класс Arrays, часть 2

Класс Arrays, часть 2

Java Syntax Pro

5 уровень , 7 лекция

Открыта

1. Метод `Arrays.fill()`

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

int[] x = new int[100];
for (int i = 0; i < x.length; i++)
x[i] = 999;

А можно просто вызвать метод Arrays.fill(), который делает точно то же самое: заполняет переданный массив переданным значением. Вот как это выглядит:

Arrays.fill(имя, значение)

И код из примера выше можно сделать немного компактнее и понятнее:

int[] x = new int[100];
Arrays.fill(x, 999);

А еще с помощью метода Arrays.fill() можно заполнить определенным значением не весь массив, а его часть:

Arrays.fill(имя, первый, последний, значение)

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

По старой доброй традиции Java, последний элемент не входит в диапазон.

Пример:

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

Arrays.fill(x, 3, 7, 999);


String str = Arrays.toString(x);

Заполняем ячейки x[3], x[4], x[5], x[6] значениями 999. Нумерация ячеек массива с нуля!

Переменная str содержит значение:

"[1, 2, 3, 999, 999, 999, 999, 8, 9, 10]"

Метод Arrays.fill() работает только с одномерными массивами. Если в него передать двумерный массив, он будет обработан как одномерный, со всеми вытекающими последствиями.

2. Метод `Arrays.copyOf()`

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

А если очень хочется?

Ну, если очень хочется, то можно:

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

Именно это, кстати, и делает метод Arrays.copyOf(). Вот как выглядит его вызов:

тип[] имя2 = Arrays.copyOf(имя, длина);

Этот метод не меняет существующий массив, вместо этого он создает новый массив и копирует в него элементы старого массива.

Если элементы не поместились (длина меньше длины существующего массива), то лишние значения игнорируются.

Если длина нового массива больше длины старого, ячейки заполняются нулями.

Пример:

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

int[] x2 = Arrays.copyOf(x, 5);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOf(x, 15);
String str3 = Arrays.toString(x3);

Переменная str2 содержит значение:

"[1, 2, 3, 4, 5]"

Переменная str3 содержит значение:

"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0]"

3. Метод `Arrays.copyOfRange()`

А что делать, если вы хотите получить массив длиной 5 из массива длины 10, но чтобы в нем были не первые 5 элементов, а 5 последних?

Именно для этого случая вам пригодится еще один метод класса Arrays – метод Arrays.copyOfRange() Вот как выглядит его вызов:

тип[] имя2 = Arrays.copyOfRange(имя, первый, последний);

Этот метод тоже создает новый массив, но заполняет его данными из произвольного места исходного массива. Где первый и последний — это номера первой и последней ячеек, которые должны быть в новом массиве.

По старой доброй традиции Java, последний элемент не входит в диапазон.

Пример:

int[] x = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20};

int[] x2 = Arrays.copyOfRange(x, 5, 10);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOfRange(x, 5, 15);
String str3 = Arrays.toString(x3);

Переменная str2 содержит значение:

"[16, 17, 18, 19, 20]"

Переменная str3 содержит значение:

"[16, 17, 18, 19, 20, 0, 0, 0, 0, 0]"

4. Метод `Arrays.sort()`

Ну и самое вкусное — сортировка. В программировании сортировать массивы приходится очень часто. Три самых частых действия при работе с массивами:

Сортировка массива
Поиск минимального (или максимального) элемента массива
Определение индекса элемента в массиве (поиск элемента в массиве)

И именно поэтому разработчики Java включили в класс Arrays метод sort(). Вот как выглядит его вызов:

Arrays.sort(имя);

Этот метод сортирует переданный массив по возрастанию.

Пример:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x);

String str = Arrays.toString(x);

Переменная str содержит значение:

"[-20, -20, -20, -2, 0, 3, 8, 11, 99, 999]"

Отлично, да? Вызвал один метод, и вот у вас еще отсортированный массив. Красота.

Кстати, сортировать можно не только весь массив, но и часть массива. Вот как выглядит его вызов:

Arrays.sort(имя, первый, последний);

Где первый и последний — это номера первой и последней ячеек, которых должна коснуться сортировка.

По старой доброй традиции Java, последний элемент не входит в диапазон.

Пример:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x, 4, 8);
String str = Arrays.toString(x);

Переменная str содержит значение:

"[11, -2, 3, 0, -20, -20, 8, 999, 99, -20]"

В Java для сортировки массивов используется самый быстрый алгоритм сортировки — QuickSort. Скорость его сортировки зависит от размера массива и рассчитывается по формуле N*Log(N).

Сортировка массива из 1000 элементов будет содержать около 3_000 сравнений ячеек массива. Сортировка массива из миллиона элементов будет содержать около 6 миллионов сравнений.

5. Метод `Arrays.binarySearch()`

Ну и последний из самых интересных методов класса Arrays умеет искать заданное значение в массиве. Это не обычный поиск, а так называемый бинарный поиск. Суть его заключается вот в чем:

Предварительно массив сортируется
Затем средний элемент массива сравнивается с искомым (с тем, который мы ищем).
Если искомый больше среднего, поиск продолжается в правой половине массива.
Если искомый элемент меньше среднего, поиск продолжается в левой половине массива

Благодаря тому, что массив отсортирован, можно за одно сравнение отбросить половину массива. Затем на следующем шаге отбросить еще половину и т.д.

Такой подход делает бинарный поиск очень быстрым. В массиве из миллиона(!) элементов он может найти индекс нужного элемента всего за 20 сравнений. Минусом такого подхода является то, что массив предварительно нужно отсортировать, а сортировка тоже занимает время.

Вот как выглядит его вызов:

int index = Arrays.binarySearch(имя, значение);

Где имя — это имя массива, который нужно передать уже отсортированным (например, с помощью функции Arrays.sort()). значение — это тот элемент, который ищется в массиве. Метод возвращает результат — индекс искомого элемента в массиве (номер ячейки массива).

Примеры:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};
Arrays.sort(x);

int index1 = Arrays.binarySearch(x, 0);
int index2 = Arrays.binarySearch(x, -20);
int index3 = Arrays.binarySearch(x, 99);
int index4 = Arrays.binarySearch(x, 5);

x содержит:

{-20, -20, -20, -2, 0, 3, 8, 11, 99, 999}

4
1 (также подходили индексы 0 и 2)
8
-7

Если искомых элементов в массиве несколько, просто вернется номер одного из них (нет гарантий, что это будет, допустим, самый первый или наоборот — самый последний из одинаковых элементов).

Если элемент в массиве не найден, индекс будет отрицательным.

6. Ссылка на Oracle документация по классу `Arrays`

Если вам очень интересно, полностью информацию про класс Arrays и все его методы вы можете прочитать в официальной документации на сайте Oracle:

https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/util/Arrays.html

Можете почитать, например, про методы Arrays.mismatch() и Arrays.compare(). Может, найдете в них для себя что-нибудь полезное.

И пусть вас не смущает количество методов – там у каждого метода есть 5-10 копий, которые отличаются только типом параметров.

Предыдущая Предыдущая лекция

Следующая Следующая лекция

Комментарии (639)

ЧТОБЫ ПОСМОТРЕТЬ ВСЕ КОММЕНТАРИИ ИЛИ ОСТАВИТЬ КОММЕНТАРИЙ,
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ

Anonymous #6463865 Уровень 6

11 июля 2026


package com.javarush.task.pro.task05.task0518;
import java.util.Arrays;
/* Сортировка массива */

public class Solution {
    public static int[] array = {9, 8, 7, 6, 5, 4, 3, 2, 1};

    public static void main(String[] args) {
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

Anonymous #6463865 Уровень 6

11 июля 2026


package com.javarush.task.pro.task05.task0517;
import java.util.Arrays;
/* Делим массив */

public class Solution {
    public static int[][] result = new int[2][];
    public static int[] array = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};

    public static void main(String[] args) {
        int x = array.length % 2 == 0
            ? array.length / 2
            : (array.length + 1) / 2;
        result[0] = Arrays.copyOfRange(array, 0, x);
        result[1] = Arrays.copyOfRange(array, x, array.length);
        System.out.println(Arrays.deepToString(result));
    }
}

Anonymous #6463865 Уровень 6

11 июля 2026


package com.javarush.task.pro.task05.task0516;
import java.util.Arrays;
/* Заполняем массив */

public class Solution {
    public static int[] array = new int[20];
    public static int valueStart = 10;
    public static int valueEnd = 13;

    public static void main(String[] args) {
        int x = array.length % 2 == 0
            ? array.length / 2
            : (array.length + 1) / 2;
        Arrays.fill(array, 0, x, valueStart);
        Arrays.fill(array, x, array.length, valueEnd);
        System.out.println(Arrays.toString(array));
    }
}

Артемий Уровень 23

15 июня 2026


package com.javarush.task.pro.task05.task0517;

import java.util.Arrays;

/* 
Делим массив
*/

public class Solution {

    public static int[][] result = new int[2][];
    public static int[] array = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};

    public static void main(String[] args) {
        //напишите тут ваш код
        if (array.length % 2 == 0) {
            result[0] = Arrays.copyOfRange(array, 0,array.length/2);
            result[1] = Arrays.copyOfRange(array, array.length/2,array.length);
        }
        else {
            result[0] = Arrays.copyOfRange(array, 0,array.length/2+1);
            result[1] = Arrays.copyOfRange(array, array.length/2+1,array.length);
        }
        System.out.println(Arrays.deepToString(result));
    }
}

y9mato Уровень 16

31 марта 2026


import java.util.Arrays;

/* 
Делим массив
*/

public class Solution {

    public static int[][] result = new int[2][];
    public static int[] array = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};

    public static void main(String[] args) {
        int dlina = array.length;
        if ((dlina % 2) != 0)
        {
            result[0] = Arrays.copyOfRange(array, 0, (dlina + 1) / 2);
            result[1] = Arrays.copyOfRange(array, (dlina + 1) / 2, dlina);
        } else{
            result[0] = Arrays.copyOfRange(array, 0, dlina / 2);
            result[1] = Arrays.copyOfRange(array, dlina / 2, dlina);
        }
        System.out.println(Arrays.deepToString(result));
    }
}


import java.util.Arrays;

/* 
Заполняем массив
*/

public class Solution {

    public static int[] array = new int[20];
    public static int valueStart = 10;
    public static int valueEnd = 13;

    public static void main(String[] args) {
        int dlinaOsn = array.length;
        if ((array.length) % 2 == 0)
        {
            Arrays.fill(array, 0, array.length / 2, valueStart);
            Arrays.fill(array, array.length / 2, dlinaOsn, valueEnd);
        } else{
            int dlina = (array.length / 2) + 1;
            Arrays.fill(array, 0, dlina, valueStart);
            Arrays.fill(array, dlina, dlinaOsn, valueEnd);
        }
        System.out.println(Arrays.toString(array));
    }
}

Эльмир Уровень 21

7 февраля 2026

С заполнением массива для меня самое легкое решение было такое:


public class Solution {

    public static int[] array = new int[25];
    public static int valueStart = 10;
    public static int valueEnd = 13;

    public static void main(String[] args) {

        if (array.length % 2 == 0){
            int i = array.length / 2;
            Arrays.fill(array, 0, i, valueStart);
            Arrays.fill(array, i, array.length, valueEnd);
        } else if (array.length % 2 != 0){
            int j = (array.length / 2) + 1;
            Arrays.fill(array, 0, j, valueStart);
            Arrays.fill(array, j, array.length, valueEnd);
        }
        System.out.println(Arrays.toString(array));
    }
}

С делением массива для меня самое легкое решение было такое:


public class Solution {

    public static int[][] result = new int[2][];
    public static int[] array = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};

    public static void main(String[] args) {
        if (array.length % 2 !=0){
            int i = (array.length / 2) + 1;
            result [0] = Arrays.copyOfRange(array, 0, i);
            result [1] = Arrays.copyOfRange(array, i, array.length);
        } else {
            int j = (array.length / 2);
            result [0] = Arrays.copyOfRange(array, 0, j);
            result [1] = Arrays.copyOfRange(array, j, array.length);
        }
        System.out.println(Arrays.deepToString(result));
    }
}

Anna Klushkina Уровень 47

6 января 2026

⛏ урааа, больше методов для работы с массивами!

Denis Pereladov Уровень 40

6 декабря 2025

Чтобы не делать проверку четности/нечетности достаточно в индексах использовать


(int) Math.ceil(array.length / 2.0)

;)

Роман Зарубин Уровень 8

2 декабря 2025

Работаем !

Grigoryvvv Уровень 17 Expert

27 октября 2025

Дополнительно рекомендую ознакомиться с методом System.arraycopy() , который копирует значения из одного массива в другой. Данный метод может работать с массивами любого типа. Он из класса System, и активно используется для работы с массивами и будет встречаться нам начиная с 10 уровня в задачах. Данный класс System находится в пакете java.lang, и его не нужно импортировать — это делается автоматически. Если заглянуть в код метода copyOf(), то выяснится, что внутри себя он вызывает метод arraycopy(). Отличие между этими методами в том, что результатом работы методов копирования из Arrays является массив, который они сами и создают, в то время как для arraycopy() массив должен быть уже создан. Вот как выглядит его вызов:


System.arraycopy(имя1, значение1 , имя2, значение2, длина);

где • имя1: исходный массив, из которого копируются элементы; • значение1: индекс первого элемента в исходном массиве, с которого начнется копирование; • имя2: целевой массив, в который будут вставляться элементы; • значение2: индекс первого элемента в целевом массиве, куда будет вставлен первый элемент; • длина: количество элементов, которое необходимо скопировать; Пример:


int[] a = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
int[] b = {5, 5, 5, 5, 5, 5, 5, 5, 5, 5};
System.arraycopy(a, 2, b, 5, 3);

Итог: массив b будет содержать значения {5, 5, 5, 5, 5, 1, 1, 1, 5, 5};

Класс Arrays, часть 2

1. Метод Arrays.fill()

2. Метод Arrays.copyOf()

3. Метод Arrays.copyOfRange()

4. Метод Arrays.sort()

5. Метод Arrays.binarySearch()

6. Ссылка на Oracle документация по классу Arrays

1. Метод `Arrays.fill()`

2. Метод `Arrays.copyOf()`

3. Метод `Arrays.copyOfRange()`

4. Метод `Arrays.sort()`

5. Метод `Arrays.binarySearch()`

6. Ссылка на Oracle документация по классу `Arrays`