Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Cattura dei wildcard in Java

Un metodo ausiliario privato con `<T>` consente di scambiare due elementi della stessa `List<?>` senza cast e senza esporre il tipo degli elementi nella firma pubblica.

Versione: Java SE 21

Sintassi

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

In Java SE 21, List<?> indica una lista con un argomento di tipo sconosciuto. Si può leggere un elemento come Object, ma non si può inserire un Object arbitrario: potrebbe trattarsi di una List<String>. Non è quindi una List<Object> e i suoi elementi non devono avere tutti la stessa classe a runtime.

Nella chiamata swapFirstCaptured(list), il compilatore cattura ? in una nuova variabile di tipo e inferisce quella variabile per T. La dichiarazione <T> prima di void dà al metodo ausiliario un unico nome per il tipo restituito da get e accettato da set. Scritto direttamente nel metodo che riceve List<?>, list.set(0, list.get(1)) non compila: il compilatore non riesce ad associare il tipo del valore letto al tipo richiesto da set. La cattura avviene in compilazione, senza copie, cast o controlli delle classi degli elementi a runtime.

swapFirst accetta una List<?> e modifica la lista stessa. Se ci sono meno di due elementi, non fa nulla. Altrimenti la lista deve supportare set; se non lo supporta, lo scambio genera UnsupportedOperationException. Se basta l’operazione di libreria, Collections.swap(List<?>, int, int) accetta già una List<?>: chi lo invoca non ha bisogno di un proprio metodo ausiliario, ma deve usare indici validi e una lista che supporti set.

Esempi

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

Risultato

blue, red
20, 10

Lo stesso metodo `swapFirst` scambia gli elementi di una lista modificabile di stringhe e di una lista modificabile di interi. Le due righe mostrano l’ordine dopo ciascuno scambio.

Lezioni correlate

  • Java · Lezione 12 · Avanzato · Versione: 2
  • Java · Lezione 34 · Intermedio · Versione: 2

Fonti