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

CKTIS / Java

Capture d’un joker de type en Java

Une méthode auxiliaire privée avec `<T>` permet de permuter deux éléments de la même `List<?>`, sans transtypage ni exposition du type des éléments dans la signature publique.

Version : Java SE 21

Syntaxe

public static void swapFirst(List<?> list) {
    swapFirstCaptured(list);
}

private static <T> void swapFirstCaptured(List<T> list) {
    if (list.size() < 2) {
        return;
    }
    T first = list.get(0);
    list.set(0, list.get(1));
    list.set(1, first);
}

En Java SE 21, List<?> désigne une liste dont l’argument de type est inconnu. On peut lire un élément comme Object, mais pas placer un Object quelconque dans la liste : il pourrait s’agir d’une List<String>. Ce n’est donc pas une List<Object>, et ses éléments n’ont pas forcément tous la même classe à l’exécution.

Lors de l’appel swapFirstCaptured(list), le compilateur capture ? sous la forme d’une nouvelle variable de type et infère cette variable pour T. La déclaration <T> avant void donne à la méthode auxiliaire un même nom pour le type renvoyé par get et accepté par set. Écrit directement dans la méthode qui reçoit une List<?>, list.set(0, list.get(1)) ne compile pas : le compilateur ne peut pas faire correspondre le type de la valeur lue au type exigé par set. La capture a lieu à la compilation, sans copie, sans transtypage ni inspection des classes des éléments à l’exécution.

swapFirst accepte une List<?> et modifie cette même liste. Si elle contient moins de deux éléments, la méthode ne fait rien. Sinon, la liste doit prendre en charge set ; dans le cas contraire, la permutation lève UnsupportedOperationException. Si l’opération de bibliothèque suffit, Collections.swap(List<?>, int, int) accepte déjà une List<?> : l’appelant n’a pas besoin de méthode auxiliaire, mais il lui faut des indices valides et une liste qui prend en charge set.

Exemples

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

public class WildcardCaptureDemo {
    public static void swapFirst(List<?> list) {
        swapFirstCaptured(list);
    }

    private static <T> void swapFirstCaptured(List<T> list) {
        if (list.size() < 2) {
            return;
        }
        T first = list.get(0);
        list.set(0, list.get(1));
        list.set(1, first);
    }

    public static void main(String[] args) {
        List<String> words = new ArrayList<>(List.of("red", "blue"));
        List<Integer> numbers = new ArrayList<>(List.of(10, 20));

        swapFirst(words);
        swapFirst(numbers);

        System.out.println(words.get(0) + ", " + words.get(1));
        System.out.println(numbers.get(0) + ", " + numbers.get(1));
    }
}

Résultat

blue, red
20, 10

La même méthode `swapFirst` permute des éléments dans une liste modifiable de chaînes et dans une liste modifiable d’entiers. Les deux lignes montrent l’ordre après chaque permutation.

Leçons associées

  • Java · Leçon 12 · Avancé · Version : 2
  • Java · Leçon 34 · Intermédiaire · Version : 2

Sources