CKTIS / Java
Parámetros varargs en Java: String... y T...
En Java SE 21, un parámetro varargs acepta argumentos separados o un array existente. Con `T...`, el borrado de tipos introduce el riesgo de contaminación del montón.
Versión: Java SE 21
Sintaxis
static void labels(String... values) { /* values has type String[] */ }
static <T> int count(T... values) { return values.length; }En Java SE 21, ... después del tipo indica un parámetro varargs. Un método o constructor admite como máximo uno y debe ir al final. Dentro del método, String... values tiene tipo String[]; en un método genérico con el parámetro de tipo <T>, T... values tiene tipo T[].
En una llamada de aridad variable, el compilador hace que los argumentos finales se agrupen en un array nuevo. labels() recibe un array vacío, no null. Si la llamada encaja sin agrupación, el array compatible se pasa sin copiarlo: quien llama puede observar los cambios en sus elementos. Para el método mostrado, labels(null) y labels((String[]) null) pasan una referencia de array nula; acceder a su length lanzaría NullPointerException. labels((String) null) pasa un array con un único elemento null.
Al resolver una sobrecarga, el compilador busca primero una coincidencia sin agrupar argumentos: primero sin boxing ni unboxing y luego permitiéndolos. Solo considera la agrupación si ninguna de esas fases encuentra un método aplicable. Por tanto, un método varargs se puede seleccionar en una fase de aridad fija. labels(String...) y labels(String[]) tienen la misma firma y no pueden ser sobrecargas distintas.
String es reificable: su tipo está disponible por completo en tiempo de ejecución. T no es reificable; al agrupar los argumentos, el array nuevo usa el tipo resultante de borrar el tipo de array determinado para esa llamada. El compilador emite una advertencia unchecked en la declaración y puede emitirla también en una llamada. Si otra referencia de tipo Object[] apunta al mismo array, una escritura puede romper las garantías de los tipos genéricos. Esta contaminación del montón puede manifestarse más tarde como ClassCastException al leer un valor.
@SafeVarargs es una afirmación de quien escribe el código, no una comprobación en tiempo de ejecución. Suprime esas advertencias en la declaración y en las llamadas. Se permite en constructores varargs y en métodos varargs static, final o private. Úsala solo tras comprobar que el array no se usa ni se expone de forma insegura.
Ejemplos
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
`[]` es un array vacío, `[null]` es un array con un elemento `null` y `null` indica que no hay array. `count` solo lee la longitud del array: cuenta dos listas, no tres cadenas.
Lecciones relacionadas
- Java · Lección 3 · Avanzado · Versión: 2
- Java · Lección 14 · Avanzado · Versión: 2
Fuentes
- Java Language Specification, Java SE 21 — §8.4.1 Formal Parameters
- Java Language Specification, Java SE 21 — §8.4.2 Method Signature
- Java Language Specification, Java SE 21 — §15.12.2 Compile-Time Step 2: Determine Method Signature
- Java Language Specification, Java SE 21 — §15.12.4.2 Evaluate Arguments
- Java Language Specification, Java SE 21 — §4.7 Reifiable Types
- Java Language Specification, Java SE 21 — §4.12.2 Variables of Reference Type
- Java SE 21 API — SafeVarargs
- Java SE 21 API — Arrays.toString(Object[])
- JDK 21 Tool Specifications — The javac Command