Der einfachste Weg, eine Sammlung in ein Array umzuwandeln?

Angenommen, wir haben eine Collection<Foo>. Was ist der beste (im aktuellen Kontext kürzeste in LoC) Weg, um es zu transformieren Foo[]? Alle bekannten Bibliotheken sind erlaubt.

UPD: (ein weiterer Fall in diesem Abschnitt, Kommentare zu hinterlassen , wenn Sie denken , es lohnt sich einen weiteren Thread für sie zu schaffen): Was ist die Umwandlung Collection<Foo>zu Bar[]dem Barhat Konstruktor mit 1 Parameter vom Typ Fooalso public Bar(Foo foo){ ... }?

Wo xist die Sammlung:

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

Alternative Lösung für die aktualisierte Frage mit Java 8:

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

Wenn Sie es mehrmals oder in einer Schleife verwenden, können Sie eine Konstante definieren

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

und mache die Konvertierung wie es ist

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

Die toArrayMethode verwendet das leere Array, um den richtigen Typ des Zielarrays zu bestimmen und ein neues Array für Sie zu erstellen.

Hier ist mein Vorschlag für das Update:

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[]{});

Bei JDK / 11 besteht eine alternative Möglichkeit zum Konvertieren von a Collection<Foo>in a Foo[]darin, Folgendes zu verwenden Collection.toArray(IntFunction<T[]> generator):

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

Wie von @Stuart auf der Mailingliste (Schwerpunkt Mine) erläutert , sollte die Leistung im Wesentlichen die gleiche sein wie die der vorhandenen Collection.toArray(new T[0])-

Das Ergebnis ist, dass Implementierungen, die Arrays.copyOf() verwenden, am schnellsten sind, wahrscheinlich weil es eine intrinsische ist .

Es kann vermieden werden, dass das frisch zugewiesene Array mit Null gefüllt wird, da es weiß, dass der gesamte Array-Inhalt überschrieben wird. Dies gilt unabhängig davon, wie die öffentliche API aussieht.

Die Implementierung der API im JDK lautet:

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

Die Standardimplementierung ruft generator.apply(0)auf, um ein Array mit der Länge Null abzurufen, und ruft dann einfach auf toArray(T[]). Dies geht durch den Arrays.copyOf() schnellen Weg, also ist es im Wesentlichen die gleiche Geschwindigkeit wie toArray(new T[0]).

Hinweis : - Nur, dass die API-Verwendung mit einer Abwärtsinkompatibilität einhergeht, wenn sie für Code mitnullWerten verwendet wird, z. B.toArray(null)da diese Aufrufe jetzt aufgrund vorhandener Aufrufe mehrdeutig sindtoArray(T[] a)und nicht kompiliert werden können.

Wenn Sie Guava in Ihrem Projekt verwenden, können Sie verwenden Iterables::toArray.

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

Für das Original siehe doppelte Antwort:

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

Wie für das Update:

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

Hier ist die endgültige Lösung für den Fall im Update-Bereich (mithilfe von Google Collections):

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

Aber der Schlüsselansatz hier wurde in der Antwort des Doubleps erwähnt (ich habe die toArrayMethode vergessen ).

Beispiel: Sie haben eine Sammlung ArrayList mit Elementen. Schülerklasse:

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