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

CKTIS / Java

Apagamento de tipos genéricos em Java

Java verifica os argumentos de tipo durante a compilação, mas `ArrayList<String>` e `ArrayList<Integer>` não têm classes distintas em tempo de execução. Isto explica as restrições dos arrays e de `instanceof`.

Versão: Java SE 21

Sintaxe

Type erasure is a compiler rule, not a Java keyword. In specification notation, |X| means the erasure of X: |List<String>| = List; |T| = Object for an unbounded T; |T| = Number for T extends Number & Comparable<T>; |T[]| = |T|[].

O apagamento de tipos genéricos é uma regra de compilação, não uma palavra reservada. O compilador usa os argumentos de tipo ao verificar o código. O apagamento de List<String> resulta em List. Uma variável de tipo T é apagada para o apagamento do seu limite mais à esquerda, ou para Object se não tiver nenhum limite declarado. O compilador insere as conversões de tipo necessárias e pode gerar métodos ponte para preservar a redefinição de métodos.

ArrayList<String> e ArrayList<Integer> são tipos distintos no código-fonte, mas getClass() devolve o mesmo objeto Class para as instâncias aqui criadas. A reflexão pode ler assinaturas genéricas das declarações, mas getClass() por si só não revela o argumento de tipo de uma instância. Também não se podem sobrecarregar m(List<String>) e m(List<Integer>) na mesma classe: ambas as assinaturas resultam em m(List).

new List<String>[2] provoca um erro de compilação porque List<String> não está totalmente disponível em tempo de execução: não é reificável. Ao guardar um valor num array, a JVM verifica o tipo dos componentes, mas não pode verificar o argumento String. new List<?>[2] é permitido: List<?> é reificável e não especifica um tipo concreto para os elementos da lista.

Se value tiver tipo estático Object, value instanceof List<String> não compila, pois a conversão correspondente seria não verificada. value instanceof List<?> verifica se o objeto implementa List, não o conteúdo da lista. Desde Java SE 16, alguns testes com argumentos de tipo concretos são permitidos: se x for declarado como List<Integer>, x instanceof ArrayList<Integer> é válido, pois a conversão não seria não verificada. Em execução, testa-se se o objeto é um ArrayList, não o argumento Integer nem o conteúdo.

Exemplos

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

public class TypeErasureDemo {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        ArrayList<Integer> numbers = new ArrayList<>();
        System.out.println(strings.getClass() == numbers.getClass());

        Object value = strings;
        System.out.println(value instanceof List<?>);
        // boolean invalidTest = value instanceof List<String>;

        List<Integer> x = numbers;
        System.out.println(x instanceof ArrayList<Integer>);

        List<?>[] lists = new List<?>[2];
        lists[0] = strings;
        lists[1] = numbers;
        System.out.println(lists.length);
        // List<String>[] invalidArray = new List<String>[2];
    }
}

Resultado

true
true
true
2

As três primeiras linhas mostram `true`: mesma classe, correspondência com `List<?>` e correspondência com `ArrayList<Integer>` dado o tipo estático. `2` é o comprimento do array. Descomenta cada instrução inválida separadamente para veres o respetivo erro de compilação.

Lições relacionadas

  • Java · Lição 58 · Básico · Versão: 2
  • Java · Lição 36 · Intermédio · Versão: 2

Fontes