Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Parametri varargs in Java: String... e T...

In Java SE 21, un parametro varargs accetta argomenti separati o un array esistente. Con `T...`, la cancellazione dei tipi comporta un rischio di inquinamento dell’heap.

Versione: Java SE 21

Sintassi

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

In Java SE 21, ... dopo il tipo indica un parametro varargs. Un metodo o un costruttore può averne al massimo uno, in ultima posizione. Nel corpo del metodo String... values ha tipo String[]; in un metodo generico con parametro di tipo <T>, T... values ha tipo T[].

In una chiamata ad arità variabile, il compilatore fa raggruppare gli argomenti finali in un nuovo array. labels() riceve un array vuoto, non null. Se la chiamata è possibile senza raggruppamento, un array compatibile viene passato senza copie: chi chiama vede le modifiche ai suoi elementi. Per il metodo mostrato, labels(null) e labels((String[]) null) passano un riferimento nullo all’array; leggere length causerebbe una NullPointerException. labels((String) null) passa un array con un solo elemento null.

La risoluzione degli overload cerca prima un metodo applicabile senza raggruppare gli argomenti: prima senza boxing e unboxing, poi consentendoli. Solo se entrambe le fasi falliscono considera il raggruppamento. Un metodo varargs può quindi essere scelto in una fase ad arità fissa. labels(String...) e labels(String[]) hanno la stessa firma e non possono costituire due overload distinti.

String è reificabile: il suo tipo è interamente disponibile in fase di esecuzione. T non è reificabile; nel raggruppamento, l’array nuovo usa il tipo ottenuto applicando la cancellazione al tipo di array determinato per quella chiamata. Il compilatore emette un avviso unchecked alla dichiarazione e può emetterlo anche in corrispondenza di una chiamata. Se lo stesso array è accessibile tramite un riferimento Object[], una scrittura può violare le garanzie dei tipi generici. Questo inquinamento dell’heap può emergere più tardi come ClassCastException in lettura.

@SafeVarargs è una dichiarazione di chi scrive il codice, non un controllo in fase di esecuzione. Sopprime questi avvisi alla dichiarazione e nei punti di chiamata. È ammessa sui costruttori varargs e sui metodi varargs static, final o private. Usala solo dopo aver controllato che l’array non venga usato né esposto in modo non sicuro.

Esempi

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

Risultato

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

`[]` è un array vuoto, `[null]` è un array con un elemento `null` e `null` indica l’assenza dell’array. `count` legge solo la lunghezza dell’array: conta due liste, non tre stringhe.

Lezioni correlate

  • Java · Lezione 3 · Avanzato · Versione: 2
  • Java · Lezione 14 · Avanzato · Versione: 2

Fonti