Un moyen facile de convertir Iterable en Collection

Dans mon application, j'utilise une bibliothèque tierce (Spring Data pour MongoDB pour être exact).

Les méthodes de cette bibliothèque reviennent Iterable<T>, tandis que le reste de mon code attend Collection<T>.

Existe-t-il une méthode utilitaire quelque part qui me permette de convertir rapidement l'une en l'autre? Je voudrais éviter de créer un tas de foreachboucles dans mon code pour une chose aussi simple.

Avec Guava, vous pouvez utiliser Lists.newArrayList (Iterable) ou Sets.newHashSet (Iterable) , entre autres méthodes similaires. Cela copiera bien sûr tous les éléments dans la mémoire. Si ce n'est pas acceptable, je pense que votre code qui fonctionne avec ceux-ci devrait prendre Iterableplutôt que Collection. La goyave fournit également des méthodes pratiques pour faire des choses que vous pouvez faire sur un en Collectionutilisant un Iterable(comme Iterables.isEmpty(Iterable)ou Iterables.contains(Iterable, Object)), mais les implications en termes de performances sont plus évidentes.

Dans JDK 8+, sans utiliser de bibliothèques supplémentaires:

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

Edit: Celui ci-dessus est pour Iterator. Si vous avez affaire à Iterable,

iterable.forEach(target::add);

Vous pouvez également écrire votre propre méthode utilitaire pour cela:

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

Solution concise avec Java 8 utilisant java.util.stream:

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

IteratorUtilsfrom commons-collectionspeut aider (bien qu'ils ne prennent pas en charge les génériques dans la dernière version stable 3.2.1):

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

La version 4.0 (qui est actuellement dans SNAPSHOT) prend en charge les génériques et vous pouvez vous en débarrasser @SuppressWarnings.

Mise à jour: Vérifiez IterableAsListauprès de Cactoos .

De CollectionUtils :

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

Voici les sources complètes de cette méthode utilitaire:

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

Pendant que vous y êtes, n'oubliez pas que toutes les collections sont finies, alors que Iterable n'a aucune promesse. Si quelque chose est itérable, vous pouvez obtenir un itérateur et c'est tout.

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

sera étendu à:

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

it.hasNext () n'est pas obligé de renvoyer false. Ainsi, dans le cas général, vous ne pouvez pas vous attendre à pouvoir convertir chaque Iterable en une collection. Par exemple, vous pouvez itérer sur tous les nombres naturels positifs, itérer sur quelque chose avec des cycles qui produisent les mêmes résultats encore et encore, etc.

Sinon: la réponse d'Atrey est assez bonne.

J'utilise FluentIterable.from(myIterable).toList()beaucoup.

Ce n'est pas une réponse à votre question mais je crois que c'est la solution à votre problème. L'interface a en org.springframework.data.repository.CrudRepositoryeffet des méthodes qui retournent java.lang.Iterablemais vous ne devez pas utiliser cette interface. Utilisez plutôt des sous-interfaces, dans votre cas org.springframework.data.mongodb.repository.MongoRepository. Cette interface possède des méthodes qui renvoient des objets de type java.util.List.

J'utilise mon utilitaire personnalisé pour caster une collection existante si disponible.

Principale:

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

Idéalement, ce qui précède utiliserait ImmutableList, mais ImmutableCollection ne permet pas les valeurs nulles qui peuvent fournir des résultats indésirables.

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

J'implémente des utilitaires similaires pour tous les sous-types de collections (Set, List, etc.). Je pense que ceux-ci feraient déjà partie de la goyave, mais je ne l'ai pas trouvé.

Dès que vous appelez contains, containsAll, equals, hashCode, remove, retainAll, sizeou toArray, vous auriez à traverser les éléments de toute façon.

Si vous n'appelez occasionnellement que des méthodes telles que isEmptyou clearje suppose que vous feriez mieux de créer la collection paresseusement. Vous pouvez par exemple avoir un support ArrayListpour stocker des éléments précédemment itérés.

Je ne connais aucune de ces classes dans aucune bibliothèque, mais ce devrait être un exercice assez simple à rédiger.

En Java 8 , vous pouvez le faire pour ajouter tous les éléments d'un Iterableà Collectionet le retourner:

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

Inspiré par la réponse @Afreys.

Depuis RxJava est un marteau et cela ressemble un peu à un clou, vous pouvez le faire

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

Voici un SSCCE pour un excellent moyen de le faire dans 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);
    }
}

Je suis tombé sur une situation similaire en essayant de récupérer un Listde Projects, plutôt que la valeur par défaut Iterable<T> findAll()déclarée dans l' CrudRepositoryinterface. Donc, dans mon ProjectRepositoryinterface (qui s'étend de CrudRepository), j'ai simplement déclaré la findAll()méthode pour retourner un List<Project>au lieu 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();
}

C'est la solution la plus simple, je pense, sans nécessiter de logique de conversion ni d'utilisation de bibliothèques externes.

Deux remarques

1. Il n'est pas nécessaire de convertir Iterable en Collection pour utiliser chaque boucle - Iterable peut être utilisé directement dans une telle boucle, il n'y a pas de différence syntaxique, donc je comprends à peine pourquoi la question d'origine a été posée.
2. La méthode suggérée pour convertir Iterable en Collection n'est pas sûre (il en va de même pour CollectionUtils) - il n'y a aucune garantie que les appels suivants à la méthode next () renvoient différentes instances d'objet. De plus, cette préoccupation n'est pas purement théorique. Par exemple, l'implémentation itérative utilisée pour transmettre des valeurs à une méthode de réduction de Hadoop Reducer renvoie toujours la même instance de valeur, uniquement avec des valeurs de champ différentes. Donc, si vous appliquez makeCollection d'en haut (ou CollectionUtils.addAll (Iterator)), vous vous retrouverez avec une collection avec tous les éléments identiques.

Essayez StickyListavec Cactoos :

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

Je n'ai pas vu de solution simple sur une seule ligne sans aucune dépendance. J'utilise simplement

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

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

Vous pouvez utiliser les usines 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);

Vous pouvez également convertir le fichier Iterableen un LazyIterableet utiliser les méthodes de conversion ou l'une des autres 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();

Tous les Mutabletypes ci-dessus s'étendent java.util.Collection.

Remarque: je suis un committer pour les collections Eclipse.