Modo semplice per convertire Iterable in Collection

Nella mia applicazione utilizzo una libreria di terze parti (i dati di primavera per MongoDB per l'esattezza).

I metodi di questa libreria ritornano Iterable<T>, mentre il resto del mio codice si aspettaCollection<T> .

Esiste un metodo di utilità da qualche parte che mi permetta di convertire rapidamente l'uno nell'altro? Vorrei evitare di creare un mucchio di foreachloop nel mio codice per una cosa così semplice.

Con Guava puoi usare Lists.newArrayList (Iterable) o Sets.newHashSet (Iterable) , tra altri metodi simili. Questo ovviamente copierà tutti gli elementi in memoria. Se questo non è accettabile, penso che il tuo codice che funziona con questi dovrebbe prendere Iterablepiuttosto che Collection. Guava fornisce anche metodi convenienti per fare cose che puoi fare Collectionsull'uso di Iterable(come Iterables.isEmpty(Iterable)o Iterables.contains(Iterable, Object)), ma le implicazioni sulle prestazioni sono più ovvie.

In JDK 8+, senza utilizzare librerie aggiuntive:

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

Modifica: quello sopra è per Iterator. Se hai a che fare Iterable,

iterable.forEach(target::add);

Puoi anche scrivere il tuo metodo di utilità per questo:

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

Soluzione concisa con Java 8 utilizzando java.util.stream:

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

IteratorUtilsda commons-collectionspuò aiutare (anche se non supportano generici nell'ultima versione stabile 3.2.1):

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

La versione 4.0 (che è in SNAPSHOT in questo momento) supporta generici e puoi sbarazzarti di @SuppressWarnings .

Aggiornamento: controllare IterableAsListda Cactoos .

Da CollectionUtils :

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

Ecco le fonti complete di questo metodo di utilità:

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

Durante questo, non dimenticare che tutte le collezioni sono limitate, mentre Iterable non ha promesse di sorta. Se qualcosa è Iterabile puoi ottenere un Iteratore e basta.

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

sarà esteso a:

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

it.hasNext () non è necessario per restituire mai false. Quindi, nel caso generale, non puoi aspettarti di poter convertire ogni Iterable in una Collezione. Ad esempio puoi iterare su tutti i numeri naturali positivi, iterare su qualcosa con cicli in esso che producono gli stessi risultati più e più volte, ecc.

Altrimenti: la risposta di Atrey è abbastanza buona.

Ne uso FluentIterable.from(myIterable).toList()molto.

Questa non è una risposta alla tua domanda, ma credo che sia la soluzione al tuo problema. L'interfaccia org.springframework.data.repository.CrudRepositoryha davvero dei metodi che ritornano java.lang.Iterablema non dovresti usare questa interfaccia. Usa invece interfacce secondarie, nel tuo caso org.springframework.data.mongodb.repository.MongoRepository. Questa interfaccia ha metodi che restituiscono oggetti di tipo java.util.List.

Uso la mia utility personalizzata per trasmettere una raccolta esistente, se disponibile.

Principale:

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

Idealmente quanto sopra dovrebbe utilizzare ImmutableList, ma ImmutableCollection non consente valori nulli che possono fornire risultati indesiderati.

test:

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

Implemento utilità simili per tutti i sottotipi di Collezioni (Set, Elenco, ecc.). Penserei che questi sarebbero già parte di Guava, ma non l'ho trovato.

Non appena si chiami contains, containsAll, equals, hashCode, remove, retainAll, sizeotoArray , che avrebbe dovuto attraversare gli elementi in ogni caso.

Se di tanto in tanto chiami solo metodi come isEmptyo clearsuppongo che sarebbe meglio creare pigramente la raccolta. Ad esempio, potresti avere un sostegnoArrayList per la memorizzazione di elementi precedentemente ripetuti.

Non conosco nessuna di queste classi in nessuna biblioteca, ma dovrebbe essere un esercizio abbastanza semplice da scrivere.

In Java 8 puoi farlo per aggiungere tutti gli elementi da un Iterablea Collectione restituirlo:

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

Ispirato dalla risposta @Afreys.

Poiché RxJava è un martello e questo tipo di chiodo sembra un chiodo, puoi farlo

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

Ecco un SSCCE per un ottimo modo per farlo in 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);
    }
}

Mi sono imbattuto in una situazione simile durante il tentativo di recuperare a Listof Projects, anziché il valore predefinito Iterable<T> findAll()dichiarato CrudRepositorynell'interfaccia. Quindi, nella mia ProjectRepositoryinterfaccia (che si estende da CrudRepository), ho semplicemente dichiarato il findAll()metodo per restituire un List<Project>invece di 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();
}

Questa è la soluzione più semplice, credo, senza richiedere la logica di conversione o l'utilizzo di librerie esterne.

Due osservazioni

1. Non è necessario convertire Iterable in Collection per utilizzare foreach loop - Iterable può essere utilizzato direttamente in tale loop, non esiste alcuna differenza sintattica, quindi non capisco perché la domanda originale sia stata posta.
2. Il modo suggerito per convertire Iterable in Collection non è sicuro (lo stesso si riferisce a CollectionUtils) - non vi è alcuna garanzia che le chiamate successive al metodo next () restituiscano istanze di oggetti diverse. Inoltre, questa preoccupazione non è pura teoria. Ad esempio l'implementazione Iterable utilizzata per passare valori a un metodo di riduzione di Hadoop Reducer restituisce sempre la stessa istanza di valore, solo con valori di campo diversi. Quindi se applichi makeCollection dall'alto (o CollectionUtils.addAll (Iteratore)) finirai con una raccolta con tutti gli elementi identici.

Prova StickyListda Cactoos :

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

Non ho visto una soluzione a una riga semplice senza dipendenze. Io uso semplice

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

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

Puoi utilizzare le fabbriche di 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);

Puoi anche convertire il file Iterablein a LazyIterablee utilizzare i metodi di conversione o una qualsiasi delle altre API disponibili disponibili.

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

Tutti i Mutabletipi di cui sopra si estendonojava.util.Collection .

Nota: sono un committer per le raccolte Eclipse.