A maneira mais fácil de transformar coleção em matriz?

Suponha que temos um Collection<Foo>. Qual é a melhor (mais curta no LoC no contexto atual) para transformá-lo Foo[]? Quaisquer bibliotecas conhecidas são permitidas.

UPD: (mais um caso nesta seção; deixe comentários se você acha que vale a pena criar outro thread para ele): Que tal transformar Collection<Foo>em Bar[]onde Bartem construtor com 1 parâmetro do tipo Fooie public Bar(Foo foo){ ... }?

Onde xestá a coleção:

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

Solução alternativa para a pergunta atualizada usando Java 8:

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

Se você o usar mais de uma vez ou em um loop, poderá definir uma constante

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

e faça a conversão como

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

O toArraymétodo utilizará a matriz vazia para determinar o tipo correto da matriz de destino e criará uma nova matriz para você.

Aqui está minha proposta para a atualização:

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

Com o JDK / 11, uma maneira alternativa de converter um Collection<Foo>em um Foo[]poderia ser usar 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

Conforme explicado por @Stuart na lista de discussão (grifo meu), o desempenho disso deve ser essencialmente o mesmo do existente Collection.toArray(new T[0])-

O resultado é que as implementações que usam Arrays.copyOf() são as mais rápidas, provavelmente por serem intrínsecas .

Ele pode evitar o preenchimento zero da matriz alocada recentemente, porque sabe que todo o conteúdo da matriz será substituído. Isso ocorre independentemente da aparência da API pública.

A implementação da API no JDK diz:

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

A implementação padrão chama generator.apply(0)para obter uma matriz de tamanho zero e simplesmente chama toArray(T[]). Isso passa pelo Arrays.copyOf() caminho rápido, portanto é essencialmente a mesma velocidade que toArray(new T[0]).

Nota : - Apenas o uso da API deve ser orientado juntamente com uma incompatibilidade reversa quando usado para código comnullvalores, por exemplo,toArray(null)uma vez que essas chamadas agora seriam ambíguas por causa da existênciatoArray(T[] a)e falhariam na compilação.

Se você usa o Guava no seu projeto, pode usá-lo Iterables::toArray.

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

Para o original, veja a resposta doublep :

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

Quanto à atualização:

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

Aqui está a solução final para o caso na seção de atualização (com a ajuda das coleções do Google):

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

Mas, a principal abordagem aqui foi mencionada na resposta do doublep (eu esqueci o toArraymétodo).

Por exemplo, você tem a coleção ArrayList com os elementos Student class:

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