KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Varargs-parameters in Java: String... en T...

In Java SE 21 accepteert een varargs-parameter losse argumenten of een bestaande array. Bij `T...` kan het wissen van type-informatie leiden tot heapvervuiling.

Versie: Java SE 21

Syntax

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

In Java SE 21 geeft ... achter het type een varargs-parameter aan. Een methode of constructor mag er maximaal één hebben, en die moet als laatste staan. In de methode heeft String... values het type String[]; in een generieke methode met typeparameter <T> heeft T... values het type T[].

Bij een aanroep met variabele ariteit zorgt de compiler ervoor dat de laatste argumenten in een nieuwe array worden gebundeld. labels() krijgt een lege array, niet null. Als de aanroep zonder bundeling past, wordt een compatibele array zonder kopie doorgegeven: wijzigingen aan de elementen zijn zichtbaar voor de aanroeper. Bij de getoonde methode geven labels(null) en labels((String[]) null) een nullreferentie door; het lezen van length zou een NullPointerException geven. labels((String) null) geeft een array met één null-element door.

Bij het kiezen van een overload zoekt de compiler eerst zonder bundeling: eerst zonder boxing en unboxing, daarna met beide toegestaan. Pas als geen van beide fasen een passende methode oplevert, wordt bundeling overwogen. Een varargs-methode kan dus al in een fase met vaste ariteit worden gekozen. labels(String...) en labels(String[]) hebben dezelfde signatuur en kunnen geen afzonderlijke overloads zijn.

String is reïficeerbaar: het type is tijdens de uitvoering volledig beschikbaar. T is dat niet; bij bundeling krijgt de nieuwe array het voor die aanroep bepaalde arraytype na het wissen van generieke type-informatie. De compiler geeft bij de declaratie een unchecked-waarschuwing en kan ook bij een aanroep waarschuwen. Als dezelfde array via een Object[]-referentie bereikbaar is, kan een schrijfactie de garanties van generieke typen doorbreken. Die heapvervuiling kan pas later bij het lezen tot een ClassCastException leiden.

@SafeVarargs is een verklaring van de programmeur, geen controle tijdens de uitvoering. De annotatie onderdrukt deze waarschuwingen bij de declaratie en op aanroepplekken. Ze is toegestaan bij varargs-constructors en static, final of private varargs-methoden. Gebruik haar alleen nadat je hebt gecontroleerd dat de array niet op een onveilige manier wordt gebruikt of doorgegeven.

Voorbeelden

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

Resultaat

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

`[]` is een lege array, `[null]` is een array met één `null`-element en `null` betekent dat er geen array is. `count` leest alleen de arraylengte en telt dus twee lijsten, niet drie tekenreeksen.

Gerelateerde lessen

  • Java · Les 3 · Gevorderd · Versie: 2
  • Java · Les 14 · Gevorderd · Versie: 2

Bronnen