Koleksiyonu diziye dönüştürmenin en kolay yolu?

Bir Collection<Foo>. Onu dönüştürmenin en iyi (mevcut bağlamda LoC'de en kısa) yolu Foo[]nedir? Herhangi tanınmış kütüphaneler izin verilir.

UPD: (bu bölümde bir durum daha var; bunun için başka bir iş parçacığı oluşturmaya değer olduğunu düşünüyorsanız yorum bırakın): 1 parametre türünde yani yapıcıyı nereye sahip hale Collection<Foo>getirmeye ne dersiniz ?Bar[]BarFoopublic Bar(Foo foo){ ... }

xKoleksiyon nerede :

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

Java 8 kullanarak güncellenmiş soruya alternatif çözüm:

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

Birden fazla kullanırsanız veya bir döngüde kullanırsanız, bir sabit

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

ve dönüşümü aynen yapın

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

toArrayYöntem, hedef dizinin doğru türünü belirlemek için boş dizi çekmek ve sizin için yeni bir dizi oluşturur.

İşte güncelleme için önerim:

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

JDK / 11, bir dönüştürme alternatif yol ile Collection<Foo>bir etmek Foo[]yararlanmak olabilir Collection.toArray(IntFunction<T[]> generator)gibidir:

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

Posta listesinde @Stuart tarafından açıklandığı gibi (benim vurgu), bunun performansı esasen mevcut olanla aynı olmalıdır.Collection.toArray(new T[0]) -

Sonuç olarak,) kullanan uygulamalar en hızlıdır, Arrays.copyOf(çünkü muhtemelen bir içseldir .

Yeni tahsis edilen dizinin sıfır doldurulmasını önleyebilir çünkü tüm dizi içeriğinin üzerine yazılacağını bilir. Bu, genel API'nin nasıl göründüğüne bakılmaksızın geçerlidir.

API'nin JDK içindeki uygulaması şu şekildedir:

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

Varsayılan uygulama generator.apply(0), sıfır uzunluklu bir dizi almayı çağırır ve ardından basitçe çağırır toArray(T[]). Bu Arrays.copyOf() hızlı yoldan geçer , bu yüzden aslında aynı hızdır toArray(new T[0]).

Not : - API kullanımı,değerlerlekod için kullanıldığında geriye dönük bir uyumsuzluk ile birlikte yönlendirilmelidir,nullörneğin,toArray(null)bu çağrılar artık mevcut olduğundan dolayı belirsiztoArray(T[] a)olacak ve derlenemeyeceğinden.

Projenizde Guava kullanıyorsanız kullanabilirsiniz Iterables::toArray.

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

Orijinal için doublep cevabına bakınız :

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

Güncellemeye gelince:

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

İşte güncelleme bölümündeki vaka için son çözüm (Google Koleksiyonları yardımıyla):

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

Ancak, buradaki temel yaklaşım doublep'nin cevabında belirtilmişti ( toArrayyöntemi unuttum ).

Örneğin, Student class öğelerini içeren ArrayList koleksiyonunuz var:

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