Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Captura de tipos com wildcard em Java

Um método auxiliar privado com `<T>` permite trocar dois elementos da mesma `List<?>`, sem conversão explícita nem exposição do tipo dos elementos na assinatura pública.

Versão: Java SE 21

Sintaxe

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

Em Java SE 21, List<?> representa uma lista com um argumento de tipo desconhecido. É possível ler um elemento como Object, mas não colocar um Object arbitrário na lista: pode tratar-se de uma List<String>. Não é, portanto, uma List<Object>, e os seus elementos não têm todos de pertencer à mesma classe em tempo de execução.

Na chamada swapFirstCaptured(list), o compilador captura ? numa nova variável de tipo e infere essa variável para T. A declaração <T> antes de void dá ao método auxiliar um único nome para o tipo devolvido por get e aceite por set. Escrever list.set(0, list.get(1)) diretamente no método que recebe List<?> não compila: o compilador não consegue associar o tipo do valor lido ao tipo exigido por set. A captura ocorre durante a compilação, sem copiar a lista, sem conversão explícita e sem inspecionar as classes dos elementos em tempo de execução.

swapFirst aceita uma List<?> e altera essa mesma lista. Se tiver menos de dois elementos, não faz nada. Caso contrário, a lista tem de suportar set; se não o suportar, a troca lança UnsupportedOperationException. Se bastar a operação da biblioteca, Collections.swap(List<?>, int, int) já aceita uma List<?>: quem faz a chamada não precisa de um método auxiliar próprio, mas continua a precisar de índices válidos e de uma lista que suporte set.

Exemplos

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

Resultado

blue, red
20, 10

O mesmo método `swapFirst` troca elementos numa lista modificável de cadeias de caracteres e numa lista modificável de inteiros. As duas linhas mostram a ordem depois de cada troca.

Lições relacionadas

  • Java · Lição 12 · Avançado · Versão: 2
  • Java · Lição 34 · Intermédio · Versão: 2

Fontes