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

CKTIS / Java

List.of et List.of() — listes non modifiables

`List.of` crée une liste non modifiable à partir des éléments fournis. Sans argument, `List.of()` renvoie une liste vide. Aucune surcharge n’accepte d’élément `null`.

Version : Java SE 21

Syntaxe

import java.util.List;

List<E> empty = List.of();
List<E> values = List.of(e1, e2);

// Factory method signatures (E is the element type):
// static <E> List<E> of()
// static <E> List<E> of(E e1, ..., E eN)  [one overload for each N from 1 to 10]
// static <E> List<E> of(E... elements)

List.of désigne les méthodes de fabrique statiques de l’interface java.util.List, disponibles depuis Java 9. List.of() est la surcharge sans argument : elle renvoie une liste vide et non modifiable, à passer lorsqu’une liste est attendue mais qu’il n’y a aucun élément à fournir. Dans List<String> empty = List.of();, Java déduit le type des éléments du type déclaré de la variable.

Il existe des surcharges à nombre fixe de paramètres pour 1 à 10 éléments et une surcharge à arguments variables, of(E... elements), pour un nombre quelconque d’éléments. La liste conserve l’ordre des arguments et accepte les doublons. Si l’un des éléments fournis vaut null, l’appel lève une NullPointerException au lieu de renvoyer une liste.

Les appels à add, remove ou set sur la liste renvoyée lèvent une UnsupportedOperationException, même si elle est vide. La liste n’est pas modifiable, mais les objets qu’elle contient peuvent l’être. Pour ajouter, supprimer ou remplacer des éléments, crée une copie superficielle et modifiable avec new ArrayList<>(source).

Exemples

import java.util.ArrayList;
import java.util.List;

public class ListOfDemo {
    public static void main(String[] args) {
        List<String> empty = List.of();
        List<String> colors = List.of("red", "blue", "red");
        System.out.println("Empty size: " + empty.size());
        System.out.println("Colors: " + String.join(", ", colors));

        try {
            colors.set(0, "green");
        } catch (UnsupportedOperationException expected) {
            System.out.println("UnsupportedOperationException");
        }

        try {
            List.of("red", null);
        } catch (NullPointerException expected) {
            System.out.println("NullPointerException");
        }

        List<String> editable = new ArrayList<>(empty);
        editable.add("green");
        System.out.println("Mutable copy: " + editable.get(0));
        System.out.println("Original size: " + empty.size());
    }
}

Résultat

Empty size: 0
Colors: red, blue, red
UnsupportedOperationException
NullPointerException
Mutable copy: green
Original size: 0

L’exemple montre une liste vide, la conservation de l’ordre et des doublons, et deux exceptions distinctes. L’ajout d’un élément à la copie modifiable ne change pas la liste source vide.

Leçons associées

  • Java · Leçon 67 · Débutant · Version : 2
  • Java · Leçon 34 · Intermédiaire · Version : 2
  • Java · Leçon 43 · Intermédiaire · Version : 2

Sources