Il modo più semplice per trasformare la raccolta in array?

Supponiamo di avere un Collection<Foo>. Qual è il modo migliore (il più breve in LoC nel contesto attuale) per trasformarlo Foo[]? Eventuali Ben noti librerie sono ammessi.

UPD: (un altro caso in questa sezione; lascia commenti se pensi che valga la pena creare un altro thread per esso): Che ne dici di trasformarti Collection<Foo>in Bar[]dove Barha il costruttore con 1 parametro di tipo, ad Fooesempio public Bar(Foo foo){ ... }?

Dov'è xla collezione:

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

Soluzione alternativa alla domanda aggiornata utilizzando Java 8:

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

Se lo usi più di una volta o in un ciclo, potresti definire una costante

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

e fai la conversione come piace

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

Il toArraymetodo prenderà l'array vuoto per determinare il tipo corretto dell'array di destinazione e creare un nuovo array per te.

Ecco la mia proposta per l'aggiornamento:

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, un modo alternativo di convertire un Collection<Foo>in un Foo[]potrebbe essere quello di utilizzare Collection.toArray(IntFunction<T[]> generator)come:

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

Come spiegato da @Stuart nella mailing list (sottolineatura mia), le prestazioni di questo dovrebbero essere essenzialmente le stesse di quelle esistenti Collection.toArray(new T[0])-

Il risultato è che le implementazioni che usano Arrays.copyOf() sono le più veloci, probabilmente perché sono intrinseche .

Può evitare di riempire zero l'array appena allocato perché sa che l'intero contenuto dell'array verrà sovrascritto. Questo è vero indipendentemente dall'aspetto dell'API pubblica.

L'implementazione dell'API all'interno di JDK recita:

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

L'implementazione predefinita chiama generator.apply(0)per ottenere un array di lunghezza zero e quindi chiama semplicemente toArray(T[]). Questo passa attraverso il Arrays.copyOf() percorso veloce, quindi è essenzialmente la stessa velocità di toArray(new T[0]).

Nota : - Solo che l'uso dell'API deve essere guidato insieme a un'incompatibilità all'indietro quando utilizzato per il codice connullvalori, ad esempiotoArray(null)poiché queste chiamate sarebbero ora ambigue a causa dell'esistentetoArray(T[] a)e non verrebbero compilate.

Se usi Guava nel tuo progetto puoi usarlo Iterables::toArray.

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

Per l'originale vedi la risposta doublep :

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

Per quanto riguarda l'aggiornamento:

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

Ecco la soluzione finale per il caso nella sezione aggiornamento (con l'aiuto di Google Collections):

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

Ma l'approccio chiave qui è stato menzionato nella risposta del doublep (ho dimenticato il toArraymetodo).

Ad esempio, hai una raccolta ArrayList con elementi Classe studente:

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