Einfache Möglichkeit, Iterable in Collection umzuwandeln

In meiner Anwendung verwende ich eine Bibliothek von Drittanbietern (Spring Data für MongoDB um genau zu sein).

Die Methoden dieser Bibliothek kehren zurück Iterable<T>, während der Rest meines Codes dies erwartetCollection<T> .

Gibt es irgendwo eine Dienstprogrammmethode, mit der ich schnell eine in die andere konvertieren kann? Ich möchte vermeiden, foreachfür eine so einfache Sache eine Reihe von Schleifen in meinem Code zu erstellen .

Mit Guava können Sie unter anderem Lists.newArrayList (Iterable) oder Sets.newHashSet (Iterable) verwenden. Dadurch werden natürlich alle Elemente in den Speicher kopiert. Wenn das nicht akzeptabel ist, sollte Ihr Code, der mit diesen funktioniert, Iterableeher als nehmen Collection. Guava bietet auch bequeme Methoden, um Dinge zu tun, die Sie Collectionmit einem Iterable(wie Iterables.isEmpty(Iterable)oder Iterables.contains(Iterable, Object)) tun können , aber die Auswirkungen auf die Leistung sind offensichtlicher.

In JDK 8+ ohne Verwendung zusätzlicher Bibliotheken:

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

Bearbeiten: Das obige ist für Iterator. Wenn Sie es zu tun haben Iterable,

iterable.forEach(target::add);

Sie können auch hierfür Ihre eigene Dienstprogrammmethode schreiben:

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

Prägnante Lösung mit Java 8 mit java.util.stream:

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

IteratorUtilsfrom commons-collectionskann helfen (obwohl sie in der neuesten stabilen Version 3.2.1 keine Generika unterstützen):

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

Version 4.0 (die derzeit in SNAPSHOT enthalten ist) unterstützt Generika, und Sie können die Version entfernen @SuppressWarnings.

Update: Überprüfen Sie IterableAsListvon Cactoos .

Aus CollectionUtils :

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

Hier sind die vollständigen Quellen dieser Dienstprogrammmethode:

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

Vergessen Sie dabei nicht, dass alle Sammlungen endlich sind, während Iterable keinerlei Versprechen hat. Wenn etwas iterierbar ist, können Sie einen Iterator bekommen und das ist es.

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

wird erweitert auf:

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

it.hasNext () muss niemals false zurückgeben. Daher können Sie im allgemeinen Fall nicht erwarten, dass Sie jedes Iterable in eine Sammlung konvertieren können. Sie können beispielsweise alle positiven natürlichen Zahlen durchlaufen, etwas mit Zyklen durchlaufen, die immer wieder dieselben Ergebnisse liefern usw.

Ansonsten: Atreys Antwort ist ganz gut.

Ich benutze FluentIterable.from(myIterable).toList()viel.

Dies ist keine Antwort auf Ihre Frage, aber ich glaube, es ist die Lösung für Ihr Problem. Die Schnittstelle org.springframework.data.repository.CrudRepositoryverfügt tatsächlich über Methoden, die zurückkehrenjava.lang.Iterable , Sie sollten diese Schnittstelle jedoch nicht verwenden. Verwenden Sie in Ihrem Fall stattdessen Subschnittstellen org.springframework.data.mongodb.repository.MongoRepository. Diese Schnittstelle verfügt über Methoden, die Objekte vom Typ zurückgeben java.util.List.

Ich verwende mein benutzerdefiniertes Dienstprogramm, um eine vorhandene Sammlung zu übertragen, falls verfügbar.

Main:

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

Im Idealfall wird ImmutableList verwendet, ImmutableCollection lässt jedoch keine Nullen zu, die zu unerwünschten Ergebnissen führen können.

Tests:

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

Ich implementiere ähnliche Dienstprogramme für alle Untertypen von Sammlungen (Set, List usw.). Ich würde denken, dass diese bereits Teil von Guava sind, aber ich habe sie nicht gefunden.

Sobald Sie rufen contains, containsAll, equals, hashCode, remove, retainAll, sizeoder toArraywürden Sie die Elemente ohnehin durchqueren müssen.

Wenn Sie gelegentlich nur Methoden wie isEmptyoder aufrufen, ist cleares wahrscheinlich besser, wenn Sie die Sammlung träge erstellen. Sie könnten beispielsweise einen Hintergrund ArrayListzum Speichern zuvor iterierter Elemente haben.

Ich kenne keine solche Klasse in einer Bibliothek, aber es sollte eine ziemlich einfache Übung sein, sie aufzuschreiben.

In Java 8 können Sie dies tun, um alle Elemente von einem Iterablebis hinzuzufügen Collectionund zurückzugeben:

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

Inspiriert von @Afreys Antwort.

Da RxJava ein Hammer ist und dies irgendwie wie ein Nagel aussieht, können Sie dies tun

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

Hier ist eine SSCCE für eine großartige Möglichkeit, dies in Java 8 zu tun

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

Zwei Bemerkungen

1. Es ist nicht erforderlich, Iterable in Collection zu konvertieren, um foreach-Schleife zu verwenden. Iterable kann in einer solchen Schleife direkt verwendet werden. Es gibt keinen syntaktischen Unterschied. Daher verstehe ich kaum, warum die ursprüngliche Frage überhaupt gestellt wurde.
2. Die vorgeschlagene Methode zum Konvertieren von Iterable in Collection ist unsicher (dasselbe gilt für CollectionUtils). Es gibt keine Garantie dafür, dass nachfolgende Aufrufe der next () -Methode unterschiedliche Objektinstanzen zurückgeben. Darüber hinaus ist dieses Anliegen nicht rein theoretisch. Beispielsweise gibt eine iterierbare Implementierung, die zum Übergeben von Werten an eine Reduktionsmethode von Hadoop Reducer verwendet wird, immer dieselbe Wertinstanz zurück, nur mit unterschiedlichen Feldwerten. Wenn Sie also makeCollection von oben (oder CollectionUtils.addAll (Iterator)) anwenden, erhalten Sie eine Sammlung mit allen identischen Elementen.

Versuchen StickyListvon Cactoos :

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

Ich habe keine einfache einzeilige Lösung ohne Abhängigkeiten gesehen. Ich benutze einfach

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

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

Ich bin auf eine ähnliche Situation gestoßen , als ich versucht habe, ein Listvon Projects abzurufen , anstatt den Iterable<T> findAll()in der CrudRepositorySchnittstelle deklarierten Standard . Also habe ich in meiner ProjectRepositorySchnittstelle (die sich von erstreckt CrudRepository) einfach die findAll()Methode deklariert , um a List<Project>anstelle von zurückzugeben 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();
}

Ich denke, dies ist die einfachste Lösung, ohne dass eine Konvertierungslogik oder die Verwendung externer Bibliotheken erforderlich ist.

Sie können Eclipse Collections- Fabriken verwenden:

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

Sie können die auch konvertieren Iterable zu ein LazyIterableund das Konverter - Verfahren oder eine der anderen verfügbaren APIs zur Verfügung verwenden.

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

Alle oben genannten MutableTypen erstrecken sich java.util.Collection.

Hinweis: Ich bin ein Committer für Eclipse-Sammlungen.