Najłatwiejszy sposób przekształcenia kolekcji w tablicę?

Załóżmy, że mamy plik Collection<Foo>. Jaki jest najlepszy (najkrótszy w LoC w obecnym kontekście) sposób, aby go przekształcić Foo[]? Wszelkie dobrze znane biblioteki są dozwolone.

UPD: (jeszcze jeden przypadek w tej sekcji; zostaw komentarz, jeśli uważasz, że warto utworzyć dla niego kolejny wątek): A co z transformacją Collection<Foo>do Bar[]gdzie Barma konstruktor z 1 parametrem typu Footj. public Bar(Foo foo){ ... }?

Gdzie xjest kolekcja:

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

Alternatywne rozwiązanie zaktualizowanego pytania za pomocą Java 8:

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

Jeśli używasz go więcej niż raz lub w pętli, możesz zdefiniować stałą

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

i zrób konwersję tak, jak chcesz

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

Plik toArrayMetoda zajmie pustą tablicę, aby ustalić właściwy rodzaj tablicy docelowej i stworzyć nową tablicę dla Ciebie.

Oto moja propozycja aktualizacji:

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

W przypadku JDK / 11 alternatywnym sposobem konwersji a Collection<Foo>na an Foo[]może być wykorzystanie Collection.toArray(IntFunction<T[]> generator)jako:

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

Jak wyjaśnił @Stuart na liście mailingowej ( wyróżnienie moje), wydajność powinna być zasadniczo taka sama, jak w przypadku istniejącej Collection.toArray(new T[0])-

W rezultacie implementacje używające Arrays.copyOf() są najszybsze, prawdopodobnie dlatego, że jest to nieodłączne .

Może uniknąć wypełniania świeżo przydzielonej tablicy zerami, ponieważ wie, że cała zawartość tablicy zostanie nadpisana. Dzieje się tak niezależnie od tego, jak wygląda publiczny interfejs API.

Implementacja API w JDK czyta:

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

Domyślna implementacja wywołuje generator.apply(0)tablicę o zerowej długości, a następnie po prostu wywołuje toArray(T[]). Przechodzi przez Arrays.copyOf() szybką ścieżkę, więc jest zasadniczo taka sama jak prędkość toArray(new T[0]).

Uwaga : - Tylko, że użycie API powinno być prowadzone wraz z wsteczną niezgodnością, gdy jest używany do kodu znullwartościami, np.toArray(null)Ponieważ te wywołania byłyby teraz niejednoznaczne z powodu istnieniatoArray(T[] a)i nie mogłyby się skompilować.

Jeśli używasz guawy w swoim projekcie, możesz użyć Iterables::toArray.

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

Oryginał znajduje się w podwójnej odpowiedzi:

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

Co do aktualizacji:

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

Oto ostateczne rozwiązanie sprawy w sekcji aktualizacji (z pomocą Google Collections):

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

Ale kluczowe podejście tutaj zostało wspomniane w odpowiedzi doublep (zapomniałem o toArraymetodzie).

Na przykład masz kolekcję ArrayList z elementami 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