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

CKTIS / Java

Parâmetros varargs em Java: String... e T...

Em Java SE 21, um parâmetro varargs aceita argumentos separados ou um array já existente. Com `T...`, o apagamento de tipos introduz um risco de poluição do heap.

Versão: Java SE 21

Sintaxe

static void labels(String... values) { /* values has type String[] */ }
static <T> int count(T... values) { return values.length; }

Em Java SE 21, ... após o tipo indica um parâmetro varargs. Um método ou construtor pode ter, no máximo, um parâmetro deste género, sempre em último lugar. No corpo do método, String... values tem o tipo String[]; num método genérico com o parâmetro de tipo <T>, T... values tem o tipo T[].

Numa chamada de aridade variável, o compilador faz com que os argumentos finais sejam agrupados num novo array. labels() recebe um array vazio, não null. Se a chamada for possível sem agrupamento, um array compatível é passado sem cópia: quem chama vê as alterações aos seus elementos. No método apresentado, labels(null) e labels((String[]) null) passam uma referência nula de array; consultar length lançaria NullPointerException. labels((String) null) passa um array com um único elemento null.

A resolução de sobrecargas procura primeiro um método aplicável sem agrupar os argumentos: primeiro sem boxing nem unboxing e depois permitindo ambos. Só considera o agrupamento se nenhuma destas fases encontrar um método aplicável. Assim, um método varargs pode ser selecionado numa fase de aridade fixa. labels(String...) e labels(String[]) têm a mesma assinatura e não podem ser sobrecargas distintas.

String é reificável: o seu tipo está totalmente disponível em tempo de execução. T não é reificável; durante o agrupamento, o novo array usa o tipo obtido ao aplicar o apagamento ao tipo de array determinado para a chamada. O compilador emite um aviso unchecked na declaração e pode também avisar no local da chamada. Se outra referência de tipo Object[] apontar para o mesmo array, uma escrita pode violar as garantias dos tipos genéricos. Esta poluição do heap pode revelar-se mais tarde como ClassCastException durante a leitura.

@SafeVarargs é uma garantia dada por quem escreve o código, não uma verificação em tempo de execução. Suprime estes avisos na declaração e nos locais de chamada. É permitida em construtores varargs e em métodos varargs static, final ou private. Usa-a só depois de verificares que o array não é usado nem exposto de forma insegura.

Exemplos

import java.util.Arrays;
import java.util.List;

public class VarargsDemo {
    static void labels(String... values) {
        System.out.println(Arrays.toString(values));
    }

    @SafeVarargs
    static <T> int count(T... values) {
        return values.length;
    }

    public static void main(String[] args) {
        labels();
        labels("red", "blue");
        labels(new String[]{"green"});
        labels((String) null);
        labels((String[]) null);
        System.out.println(count(List.of("red", "blue"), List.of("green")));
    }
}

Resultado

[]
[red, blue]
[green]
[null]
null
2

`[]` é um array vazio, `[null]` é um array com um elemento `null` e `null` indica que não há array. `count` apenas lê o comprimento do array: conta duas listas, não três cadeias de caracteres.

Lições relacionadas

  • Java · Lição 3 · Avançado · Versão: 2
  • Java · Lição 14 · Avançado · Versão: 2

Fontes