¿La forma más fácil de transformar la colección en matriz?

Supongamos que tenemos a Collection<Foo>. ¿Cuál es la mejor manera (la más corta en LoC en el contexto actual) para transformarlo Foo[]? Cualquier biblioteca conocida está permitida.

UPD: (un caso más en esta sección; deje comentarios si cree que vale la pena crear otro hilo para él): ¿Qué pasa con la transformación Collection<Foo>a Bar[]donde Bartiene un constructor con 1 parámetro de tipo, Fooes decir public Bar(Foo foo){ ... }?

¿Dónde xestá la colección?

Foo[] foos = x.toArray(new Foo[x.size()]);

Solución alternativa a la pregunta actualizada utilizando Java 8:

Bar[] result = foos.stream()
    .map(x -> new Bar(x))
    .toArray(size -> new Bar[size]);

Si lo usa más de una vez o en un bucle, podría definir una constante

public static final Foo[] FOO = new Foo[]{};

y hacer la conversión como

Foo[] foos = fooCollection.toArray(FOO);

El toArraymétodo tomará la matriz vacía para determinar el tipo correcto de la matriz de destino y creará una nueva matriz para usted.

Aquí está mi propuesta para la actualización:

Collection<Foo> foos = new ArrayList<Foo>();
Collection<Bar> temp = new ArrayList<Bar>();
for (Foo foo:foos) 
    temp.add(new Bar(foo));
Bar[] bars = temp.toArray(new Bar[]{});

Con JDK / 11, una forma alternativa de convertir a Collection<Foo>a Foo[]podría ser utilizar Collection.toArray(IntFunction<T[]> generator)como:

Foo[] foos = fooCollection.toArray(new Foo[0]); // before JDK 11
Foo[] updatedFoos = fooCollection.toArray(Foo[]::new); // after JDK 11

Según lo explicado por @Stuart en la lista de correo (el énfasis es mío), el rendimiento de este debe ser esencialmente el mismo que el de la ya existente Collection.toArray(new T[0])-

El resultado es que las implementaciones que usan Arrays.copyOf() son las más rápidas, probablemente porque es intrínseca .

Puede evitar llenar con cero la matriz recién asignada porque sabe que se sobrescribirá todo el contenido de la matriz. Esto es cierto independientemente de cómo se vea la API pública.

La implementación de la API dentro del JDK dice:

default <T> T[] toArray(IntFunction<T[]> generator) {
    return toArray(generator.apply(0));
}

La implementación predeterminada llama generator.apply(0)para obtener una matriz de longitud cero y luego simplemente llama toArray(T[]). Esto pasa por el Arrays.copyOf() camino rápido, por lo que es esencialmente la misma velocidad que toArray(new T[0]).

Nota : - Solo que el uso de la API debe guiarse junto con una incompatibilidad hacia atrás cuando se usa para código connullvalores, por ejemplo,toArray(null)ya que estas llamadas ahora serían ambiguas debido a la existenciatoArray(T[] a)y no podrían compilarse.

Si usa Guava en su proyecto, puede usar Iterables::toArray.

Foo[] foos = Iterables.toArray(x, Foo.class);

Para el original, vea la respuesta doublep :

Foo[] a = x.toArray(new Foo[x.size()]);

En cuanto a la actualización:

int i = 0;
Bar[] bars = new Bar[fooCollection.size()];
for( Foo foo : fooCollection ) { // where fooCollection is Collection<Foo>
    bars[i++] = new Bar(foo);
}    

Aquí está la solución final para el caso en la sección de actualización (con la ayuda de Google Collections):

Collections2.transform (fooCollection, new Function<Foo, Bar>() {
    public Bar apply (Foo foo) {
        return new Bar (foo);
    }
}).toArray (new Bar[fooCollection.size()]);

Pero, el enfoque clave aquí se mencionó en la respuesta de doublep (olvidé el toArraymétodo).

Por ejemplo, tiene una colección ArrayList con elementos Clase de estudiante:

List stuList = new ArrayList();
Student s1 = new Student("Raju");
Student s2 = new Student("Harish");
stuList.add(s1);
stuList.add(s2);
//now you can convert this collection stuList to Array like this
Object[] stuArr = stuList.toArray();           // <----- toArray() function will convert collection to array