Arrays.sort în Java

static void sort(int[] a)                       // și long[], double[], char[], ...
static void sort(int[] a, int fromIndex, int toIndex)
static void sort(Object[] a)
static <T> void sort(T[] a, Comparator<? super T> c)

Ce face Arrays.sort

Arrays.sort(a) rearanjează elementele array-ului în ordine crescătoare. Array-ul se modifică pe loc; metoda nu returnează nimic. Poți sorta și doar o porțiune: sort(a, de, pana), unde pana este exclus.

Pentru array-uri de obiecte (String[], Integer[], un record) poți da un Comparator: Arrays.sort(nume, Comparator.reverseOrder()). Pentru primitive (int[]) nu există variantă cu comparator; ca să sortezi descrescător, sortezi crescător și parcurgi invers sau folosești Integer[].

Primitivele se sortează cu un Quicksort optimizat; obiectele cu un algoritm stabil (TimSort), care păstrează ordinea elementelor egale.

Parametri

Parametru	Descriere
a	Array-ul de sortat.
fromIndex, toIndex	Porțiunea sortată: de la fromIndex inclusiv la toIndex exclusiv.
c	Comparatorul, pentru array-uri de obiecte.

Ce returnează

Nimic (void).

Exemple

Exemplul 1: Numere, texte și o porțiune

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] temperaturi = {21, 18, 25, 19, 23};
        Arrays.sort(temperaturi);
        System.out.println(Arrays.toString(temperaturi));

        String[] orase = {"Iași", "Arad", "Constanța", "Brașov"};
        Arrays.sort(orase);
        System.out.println(Arrays.toString(orase));

        int[] coduri = {9, 8, 7, 6, 5, 4};
        Arrays.sort(coduri, 1, 4);
        System.out.println("Doar pozițiile 1-3: " + Arrays.toString(coduri));
    }
}

Rezultat

[18, 19, 21, 23, 25]
[Arad, Brașov, Constanța, Iași]
Doar pozițiile 1-3: [9, 6, 7, 8, 5, 4]

Exemplul 2: Obiecte sortate cu Comparator

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

public class Main {
    record Carte(String titlu, int an) {}

    public static void main(String[] args) {
        Carte[] raft = {
            new Carte("Ion", 1920), new Carte("Enigma Otiliei", 1938),
            new Carte("Moara cu noroc", 1881), new Carte("Baltagul", 1930)
        };
        Arrays.sort(raft, Comparator.comparingInt(Carte::an));
        for (Carte c : raft) {
            System.out.println(c.an() + " " + c.titlu());
        }
        Integer[] note = {7, 10, 5, 9};
        Arrays.sort(note, Comparator.reverseOrder());
        System.out.println(Arrays.toString(note));
    }
}

Rezultat

1881 Moara cu noroc
1920 Ion
1930 Baltagul
1938 Enigma Otiliei
[10, 9, 7, 5]

Greșeli frecvente

• Încerci Arrays.sort(int[], Comparator). Nu există pentru primitive; folosește Integer[] sau sortează crescător și citește invers.
• Scrii int[] sortat = Arrays.sort(a);. Metoda returnează void; array-ul a este cel sortat.
• Uiți că toIndex este exclus și sortezi o poziție mai puțin decât voiai.

Comenzi înrudite

• Collections.sort: Sortează o listă pe loc: crescător după ordinea naturală sau după un Comparator dat. Echivalent cu lista.sort(…).
• List.sort: Sortează lista pe loc după comparatorul dat; cu null sortează în ordinea naturală (numere crescător, texte alfabetic).
• Arrays.binarySearch: Caută rapid o valoare într-un array sortat. Returnează poziția sau un număr negativ care arată unde ar trebui inserată.
• Comparator: Interfața care spune cum se ordonează două obiecte: compare(a, b) returnează un număr negativ, zero sau pozitiv.
• Arrays.toString: toString transformă un array în text de forma [1, 2, 3]; deepToString face același lucru pentru matrice (array-uri de array-uri).