¿Puedo pasar un array como argumentos a un método con argumentos variables en Java?

Contamos con la contestación a este dilema, o por lo menos eso pensamos. Si presentas preguntas déjanoslo saber en un comentario, que sin dudar

Solución:

Sí un T... es solo un azúcar sintáctico para un T[].

JLS 8.4.1 Parámetros de formato

El último parámetro formal de una lista es especial; puede ser un aridad variable parámetro, indicado por una elipsis que sigue al tipo.

Si el último parámetro formal es un parámetro de aridad variable de tipo T, se considera que define un parámetro formal de tipo T[]. El método es entonces un aridad variable método. De lo contrario, es un aridad fija método. Las invocaciones de un método de aridad variable pueden contener más expresiones de argumentos reales que parámetros formales. Todas las expresiones de argumentos reales que no corresponden a los parámetros formales que preceden al parámetro de aridad de la variable serán evaluadas y los resultados almacenados en un array que se pasará a la invocación del método.

Aquí hay un ejemplo para ilustrar:

public static String ezFormat(Object... args) 
    String format = new String(new char[args.length])
        .replace("", "[ %s ]");
    return String.format(format, args);

public static void main(String... args) 
    System.out.println(ezFormat("A", "B", "C"));
    // prints "[ A ][ B ][ C ]"

Y si lo de arriba main El método es válido, porque de nuevo, String... es solo String[]. Además, debido a que las matrices son covariantes, una String[] es un Object[], para que también puedas llamar ezFormat(args) de cualquier manera.

Ver también

• Guía del lenguaje Java / varargs

---

Varargs gotchas # 1: pasar null

La forma en que se resuelven los varargs es bastante complicada y, a veces, hace cosas que pueden sorprenderte.

Considere este ejemplo:

static void count(Object... objs) 
    System.out.println(objs.length);


count(null, null, null); // prints "3"
count(null, null); // prints "2"
count(null); // throws java.lang.NullPointerException!!!

Debido a cómo se resuelven los varargs, la última declaración invoca con objs = null, que por supuesto causaría NullPointerException con objs.length. Si quieres regalar uno null argumento a un parámetro varargs, puede realizar una de las siguientes acciones:

count(new Object[]  null ); // prints "1"
count((Object) null); // prints "1"

Preguntas relacionadas

La siguiente es una muestra de algunas de las preguntas que la gente ha hecho al tratar con varargs:

• error con varargs y sobrecarga?
• Cómo trabajar con varargs y reflexión
• El método más específico con coincidencias de aridad fija / variable (varargs)

---

Problemas de Vararg # 2: agregar argumentos adicionales

Como ha descubierto, lo siguiente no “funciona”:

    String[] myArgs =  "A", "B", "C" ;
    System.out.println(ezFormat(myArgs, "Z"));
    // prints "[ [Ljava.lang.String;@13c5982 ][ Z ]"

Debido a la forma en que funcionan los varargs, ezFormat en realidad obtiene 2 argumentos, el primero es un String[], el segundo es un String. Si estás pasando un array a varargs, y desea que sus elementos sean reconocidos como argumentos individuales, y también necesita agregar un argumento adicional, entonces no tiene más remedio que crear otro array que acomoda el elemento extra.

A continuación, se muestran algunos métodos de ayuda útiles:

static  T[] append(T[] arr, T lastElement) 
    final int N = arr.length;
    arr = java.util.Arrays.copyOf(arr, N+1);
    arr[N] = lastElement;
    return arr;

static  T[] prepend(T[] arr, T firstElement) 
    final int N = arr.length;
    arr = java.util.Arrays.copyOf(arr, N+1);
    System.arraycopy(arr, 0, arr, 1, N);
    arr[0] = firstElement;
    return arr;

Ahora puede hacer lo siguiente:

    String[] myArgs =  "A", "B", "C" ;
    System.out.println(ezFormat(append(myArgs, "Z")));
    // prints "[ A ][ B ][ C ][ Z ]"

    System.out.println(ezFormat(prepend(myArgs, "Z")));
    // prints "[ Z ][ A ][ B ][ C ]"

---

Varargs gotchas # 3: pasar un array de primitivas

No “funciona”:

    int[] myNumbers =  1, 2, 3 ;
    System.out.println(ezFormat(myNumbers));
    // prints "[ [[email protected] ]"

Varargs solo funciona con tipos de referencia. Autoboxing no se aplica a array de primitivas. Los siguientes trabajos:

    Integer[] myNumbers =  1, 2, 3 ;
    System.out.println(ezFormat(myNumbers));
    // prints "[ 1 ][ 2 ][ 3 ]"

El tipo subyacente de un método variádico function(Object... args)esfunction(Object[] args). Sun agregó varargs de esta manera para preservar la compatibilidad con versiones anteriores.

Así que debería poder anteponer extraVar para args y llama String.format(format, args).

Está bien pasar un array – de hecho, equivale a lo mismo

String.format("%s %s", "hello", "world!");

es lo mismo que

String.format("%s %s", new Object[]  "hello", "world!");

Es solo azúcar sintáctico: el compilador convierte el primero en el segundo, ya que el método subyacente espera un array para el parámetro vararg.

Ver

• Varargs – Documentación J2SE 1.5

valoraciones y reseñas

Puedes corroborar nuestro análisis escribiendo un comentario o dejando una valoración te lo agradecemos.

---

---

Utiliza Nuestro Buscador