Manera fácil de convertir Iterable a Collection

En mi aplicación utilizo una biblioteca de terceros (Spring Data para MongoDB para ser exactos).

Los métodos de esta biblioteca regresan Iterable<T>, mientras que el resto de mi código espera Collection<T>.

¿Hay algún método de utilidad en algún lugar que me permita convertir rápidamente uno a otro? Me gustaría evitar crear un montón de foreachbucles en mi código para algo tan simple.

Con Guava puede usar Lists.newArrayList (Iterable) o Sets.newHashSet (Iterable) , entre otros métodos similares. Por supuesto, esto copiará todos los elementos en la memoria. Si eso no es aceptable, creo que su código que funciona con estos debería tomar en Iterablelugar de Collection. La guayaba también proporciona métodos convenientes para hacer cosas que puede hacer Collectionusando un Iterable(como Iterables.isEmpty(Iterable)o Iterables.contains(Iterable, Object)), pero las implicaciones de rendimiento son más obvias.

En JDK 8+, sin usar ninguna biblioteca adicional:

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

Editar: El anterior es para Iterator. Si se trata de Iterable,

iterable.forEach(target::add);

También puede escribir su propio método de utilidad para esto:

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

Solución concisa con 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());
}

IteratorUtilsde commons-collectionsayudar a mayo (a pesar de que no son compatibles con los genéricos en la última versión estable 3.2.1):

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

La versión 4.0 (que está en SNAPSHOT en este momento) admite genéricos y puede deshacerse de ellos @SuppressWarnings.

Actualización: Verificación IterableAsListde Cactoos .

De CollectionUtils :

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

Aquí están las fuentes completas de este método de utilidad:

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

Mientras lo hace, no olvide que todas las colecciones son finitas, mientras que Iterable no tiene promesas de ningún tipo. Si algo es Iterable, puede obtener un Iterator y eso es todo.

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

se ampliará a:

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

it.hasNext () no está obligado a devolver false. Por lo tanto, en el caso general, no puede esperar poder convertir cada Iterable en una Colección. Por ejemplo, puede iterar sobre todos los números naturales positivos, iterar sobre algo con ciclos que produzca los mismos resultados una y otra vez, etc.

De lo contrario: la respuesta de Atrey está bastante bien.

Yo uso FluentIterable.from(myIterable).toList()mucho

Esta no es una respuesta a su pregunta, pero creo que es la solución a su problema. La interfaz org.springframework.data.repository.CrudRepositorytiene métodos que regresan, java.lang.Iterablepero no debe usar esta interfaz. En su lugar, use sub interfaces, en su caso org.springframework.data.mongodb.repository.MongoRepository. Esta interfaz tiene métodos que devuelven objetos de tipo java.util.List.

Uso mi utilidad personalizada para emitir una Colección existente si está disponible.

Principal:

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

Idealmente, lo anterior usaría ImmutableList, pero ImmutableCollection no permite valores nulos que pueden proporcionar resultados no deseados.

Pruebas:

@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 utilidades similares para todos los subtipos de Colecciones (Conjunto, Lista, etc.). Creo que estos ya serían parte de Guava, pero no lo he encontrado.

Tan pronto como usted lo llama contains, containsAll, equals, hashCode, remove, retainAll, sizeo toArray, tendría que atravesar los elementos de todos modos.

Si ocasionalmente solo llama a métodos como isEmptyo clearsupongo que sería mejor crear la colección de manera perezosa. Por ejemplo, podría tener un respaldo ArrayListpara almacenar elementos iterados previamente.

No conozco ninguna clase de este tipo en ninguna biblioteca, pero debería ser un ejercicio bastante simple de escribir.

En Java 8 puede hacer esto para agregar todos los elementos de un Iterableto Collectiony devolverlo:

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

Inspirado por la respuesta de @Afreys.

Como RxJava es un martillo y parece un clavo, puedes hacer

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

Aquí hay un SSCCE para una excelente manera de hacer esto en 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);
    }
}

Encontré una situación similar al intentar obtener una Listde Projects, en lugar del valor predeterminado Iterable<T> findAll()declarado en la CrudRepositoryinterfaz. Entonces, en mi ProjectRepositoryinterfaz (que se extiende desde CrudRepository), simplemente declaró que el findAll()método devolvería un en List<Project>lugar 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 es la solución más simple, creo, sin requerir la lógica de conversión o el uso de bibliotecas externas.

Dos observaciones

1. No es necesario convertir Iterable en Collection para usar el bucle foreach: Iterable se puede usar en dicho bucle directamente, no hay diferencia sintáctica, por lo que apenas entiendo por qué se hizo la pregunta original.
2. La forma sugerida de convertir Iterable a Collection no es segura (lo mismo se refiere a CollectionUtils): no hay garantía de que las llamadas posteriores al método next () devuelvan diferentes instancias de objeto. Además, esta preocupación no es puramente teórica. Por ejemplo, la implementación Iterable utilizada para pasar valores a un método de reducción de Hadoop Reducer siempre devuelve la misma instancia de valor, solo con valores de campo diferentes. Entonces, si aplica makeCollection desde arriba (o CollectionUtils.addAll (Iterator)) terminará con una colección con todos los elementos idénticos.

Probar StickyListde Cactoos :

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

No vi una solución simple de una línea sin ninguna dependencia. Yo uso simple

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

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

Puede usar las fábricas de 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);

También puede convertir Iterablea ay LazyIterableusar los métodos de conversión o cualquiera de las otras API disponibles disponibles.

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 los Mutabletipos anteriores se extienden java.util.Collection.

Nota: Soy un committer para Eclipse Collections.