Łatwy sposób przekonwertować Iterable na Collection

W mojej aplikacji korzystam z biblioteki innej firmy (dokładniej Spring Data dla MongoDB).

Metody tej biblioteki zwracają się Iterable<T>, podczas gdy reszta mojego kodu oczekuje Collection<T>.

Czy jest gdzieś jakaś metoda narzędziowa, która pozwoli mi szybko przekonwertować jedną na drugą? Chciałbym uniknąć tworzenia kilkuforeach pęków w moim kodzie dla tak prostej rzeczy.

Z Guava możesz użyć Lists.newArrayList (Iterable) lub Sets.newHashSet (Iterable) , wśród innych podobnych metod. To oczywiście skopiuje wszystkie elementy do pamięci. Jeśli to nie jest dopuszczalne, uważam, że twój kod, który z nimi współpracuje, powinien Iterableraczej zająć niż Collection. Zdarza się również, że Guava zapewnia wygodne metody robienia rzeczy, które można wykonać za Collectionpomocą Iterable(takich jak Iterables.isEmpty(Iterable)lub Iterables.contains(Iterable, Object)), ale implikacje dotyczące wydajności są bardziej oczywiste.

W JDK 8+, bez korzystania z dodatkowych bibliotek:

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

Edycja: Powyższy jest dla Iterator. Jeśli masz do czynienia Iterable,

iterable.forEach(target::add);

Możesz również napisać własną metodę narzędzia:

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

Zwięzłe rozwiązanie z Javą 8 przy użyciu java.util.stream:

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

IteratorUtilsz commons-collectionsmoże pomóc (chociaż nie obsługują one generycznych w najnowszej stabilnej wersji 3.2.1):

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

Wersja 4.0 (która jest obecnie w SNAPSHOT) obsługuje generyczne i możesz się ich pozbyć @SuppressWarnings .

Aktualizacja: Sprawdź IterableAsListod Cactoos .

Z kolekcjiUtils :

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

Oto pełne źródła tej metody narzędzia:

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

Nie zapominając o tym, że wszystkie kolekcje są skończone, a Iterable nie ma żadnych obietnic. Jeśli coś jest Iterowalne, możesz dostać Iterator i to wszystko.

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

zostanie rozszerzony do:

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

it.hasNext () nie musi nigdy zwracać wartości false. Dlatego w ogólnym przypadku nie można oczekiwać, że będzie można przekonwertować każdy Iterable na kolekcję. Na przykład możesz iterować po wszystkich dodatnich liczbach naturalnych, iterować po czymś z cyklami, które dają te same wyniki w kółko itp.

W przeciwnym razie odpowiedź Atrey jest całkiem dobra.

Używam FluentIterable.from(myIterable).toList()dużo.

To nie jest odpowiedź na twoje pytanie, ale uważam, że jest to rozwiązanie twojego problemu. Interfejs org.springframework.data.repository.CrudRepositoryrzeczywiście ma metody, które zwracają, java.lang.Iterableale nie powinieneś używać tego interfejsu. Zamiast tego, w twoim przypadku, użyj interfejsów podrzędnych org.springframework.data.mongodb.repository.MongoRepository. Ten interfejs ma metody zwracające obiekty typu java.util.List.

Używam mojego niestandardowego narzędzia, by rzutować istniejącą kolekcję, jeśli jest dostępna.

Główny:

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

Idealnie powyższe użyłoby ImmutableList, ale ImmutableCollection nie dopuszcza wartości zerowych, które mogą dawać niepożądane wyniki.

Testy:

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

Implementuję podobne narzędzia dla wszystkich podtypów kolekcji (zestaw, lista itp.). Sądzę, że byłyby już częścią Guawy, ale nie znalazłem tego.

Jak najszybciej zadzwonić contains, containsAll, equals, hashCode, remove, retainAll, sizelubtoArray , że pan musiał przemierzać elementy tak.

Jeśli od czasu do czasu wywołujesz tylko metody takie jak isEmptylub clear, przypuszczam, że lepiej byłoby, gdybyś utworzył kolekcję leniwie. Możesz na przykład mieć wsparcieArrayList do przechowywania wcześniej iterowanych elementów.

Nie znam żadnej takiej klasy w żadnej bibliotece, ale napisanie jej powinno być dość prostym ćwiczeniem.

W Javie 8 możesz to zrobić, aby dodać wszystkie elementy od Iterabledo Collectioni zwrócić:

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

Zainspirowany odpowiedzią @Afreys.

Ponieważ RxJava jest młotkiem, a ten rodzaj przypomina gwóźdź, możesz to zrobić

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

Oto SSCCE za świetny sposób na zrobienie tego w Javie 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);
    }
}

Dwie uwagi

1. Aby korzystać z pętli foreach, nie trzeba konwertować Iterable na Collection - Iterable można stosować bezpośrednio w takiej pętli, nie ma różnicy składniowej, więc prawie nie rozumiem, dlaczego zadano pierwotne pytanie.
2. Sugerowany sposób konwersji Iterable na Collection jest niebezpieczny (to samo dotyczy CollectionUtils) - nie ma gwarancji, że kolejne wywołania metody next () zwrócą różne instancje obiektów. Co więcej, obawa ta nie jest czysto teoretyczna. Na przykład implementacja iteracyjna używana do przekazywania wartości do metody redukcji Hadoop Reducer zawsze zwraca tę samą instancję wartości, tylko z różnymi wartościami pola. Więc jeśli zastosujesz makeCollection z góry (lub CollectionUtils.addAll (Iterator)), otrzymasz kolekcję ze wszystkimi identycznymi elementami.

Natknąłem się w podobnej sytuacji, starając się sprowadzić Listz ProjectS, raczej niż domyślne Iterable<T> findAll()zadeklarowane w CrudRepositoryinterfejsie. Tak więc w moim ProjectRepositoryinterfejsie (który rozszerza się CrudRepository) po prostu zadeklarowałem findAll()metodę zwrócenia List<Project>zamiast 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();
}

To chyba najprostsze rozwiązanie, które nie wymaga logiki konwersji ani korzystania z zewnętrznych bibliotek.

Spróbuj StickyListz Cactoos :

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

Nie widziałem prostego rozwiązania jednoliniowego bez żadnych zależności. Jestem prosty w użyciu

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

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

Możesz korzystać z fabryk kolekcji Eclipse :

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

Możesz także przekonwertować na Iterablea LazyIterablei użyć metod konwertera lub dowolnego innego dostępnego API.

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

Wszystkie powyższe Mutabletypy rozszerzają się java.util.Collection.

Uwaga: jestem osobą odpowiedzialną za kolekcje Eclipse.