Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Collections.sort — ordinare una lista in Java

Ordina una lista esistente secondo l’ordine naturale degli elementi o tramite un comparatore. Entrambi gli overload modificano la stessa lista e conservano l’ordine relativo degli elementi equivalenti nel confronto.

Versione: Java SE 21

Sintassi

import java.util.Collections;
import java.util.Comparator;
import java.util.List;

// Collections method signatures:
public static <T extends Comparable<? super T>> void sort(List<T> list)
public static <T> void sort(List<T> list, Comparator<? super T> c)

// Call forms:
Collections.sort(list);
Collections.sort(list, comparator);

Collections.sort è un metodo statico della classe java.util.Collections che riordina gli elementi della List passata come argomento. Il tipo di ritorno è void: il metodo non restituisce una nuova lista. Collections.sort() è una notazione abbreviata per indicare il metodo, non una chiamata valida senza argomenti. Entrambi gli overload richiedono una lista.

Collections.sort(list) ordina in senso crescente secondo l’ordine naturale definito da Comparable.compareTo. Gli elementi devono essere confrontabili tra loro. Collections.sort(list, comparator) segue l’ordine definito da un Comparator in grado di confrontare ogni coppia di elementi. Con un comparatore diverso da null, gli elementi non devono necessariamente implementare Comparable. Un comparatore null seleziona l’ordine naturale. In Java SE 21, entrambi gli overload delegano a List.sort.

Entrambi gli overload eseguono un ordinamento stabile: gli elementi per cui il confronto restituisce 0 mantengono l’ordine relativo, anche se equals li considera diversi. La lista deve consentire la sostituzione degli elementi, ma non deve necessariamente poter cambiare dimensione. Non dare per scontato di poter ordinare una lista creata con List.of(...): può verificarsi una UnsupportedOperationException. Per conservare l’ordine originale, ordina new ArrayList<>(list).

Passare null come lista provoca una NullPointerException. Elementi non confrontabili tra loro secondo l’ordine scelto possono provocare una ClassCastException. Se l’implementazione rileva una violazione del contratto di Comparable o Comparator, può lanciare una IllegalArgumentException; il rilevamento non è garantito.

Esempi

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class CollectionsSortDemo {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>(List.of(3, 1, 2));
        Collections.sort(numbers);
        System.out.println(numbers);

        List<String> names = new ArrayList<>(List.of("Zoe", "Mia", "Bo", "Al"));
        Collections.sort(names, Comparator.comparingInt(String::length));
        System.out.println(names);
    }
}

Risultato

[1, 2, 3]
[Bo, Al, Zoe, Mia]

La prima chiamata ordina gli interi in senso crescente. La seconda usa `Comparator.comparingInt(String::length)` per ordinare le stringhe dalla più corta alla più lunga. A parità di lunghezza, `Bo` rimane prima di `Al` e `Zoe` prima di `Mia`.

Lezioni correlate

  • Java · Lezione 33 · Avanzato · Versione: 2
  • Java · Lezione 48 · Base · Versione: 2
  • Java · Lezione 65 · Base · Versione: 2
  • Java · Lezione 5 · Intermedio · Versione: 2

Fonti