Cara mudah untuk mengonversi Iterable ke Collection

Dalam aplikasi saya, saya menggunakan perpustakaan pihak ke-3 (Data Spring untuk MongoDB tepatnya).

Metode perpustakaan ini kembali Iterable<T>, sedangkan kode saya yang lain mengharapkan Collection<T>.

Apakah ada metode utilitas di suatu tempat yang akan membiarkan saya dengan cepat mengkonversi satu ke yang lain? Saya ingin menghindari membuat banyak foreachloop dalam kode saya untuk hal yang sangat sederhana.

Dengan Guava Anda dapat menggunakan Lists.newArrayList (Iterable) atau Sets.newHashSet (Iterable) , di antara metode serupa lainnya. Ini tentu saja akan menyalin semua elemen ke dalam memori. Jika itu tidak dapat diterima, saya pikir kode Anda yang berfungsi dengan ini harus mengambil Iterablealih Collection. Jambu biji juga terjadi untuk memberikan metode yang nyaman untuk melakukan hal-hal yang dapat Anda lakukan pada Collectionmenggunakan Iterable(seperti Iterables.isEmpty(Iterable)atau Iterables.contains(Iterable, Object)), tetapi implikasi kinerja lebih jelas.

Di JDK 8+, tanpa menggunakan lib tambahan:

Iterator<T> source = ...;
List<T> target = new ArrayList<>();
source.forEachRemaining(target::add);

Sunting: Yang di atas adalah untuk Iterator. Jika Anda berurusan dengan Iterable,

iterable.forEach(target::add);

Anda dapat menulis metode utilitas Anda sendiri untuk ini juga:

public static <E> Collection<E> makeCollection(Iterable<E> iter) {
    Collection<E> list = new ArrayList<E>();
    for (E item : iter) {
        list.add(item);
    }
    return list;
}

Solusi ringkas dengan Java 8 menggunakan java.util.stream:

public static <T> List<T> toList(final Iterable<T> iterable) {
    return StreamSupport.stream(iterable.spliterator(), false)
                        .collect(Collectors.toList());
}

IteratorUtilsfrom commons-collectionsdapat membantu (meskipun mereka tidak mendukung obat generik dalam versi stabil terbaru 3.2.1):

@SuppressWarnings("unchecked")
Collection<Type> list = IteratorUtils.toList(iterable.iterator());

Versi 4.0 (yang ada di SNAPSHOT saat ini) mendukung obat generik dan Anda dapat menyingkirkannya @SuppressWarnings.

Pembaruan: Periksa IterableAsListdari Cactoos .

Dari CollectionUtils :

List<T> targetCollection = new ArrayList<T>();
CollectionUtils.addAll(targetCollection, iterable.iterator())

Berikut adalah sumber lengkap dari metode utilitas ini:

public static <T> void addAll(Collection<T> collection, Iterator<T> iterator) {
    while (iterator.hasNext()) {
        collection.add(iterator.next());
    }
}

Sementara itu, jangan lupa bahwa semua koleksi terbatas, sementara Iterable tidak punya janji apa pun. Jika sesuatu Iterable Anda bisa mendapatkan Iterator dan hanya itu.

for (piece : sthIterable){
..........
}

akan diperluas ke:

Iterator it = sthIterable.iterator();
while (it.hasNext()){
    piece = it.next();
..........
}

it.hasNext () tidak diharuskan untuk mengembalikan false. Dengan demikian dalam kasus umum Anda tidak dapat berharap untuk dapat mengkonversi setiap Iterable ke Koleksi. Misalnya Anda dapat mengulangi semua bilangan alami positif, beralih pada sesuatu dengan siklus di dalamnya yang menghasilkan hasil yang sama berulang-ulang, dll.

Jika tidak: Jawaban Atrey cukup baik.

Saya menggunakan FluentIterable.from(myIterable).toList()banyak.

Ini bukan jawaban untuk pertanyaan Anda tetapi saya yakin ini adalah solusi untuk masalah Anda. Antarmuka org.springframework.data.repository.CrudRepositorymemang memiliki metode yang mengembalikan java.lang.Iterabletetapi Anda tidak harus menggunakan antarmuka ini. Alih-alih menggunakan sub antarmuka, dalam kasus Anda org.springframework.data.mongodb.repository.MongoRepository. Antarmuka ini memiliki metode yang mengembalikan objek bertipe java.util.List.

Saya menggunakan utilitas khusus saya untuk melemparkan Koleksi yang ada jika tersedia.

Utama:

public static <T> Collection<T> toCollection(Iterable<T> iterable) {
    if (iterable instanceof Collection) {
        return (Collection<T>) iterable;
    } else {
        return Lists.newArrayList(iterable);
    }
}

Idealnya di atas akan menggunakan ImmutableList, tetapi ImmutableCollection tidak mengizinkan nol yang dapat memberikan hasil yang tidak diinginkan.

Tes:

@Test
public void testToCollectionAlreadyCollection() {
    ArrayList<String> list = Lists.newArrayList(FIRST, MIDDLE, LAST);
    assertSame("no need to change, just cast", list, toCollection(list));
}

@Test
public void testIterableToCollection() {
    final ArrayList<String> expected = Lists.newArrayList(FIRST, null, MIDDLE, LAST);

    Collection<String> collection = toCollection(new Iterable<String>() {
        @Override
        public Iterator<String> iterator() {
            return expected.iterator();
        }
    });
    assertNotSame("a new list must have been created", expected, collection);
    assertTrue(expected + " != " + collection, CollectionUtils.isEqualCollection(expected, collection));
}

Saya menerapkan utilitas serupa untuk semua subtipe Koleksi (Set, Daftar, dll). Saya pikir ini sudah menjadi bagian dari Jambu Biji, tetapi saya belum menemukannya.

Segera setelah Anda menelepon contains, containsAll, equals, hashCode, remove, retainAll, sizeatau toArray, Anda harus melintasi elemen pula.

Jika Anda sesekali hanya memanggil metode seperti isEmptyatau clearsaya kira Anda akan lebih baik dengan membuat koleksi dengan malas. Misalnya, Anda dapat memiliki dukungan ArrayListuntuk menyimpan elemen yang sebelumnya di-iterasi.

Saya tidak tahu ada kelas seperti itu di perpustakaan mana pun, tetapi itu harus menjadi latihan yang cukup sederhana untuk menulis.

Di Java 8 Anda dapat melakukan ini untuk menambahkan semua elemen dari Iterableke Collectiondan mengembalikannya:

public static <T> Collection<T> iterableToCollection(Iterable<T> iterable) {
  Collection<T> collection = new ArrayList<>();
  iterable.forEach(collection::add);
  return collection;
}

Terinspirasi oleh jawaban @Afreys.

Karena RxJava adalah palu dan ini terlihat seperti paku, Anda dapat melakukannya

Observable.from(iterable).toList().toBlocking().single();

Berikut ini SSCCE untuk cara hebat melakukannya di Java 8

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class IterableToCollection {
    public interface CollectionFactory <T, U extends Collection<T>> {
        U createCollection();
    }

    public static <T, U extends Collection<T>> U collect(Iterable<T> iterable, CollectionFactory<T, U> factory) {
        U collection = factory.createCollection();
        iterable.forEach(collection::add);
        return collection;
    }

    public static void main(String[] args) {
        Iterable<Integer> iterable = IntStream.range(0, 5).boxed().collect(Collectors.toList());
        ArrayList<Integer> arrayList = collect(iterable, ArrayList::new);
        HashSet<Integer> hashSet = collect(iterable, HashSet::new);
        LinkedList<Integer> linkedList = collect(iterable, LinkedList::new);
    }
}

Aku datang di situasi yang sama ketika mencoba untuk mengambil sebuah Listdari Projects, daripada default Iterable<T> findAll()dideklarasikan dalam CrudRepositoryinterface. Jadi, di ProjectRepositoryantarmuka saya (yang memanjang dari CrudRepository), saya hanya menyatakan findAll()metode untuk mengembalikan List<Project>bukan Iterable<Project>.

package com.example.projectmanagement.dao;

import com.example.projectmanagement.entities.Project;
import org.springframework.data.repository.CrudRepository;
import java.util.List;

public interface ProjectRepository extends CrudRepository<Project, Long> {

    @Override
    List<Project> findAll();
}

Ini adalah solusi paling sederhana, saya pikir, tanpa memerlukan logika konversi atau penggunaan perpustakaan eksternal.

Dua komentar

1. Tidak perlu mengkonversi Iterable ke Collection untuk menggunakan foreach loop - Iterable dapat digunakan dalam loop tersebut secara langsung, tidak ada perbedaan sintaksis, jadi saya tidak mengerti mengapa pertanyaan awal ditanyakan sama sekali.
2. Cara yang disarankan untuk mengonversi Iterable ke Collection tidak aman (hal yang sama berkaitan dengan CollectionUtils) - tidak ada jaminan bahwa panggilan selanjutnya ke metode berikutnya () mengembalikan instance objek yang berbeda. Apalagi, kekhawatiran ini tidak murni teoretis. Misalnya implementasi Iterable yang digunakan untuk meneruskan nilai ke metode pengurangan Hadoop Reducer selalu mengembalikan contoh nilai yang sama, hanya dengan nilai bidang yang berbeda. Jadi jika Anda menerapkan makeCollection dari atas (atau CollectionUtils.addAll (Iterator)), Anda akan mendapatkan koleksi dengan semua elemen yang identik.

Coba StickyListdari Cactoos :

List<String> list = new StickyList<>(iterable);

Saya tidak melihat solusi satu baris sederhana tanpa dependensi. Saya menggunakan sederhana

List<Users> list;
Iterable<IterableUsers> users = getUsers();

// one line solution
list = StreamSupport.stream(users.spliterator(), true).collect(Collectors.toList());

Anda dapat menggunakan pabrik Eclipse Collections :

Iterable<String> iterable = Arrays.asList("1", "2", "3");

MutableList<String> list = Lists.mutable.withAll(iterable);
MutableSet<String> set = Sets.mutable.withAll(iterable);
MutableSortedSet<String> sortedSet = SortedSets.mutable.withAll(iterable);
MutableBag<String> bag = Bags.mutable.withAll(iterable);
MutableSortedBag<String> sortedBag = SortedBags.mutable.withAll(iterable);

Anda juga dapat mengonversi Iterableke a LazyIterabledan menggunakan metode konverter atau API lain yang tersedia yang tersedia.

Iterable<String> iterable = Arrays.asList("1", "2", "3");
LazyIterable<String> lazy = LazyIterate.adapt(iterable);

MutableList<String> list = lazy.toList();
MutableSet<String> set = lazy.toSet();
MutableSortedSet<String> sortedSet = lazy.toSortedSet();
MutableBag<String> bag = lazy.toBag();
MutableSortedBag<String> sortedBag = lazy.toSortedBag();

Semua Mutabletipe di atas memanjang java.util.Collection.

Catatan: Saya pengendara untuk Eclipse Collections.