Cara termudah untuk mengubah koleksi menjadi array?

Misalkan kita punya Collection<Foo>. Apa cara terbaik (terpendek dalam LoC dalam konteks saat ini) untuk mengubahnya Foo[]? Setiap perpustakaan terkenal diizinkan.

UPD: (satu kasus lagi di bagian ini; tinggalkan komentar jika Anda pikir layak membuat utas lain untuk itu): Bagaimana dengan mentransformasikan Collection<Foo>ke Bar[]mana Barmemiliki konstruktor dengan 1 parameter tipe Fooyaitu public Bar(Foo foo){ ... }?

Di mana xkoleksinya:

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

Solusi alternatif untuk pertanyaan yang diperbarui menggunakan Java 8:

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

Jika Anda menggunakannya lebih dari sekali atau dalam satu lingkaran, Anda bisa menentukan konstanta

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

dan lakukan konversi seperti itu

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

The toArrayMetode akan mengambil array kosong untuk menentukan jenis yang tepat dari array target dan membuat array baru untuk Anda.

Inilah proposal saya untuk pembaruan:

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

Dengan JDK / 11, cara alternatif untuk mengonversi a Collection<Foo>menjadi Foo[]dapat digunakan Collection.toArray(IntFunction<T[]> generator)sebagai:

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

Sebagaimana dijelaskan oleh @Stuart pada milis (penekanan milik saya), kinerja ini pada dasarnya harus sama dengan yang ada Collection.toArray(new T[0])-

Hasilnya adalah implementasi yang menggunakan Arrays.copyOf() adalah yang tercepat, mungkin karena itu adalah intrinsik .

Ini dapat menghindari nol-mengisi array yang baru dialokasikan karena tahu seluruh isi array akan ditimpa. Ini benar terlepas dari seperti apa API publik itu.

Implementasi API dalam JDK berbunyi:

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

Panggilan implementasi standar generator.apply(0)untuk mendapatkan array nol panjang dan kemudian hanya memanggil toArray(T[]). Ini melewati Arrays.copyOf() jalur cepat, jadi pada dasarnya kecepatannya sama dengan toArray(new T[0]).

Catatan : - Hanya saja penggunaan API akan dipandu bersama dengan ketidakcocokan ke belakang ketika digunakan untuk kode dengannullnilai-nilai misalnyatoArray(null)karena panggilan ini sekarang akan ambigu karena adatoArray(T[] a)dan akan gagal untuk dikompilasi.

Jika Anda menggunakan Jambu dalam proyek Anda, Anda dapat menggunakan Iterables::toArray.

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

Untuk yang asli, lihat jawaban doublep :

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

Adapun pembaruan:

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

Inilah solusi terakhir untuk kasing di bagian pembaruan (dengan bantuan Koleksi Google):

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

Tapi, pendekatan kunci di sini disebutkan dalam jawaban doublep (saya lupa toArraymetode).

Misalnya, Anda memiliki koleksi ArrayList dengan elemen Kelas siswa:

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