¿Qué pasaría si una función pudiera aceptar 2, 5 o 20 argumentos sin cambiar su firma? Eso existe en Java: varargs, la forma elegante de manejar “parámetros infinitos”.
En mi día a día, los varargs me ahorran escribir métodos para cada aridad y me permiten construir APIs más fluidas. Piensa en un logger que acepte un formato y cualquier cantidad de argumentos, o en una utilidad que arme un mensaje a partir de tokens variables. Con varargs, lo complejo se queda en una firma simple y clara.
El truco está en que Java transforma ese parámetro variado en un arreglo del tipo correspondiente. Eso significa que, cada vez que llamas a un método con valores extra, se crea un array en tiempo de ejecución. Es rápido para casos simples, pero ojo: si el camino es crítico en rendimiento, evita usar varargs en hot paths o haz overloading para los casos más comunes. También limita la mezcla con tipos genéricos para evitar boxing innecesario.
Ejemplo práctico en código claro:
public class Utils {
public static int sum(int... numbers) { int s = 0; for (int n : numbers) s += n; return s; }
public static String join(String delimiter, String... tokens) { return String.join(delimiter, tokens); }
public static void main(String[] args) {
System.out.println(sum(1, 2, 3, 4));
System.out.println(join(" - ", "A", "B", "C"));
}
}
Lo ves: una misma firma para cualquier cantidad de entradas, utilizable en múltiples contextos sin boilerplate.
Hoy te propongo un paso concreto: identifica un método que tengas ya con dos o tres variantes de aridad (o que reciba un formato y argumentos). Reescribe esa firma para usar varargs y refactoriza dos o tres llamadas para ver la ganancia de claridad. Mide el cambio de legibilidad y, si hace daño en rendimiento, añade overloading para los casos más comunes.
Top comments (0)