Arrays.sort() в Java: сортировка массива

Сортировка массива — это частая задача при написании Java-приложений. Статический метод Arrays.sort() из класса java.util.Arrays сортирует элементы массива по возрастанию «на месте» — быстро, без ручной реализации алгоритмов. В этом уроке разберём его перегрузки, сортировку по убыванию, сортировку строк и объектов, а также отличия от Collections.sort().

Базовый пример: сортировка по возрастанию

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

import java.util.Arrays;

public class ArraysSortExample1 {
    public static void main(String[] args) {
        int[] array = new int[]{3, 1, 5, 6, 8};
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

Вывод программы:

[1, 3, 5, 6, 8]

Перегрузки метода Arrays.sort()

В классе java.util.Arrays метод sort() перегружен для всех примитивных типов (кроме boolean) и для массивов объектов:

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

Перегрузка с параметрами fromIndex и toIndex сортирует только указанный диапазон. Начальный индекс включается, конечный — нет:

import java.util.Arrays;

public class ArraysSortRangeExample {
    public static void main(String[] args) {
        int[] array = {9, 7, 5, 3, 1};
        Arrays.sort(array, 1, 4); // сортируем элементы с индексами 1, 2, 3
        System.out.println(Arrays.toString(array)); // [9, 3, 5, 7, 1]
    }
}

Если fromIndex > toIndex, будет выброшено IllegalArgumentException, а при выходе за границы массива — ArrayIndexOutOfBoundsException.

Сортировка по убыванию

Чтобы отсортировать массив по убыванию, используется перегрузка с компаратором Comparator.reverseOrder(). Она работает только с массивами объектов, поэтому вместо int[] нужен Integer[]:

import java.util.Arrays;
import java.util.Comparator;

public class ArraysSortDescExample {
    public static void main(String[] args) {
        Integer[] array = {3, 1, 5, 6, 8};
        Arrays.sort(array, Comparator.reverseOrder());
        System.out.println(Arrays.toString(array)); // [8, 6, 5, 3, 1]
    }
}

Для массива примитивов int[] компаратор применить нельзя. Варианты решения:

• отсортировать по возрастанию и затем перевернуть массив циклом (поменять местами элементы с концов к середине);
• преобразовать через Stream API: int[] desc = Arrays.stream(array).boxed().sorted(Comparator.reverseOrder()).mapToInt(Integer::intValue).toArray();

Так выглядит вариант с переворотом массива после сортировки:

int[] array = {3, 1, 5, 6, 8};
Arrays.sort(array); // [1, 3, 5, 6, 8]
for (int i = 0; i < array.length / 2; i++) {
    int tmp = array[i];
    array[i] = array[array.length - 1 - i];
    array[array.length - 1 - i] = tmp;
}
System.out.println(Arrays.toString(array)); // [8, 6, 5, 3, 1]

Сортировка строк и объектов

Массив строк сортируется так же, как массив чисел: String реализует интерфейс Comparable, поэтому строки выстраиваются в лексикографическом порядке:

String[] names = {"Olga", "Anna", "Boris"};
Arrays.sort(names);
System.out.println(Arrays.toString(names)); // [Anna, Boris, Olga]

Для собственных классов есть два пути: реализовать Comparable в самом классе или передать Comparator вторым аргументом. Компаратор удобно строить через ссылки на методы:

import java.util.Arrays;
import java.util.Comparator;

record Person(String name, int age) {}

public class ArraysSortObjectsExample {
    public static void main(String[] args) {
        Person[] people = {
            new Person("Olga", 30),
            new Person("Anna", 25),
            new Person("Boris", 35)
        };
        Arrays.sort(people, Comparator.comparingInt(Person::age));
        System.out.println(Arrays.toString(people));
        // [Person[name=Anna, age=25], Person[name=Olga, age=30], Person[name=Boris, age=35]]
    }
}

Если элементы массива объектов не реализуют Comparable и компаратор не передан, во время выполнения будет выброшено ClassCastException.

Arrays.sort() и Collections.sort(): в чём разница

Начиная с Java 8 у списков есть и собственный метод list.sort(comparator) — Collections.sort() внутри делегирует именно ему.

Arrays.parallelSort()

С Java 8 доступен метод Arrays.parallelSort() с теми же перегрузками. Он разбивает массив на части, сортирует их в нескольких потоках через Fork/Join-пул и сливает результат. На больших массивах (сотни тысяч элементов и более) это даёт выигрыш на многоядерных процессорах; на маленьких массивах parallelSort() сам переключается на обычную последовательную сортировку, так что заметной разницы не будет.

int[] bigArray = new int[1_000_000];
// ... заполнение массива ...
Arrays.parallelSort(bigArray);

На чём чаще всего ошибаются

• Ожидают, что метод вернёт новый массив. Arrays.sort() возвращает void и сортирует на месте — запись int[] sorted = Arrays.sort(array); не скомпилируется.
• Пытаются передать компаратор для int[]. Перегрузка с Comparator существует только для массивов объектов — используйте Integer[] или Stream API.
• Печатают массив без Arrays.toString(). System.out.println(array) выведет что-то вроде [I@1b6d3586 — хеш, а не содержимое.
• Забывают про null-элементы. При сортировке массива объектов с null внутри будет NullPointerException; обойти можно компаратором Comparator.nullsFirst(...) или Comparator.nullsLast(...).
• Сортируют перед Arrays.binarySearch() не всегда. Бинарный поиск корректно работает только на отсортированном массиве — вызов Arrays.sort() перед ним обязателен.

Презентация с видео на Patreon →