Maneira fácil de converter Iterável em Coleção

No meu aplicativo, uso a biblioteca de terceiros (Spring Data for MongoDB para ser exato).

Os métodos desta biblioteca retornam Iterable<T>, enquanto o restante do meu código esperaCollection<T> .

Existe algum método utilitário em algum lugar que me permita converter rapidamente um para o outro? Gostaria de evitar a criação de um monte de foreachloops no meu código para uma coisa tão simples.

Com o Guava, você pode usar Lists.newArrayList (Iterable) ou Sets.newHashSet (Iterable) , entre outros métodos semelhantes. Obviamente, isso copiará todos os elementos na memória. Se isso não é aceitável, acho que seu código que funciona com estes deveria levar Iterableem vez de Collection. A goiaba também fornece métodos convenientes para fazer as coisas que você pode fazer Collectionusando um Iterable(como Iterables.isEmpty(Iterable)ou Iterables.contains(Iterable, Object)), mas as implicações de desempenho são mais óbvias.

No JDK 8+, sem usar nenhuma biblioteca adicional:

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

Edit: O acima é para Iterator. Se você está lidando com Iterable,

iterable.forEach(target::add);

Você também pode escrever seu próprio método utilitário:

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

Solução concisa com Java 8 usando java.util.stream:

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

IteratorUtilsfrom commons-collectionspode ajudar (embora eles não suportem genéricos na versão estável mais recente 3.2.1):

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

A versão 4.0 (que está no SNAPSHOT no momento) suporta genéricos e você pode se livrar do @SuppressWarnings.

Atualização: Verifique IterableAsListno Cactoos .

Da coleçãoUtils :

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

Aqui estão as fontes completas deste método utilitário:

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

Enquanto isso, não esqueça que todas as coleções são finitas, enquanto o Iterable não tem nenhuma promessa. Se algo é iterável, você pode obter um iterador e é isso.

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

será expandido para:

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

Não é necessário que it.hasNext () retorne sempre false. Portanto, no caso geral, você não pode esperar poder converter todos os iteráveis ​​em uma coleção. Por exemplo, você pode repetir todos os números naturais positivos, repetir algo com ciclos que produzem os mesmos resultados repetidamente, etc.

Caso contrário: a resposta de Atrey é bastante boa.

Eu uso FluentIterable.from(myIterable).toList()muito.

Esta não é uma resposta para sua pergunta, mas acredito que seja a solução para o seu problema. A interface org.springframework.data.repository.CrudRepositoryrealmente possui métodos que retornam, java.lang.Iterablemas você não deve usar essa interface. Em vez disso, use sub interfaces, no seu caso org.springframework.data.mongodb.repository.MongoRepository. Essa interface possui métodos que retornam objetos do tipo java.util.List.

Eu uso meu utilitário personalizado para transmitir uma coleção existente, se disponível.

A Principal:

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

Idealmente, o descrito acima usaria ImmutableList, mas ImmutableCollection não permite nulos que podem fornecer resultados indesejáveis.

Testes:

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

Eu implemento utilitários semelhantes para todos os subtipos de coleções (conjunto, lista, etc.). Eu acho que isso já faria parte da goiaba, mas não a encontrei.

Assim que você chama contains, containsAll, equals, hashCode, remove, retainAll, sizeoutoArray , você teria que atravessar os elementos de qualquer maneira.

Se você estiver ocasionalmente chamando métodos como isEmptyou cleareu suponho que você seria melhor criando a coleção preguiçosamente. Você poderia, por exemplo, ter um apoioArrayList para armazenar elementos iterados anteriormente.

Não conheço essa classe em nenhuma biblioteca, mas deve ser um exercício bastante simples de escrever.

No Java 8, você pode fazer isso para adicionar todos os elementos de um Iterablepara Collectione retorná-lo:

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

Inspirado pela resposta @Afreys.

Como o RxJava é um martelo e isso parece um prego, você pode fazer

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

Aqui está um SSCCE para uma ótima maneira de fazer isso no 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);
    }
}

Me deparei com uma situação semelhante ao tentar buscar um Listde Projects, em vez do padrão Iterable<T> findAll()declarado na CrudRepositoryinterface. Então, na minha ProjectRepositoryinterface (que se estende de CrudRepository), simplesmente declarei o findAll()método para retornar um em List<Project>vez de 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();
}

Esta é a solução mais simples, eu acho, sem exigir lógica de conversão ou uso de bibliotecas externas.

Duas observações

1. Não há necessidade de converter Iterable em Collection para usar o loop foreach - o Iterable pode ser usado diretamente nesse loop, não há diferença sintática, portanto, mal entendo por que a pergunta original foi feita.
2. A maneira sugerida de converter Iterável em Coleção não é segura (o mesmo se aplica a CollectionUtils) - não há garantia de que as chamadas subseqüentes ao método next () retornem instâncias de objeto diferentes. Além disso, essa preocupação não é pura teórica. Por exemplo, a implementação iterável usada para passar valores para um método de redução do Hadoop Reducer sempre retorna a mesma instância de valor, apenas com valores de campo diferentes. Portanto, se você aplicar makeCollection a partir de cima (ou CollectionUtils.addAll (Iterator)), você terminará com uma coleção com todos os elementos idênticos.

Experimente StickyListno Cactoos :

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

Não vi uma solução simples de uma linha sem nenhuma dependência. Eu uso simples

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

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

Você pode usar as fábricas do 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);

Você também pode converter Iterablepara para LazyIterablee usar os métodos de conversão ou qualquer uma das outras APIs disponíveis.

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

Todos os Mutabletipos acima se estendem java.util.Collection.

Nota: Sou um colaborador das Coleções Eclipse.