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

Question

Supponiamo di avere un Collection<Foo>. Qual è il modo migliore (il più breve in LoC nel contesto corrente) per trasformarlo in Foo[]? Sono consentite tutte le librerie note .

UPD: (un caso di più in questa sezione, lasciare commenti se si pensa che valga la pena di creare un altro thread per esso): Che dire di trasformare Collection<Foo>-Bar[] dove Bar ha costruttore con 1 parametro di tipo Foo cioè public Bar(Foo foo){ ... }?

Answer 1

Dove x è la raccolta:

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

Answer 2

Se lo si utilizza più di una volta o in un ciclo, si potrebbe definire una costante

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

e fare la conversione piace

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

Il metodo toArray utilizzerà l'array vuoto per determinare e il tipo corretto dell'array di destinazione e crea 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[]{}); 

Answer 3

per l'originale vedere doublep risposta:

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); 
}  

Answer 4

Ecco la finale soluzione per il caso in aggiornamento sett ioni (con l'aiuto di Google Collezioni):

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 in the doublep's answer (ho dimenticato per toArray metodo).

Answer 5

soluzione alternativa al domanda aggiornato utilizzando Java 8:

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