Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Collections.sort — trier une liste en Java

Triez une liste existante selon l’ordre naturel de ses éléments ou à l’aide d’un comparateur. Les deux surcharges modifient la même liste et préservent l’ordre relatif des éléments jugés égaux par la comparaison.

Version : Java SE 21

Syntaxe

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 est une méthode statique de la classe java.util.Collections qui réordonne les éléments de la List fournie. Son type de retour est void : elle ne renvoie pas de nouvelle liste. Collections.sort() est une notation abrégée pour désigner la méthode, pas un appel valide sans argument. Les deux surcharges exigent une liste.

Collections.sort(list) effectue un tri croissant selon l’ordre naturel défini par Comparable.compareTo. Les éléments doivent être comparables entre eux. Collections.sort(list, comparator) suit l’ordre défini par un Comparator capable de comparer chaque paire d’éléments. Si le comparateur n’est pas null, les éléments n’ont pas besoin d’implémenter Comparable. Un comparateur null sélectionne l’ordre naturel. En Java SE 21, les deux surcharges délèguent le tri à List.sort.

Les deux tris sont stables : les éléments dont la comparaison renvoie 0 conservent leur ordre relatif, même si equals les considère comme différents. La liste doit permettre le remplacement d’éléments, mais sa taille n’a pas besoin d’être modifiable. Ne comptez pas sur le tri d’une liste créée avec List.of(...) : une UnsupportedOperationException peut être levée. Pour conserver l’ordre initial, triez new ArrayList<>(list).

Passer null comme liste provoque une NullPointerException. Des éléments qui ne peuvent pas être comparés entre eux selon l’ordre choisi peuvent provoquer une ClassCastException. Si l’implémentation détecte une violation du contrat de Comparable ou de Comparator, elle peut lever une IllegalArgumentException ; cette détection n’est pas garantie.

Exemples

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);
    }
}

Résultat

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

Le premier appel trie les entiers par ordre croissant. Le second utilise `Comparator.comparingInt(String::length)` pour trier les chaînes de la plus courte à la plus longue. À longueur égale, `Bo` reste avant `Al` et `Zoe` avant `Mia`.

Leçons associées

  • Java · Leçon 33 · Avancé · Version : 2
  • Java · Leçon 48 · Débutant · Version : 2
  • Java · Leçon 65 · Débutant · Version : 2
  • Java · Leçon 5 · Intermédiaire · Version : 2

Sources