0Pricing
Java Academy · Lección

Parámetros varargs

Defina métodos que acepten listas de argumentos de longitud variable y combínelas con arrays.

Parámetros varargs es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

Parámetros varargs

Los varargs (listas de argumentos de longitud variable) permiten definir métodos que aceptan cualquier cantidad de argumentos del mismo tipo, tratados internamente como un array.

Declaración de varargs

Utilice Type... name para un parámetro varargs. Debe ser el último parámetro y solo puede haber uno por método.

static int sum(int... numbers) {
    int total = 0;
    for (int n : numbers) total += n;
    return total;
}

System.out.println(sum());           // 0 (empty array)
System.out.println(sum(1));          // 1
System.out.println(sum(1, 2, 3));    // 6
System.out.println(sum(1, 2, 3, 4)); // 10

// Can also pass an array
int[] arr = {5, 10, 15};
System.out.println(sum(arr));        // 30

Varargs internamente

Los varargs son azúcar sintáctico. El compilador convierte la llamada en la creación de un array en el sitio de la llamada.

// Calling: sum(1, 2, 3)
// Compiler generates: sum(new int[]{1, 2, 3})

static void printAll(String label, String... items) {
    System.out.println(label + ":");
    for (String item : items) System.out.println("  - " + item);
}

printAll("Fruits", "Apple", "Banana", "Cherry");
// Fruits:
//   - Apple
//   - Banana
//   - Cherry

printAll("Empty"); // varargs is empty array

Parámetros combinados con varargs

El parámetro varargs debe ser el último. Puede combinarlo con parámetros normales delante de él.

static double average(String label, double... values) {
    if (values.length == 0) return 0.0;
    double sum = 0;
    for (double v : values) sum += v;
    double avg = sum / values.length;
    System.out.printf("%s average: %.2f%n", label, avg);
    return avg;
}

average("Math scores", 92.0, 85.5, 78.0, 95.0);
// Math scores average: 87.62

average("Single value", 100.0);
// Single value average: 100.00

Varargs con tipos genéricos

Usar varargs con genéricos provoca una advertencia de contaminación del montón. Suprímala con @SafeVarargs cuando pueda demostrar que el método es seguro.

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

@SafeVarargs  // suppresses heap pollution warning
static <T> List<T> listOf(T... elements) {
    return Arrays.asList(elements); // safe: we don't store to the array
}

List<String> names = listOf("Alice", "Bob", "Charlie");
System.out.println(names); // [Alice, Bob, Charlie]

List<Integer> scores = listOf(95, 87, 73);
System.out.println(scores); // [95, 87, 73]

Varargs y sobrecarga

Cuando un método varargs está sobrecargado con una coincidencia exacta, se prefiere la coincidencia exacta. Los varargs son el último recurso.

static void log(String msg)         { System.out.println("1-arg: " + msg); }
static void log(String m1, String m2) { System.out.println("2-arg: " + m1 + ", " + m2); }
static void log(String... msgs)        { System.out.println("varargs: " + msgs.length); }

log("hello");          // 1-arg: hello
log("a", "b");         // 2-arg: a, b
log("a", "b", "c");   // varargs: 3
log();                  // varargs: 0

printf usa varargs

System.out.printf usa varargs: acepta una cadena de formato y cualquier cantidad de argumentos de cualquier tipo.

// printf signature: printf(String format, Object... args)
System.out.printf("%s ordered %d items for $%.2f%n",
    "Alice", 3, 59.97);
// Alice ordered 3 items for $59.97

// String.format is also varargs
String msg = String.format("Error %d: %s", 404, "Not Found");
System.out.println(msg); // Error 404: Not Found

Crear un logger con varargs

Implementación de un logger estructurado sencillo que acepta pares clave-valor mediante varargs.

static void logEvent(String event, Object... keyValues) {
    if (keyValues.length % 2 != 0)
        throw new IllegalArgumentException("Key-value pairs required");
    StringBuilder sb = new StringBuilder(event);
    for (int i = 0; i < keyValues.length; i += 2)
        sb.append(" ").append(keyValues[i]).append("=").append(keyValues[i+1]);
    System.out.println(sb);
}

logEvent("user.login",  "userId", 42, "ip", "192.168.1.1", "success", true);
// user.login userId=42 ip=192.168.1.1 success=true

Consideración de rendimiento

Cada llamada con varargs crea un array nuevo en el heap. Para métodos de utilidad llamados con mucha frecuencia, proporcione sobrecargas de aridad fija para evitar la asignación.

// Java's own EnumSet does this:
static <E extends Enum<E>> EnumSet<E> of(E e)              { ... }
static <E extends Enum<E>> EnumSet<E> of(E e1, E e2)       { ... }
static <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3) { ... }
static <E extends Enum<E>> EnumSet<E> of(E e1, E... rest)  { ... }
// Avoids array creation for 1-3 args (most common case)

// Apply the same pattern to your own hot-path APIs:
static void report(String msg)             { log(new String[]{msg}); }
static void report(String m1, String m2)   { log(new String[]{m1, m2}); }
static void report(String... msgs)         { log(msgs); }

Varargs y null

Pasar null a un método varargs es ambiguo: Java puede interpretarlo como un array nulo. Utilice una conversión explícita para evitar la advertencia.

static void printItems(String... items) {
    if (items == null) {
        System.out.println("null array passed");
        return;
    }
    for (String item : items)
        System.out.println(item != null ? item : "(null element)");
}

printItems((String[]) null); // null array passed
printItems(null, "valid");   // (null element), valid
printItems();                 // empty array (0 items)

Práctica: ayudante de formato de String

Un envoltorio seguro para printf que devuelve la cadena formateada y usa varargs para ajustarse al estilo de argumentos de formato.

static String fmt(String pattern, Object... args) {
    try {
        return String.format(pattern, args);
    } catch (java.util.IllegalFormatException e) {
        return "[FORMAT ERROR: " + e.getMessage() + "]";
    }
}

System.out.println(fmt("User %s has %d orders", "Alice", 5));
// User Alice has 5 orders

System.out.println(fmt("Invalid %z format", "arg"));
// [FORMAT ERROR: Conversion = 'z' ...]

Comprobación rápida

¿Cuál es el tipo de un parámetro varargs dentro del cuerpo del método?

Repaso: parámetros varargs

Conceptos clave:

  • Los varargs (Type... name) aceptan cero o más argumentos, tratados internamente como un array
  • Debe ser el último parámetro; solo puede haber un parámetro varargs por método
  • El código que realiza la llamada puede pasar valores individuales o un array
  • Utilice @SafeVarargs para suprimir las advertencias de contaminación del montón en varargs genéricos
  • Las sobrecargas con coincidencia exacta se prefieren a las sobrecargas varargs
  • Proporcione sobrecargas de aridad fija para los métodos llamados con frecuencia y evite así la asignación de arrays

Preguntas frecuentes

¿La lección «Parámetros varargs» es gratis?

Sí — el texto completo de «Parámetros varargs» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Parámetros varargs»?

Defina métodos que acepten listas de argumentos de longitud variable y combínelas con arrays. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Parámetros varargs»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Reglas de sobrecarga de métodos
  2. Parámetros varargs
  3. Campos estáticos y constantes
  4. Clases de utilidades y métodos de fábrica estáticos
← Volver a Java Academy