Convertir l'itérateur en ArrayList

Étant donné Iterator<Element>, comment pouvons - nous le convertir Iteratorà ArrayList<Element>(ou List<Element>) dans le meilleur et le plus rapide façon possible, afin que nous puissions utiliser les ArrayListopérations de sur elle, comme get(index), add(element), etc.

Mieux vaut utiliser une bibliothèque comme Guava :

import com.google.common.collect.Lists;

Iterator<Element> myIterator = ... //some iterator
List<Element> myList = Lists.newArrayList(myIterator);

Un autre exemple de goyave:

ImmutableList.copyOf(myIterator);

ou Collections Apache Commons :

import org.apache.commons.collections.IteratorUtils;

Iterator<Element> myIterator = ...//some iterator

List<Element> myList = IteratorUtils.toList(myIterator);       

Dans Java 8, vous pouvez utiliser la nouvelle forEachRemainingméthode qui a été ajoutée à l' Iteratorinterface:

List<Element> list = new ArrayList<>();
iterator.forEachRemaining(list::add);

Vous pouvez copier un itérateur dans une nouvelle liste comme celle-ci:

Iterator<String> iter = list.iterator();
List<String> copy = new ArrayList<String>();
while (iter.hasNext())
    copy.add(iter.next());

Cela suppose que la liste contient des chaînes. Il n'y a vraiment pas de moyen plus rapide de recréer une liste à partir d'un itérateur, vous êtes obligé de le parcourir à la main et de copier chaque élément dans une nouvelle liste du type approprié.

ÉDITER :

Voici une méthode générique pour copier un itérateur dans une nouvelle liste de manière sécurisée:

public static <T> List<T> copyIterator(Iterator<T> iter) {
    List<T> copy = new ArrayList<T>();
    while (iter.hasNext())
        copy.add(iter.next());
    return copy;
}

Utilisez-le comme ceci:

List<String> list = Arrays.asList("1", "2", "3");
Iterator<String> iter = list.iterator();
List<String> copy = copyIterator(iter);
System.out.println(copy);
> [1, 2, 3]

Notez qu'il y a une différence entre Iterableet Iterator.

Si vous en avez un Iterable, alors avec Java 8, vous pouvez utiliser cette solution:

Iterable<Element> iterable = createIterable();
List<Element> array = StreamSupport
    .stream(iterable.spliterator(), false)
    .collect(Collectors.toList());

Comme je sais, Collectors.toList()crée une ArrayListinstance.

En fait, à mon avis, cela semble également bien sur une seule ligne.
Par exemple, si vous devez revenir List<Element>d'une méthode:

return StreamSupport.stream(iter.spliterator(), false).collect(Collectors.toList());

Vous pouvez également utiliser à IteratorUtilspartir d'Apache commons-collections , bien qu'il ne prenne pas en charge les génériques:

List list = IteratorUtils.toList(iterator);

Solution assez concise avec Java 8 simple en utilisant java.util.stream:

public static <T> ArrayList<T> toArrayList(final Iterator<T> iterator) {
    return StreamSupport
        .stream(
            Spliterators
                .spliteratorUnknownSize(iterator, Spliterator.ORDERED), false)
        .collect(
                Collectors.toCollection(ArrayList::new)
    );
}

List result = new ArrayList();
while (i.hasNext()){
    result.add(i.next());
}

Essayez StickyListavec Cactoos :

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

Avertissement: je suis l'un des développeurs.

Voici une ligne à l'aide de Streams

Iterator<?> iterator = ...
List<?> list = StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, 0), false)
                .collect(Collectors.toList());

Je veux juste souligner une solution apparemment évidente qui ne sera PAS fonctionnera :

Liste liste = Stream.generate (itérateur :: suivant)
    .collect (Collectors.toList ());

C'est parce que Stream#generate(Supplier<T>)ne peut créer que des flux infinis, il ne s'attend pas à ce que son argument lance NoSuchElementException(c'est ce queIterator#next() qui fera à la fin).

La réponse du xehpuk doit être utilisée à la place si la méthode Iterator → Stream → List est votre choix.

utilisez google guava !

Iterable<String> fieldsIterable = ...
List<String> fields = Lists.newArrayList(fieldsIterable);

++

Ici, dans ce cas, si vous voulez le moyen le plus rapide possible, for loopc'est mieux.

L'itérateur sur une taille d'échantillon de 10,000 runsprises 40 msoù comme pour les boucles2 ms

        ArrayList<String> alist = new ArrayList<String>();  
        long start, end;  

        for (int i = 0; i < 1000000; i++) {  
            alist.add(String.valueOf(i));  
        }  

        ListIterator<String> it = alist.listIterator();      

        start = System.currentTimeMillis();  
        while (it.hasNext()) {  
            String s = it.next();  
        }  
        end = System.currentTimeMillis();  

        System.out.println("Iterator start: " + start + ", end: " + end + ", delta: "  
            + (end - start));  
        start = System.currentTimeMillis();  
        int ixx = 0;  
        for (int i = 0; i < 100000; i++) {  
            String s = alist.get(i);  
        }  

        System.out.println(ixx);  
        end = System.currentTimeMillis();  
        System.out.println("for loop start: " + start + ", end: " + end + ", delta: "  
            + (end - start));  

Cela suppose que la liste contient des chaînes.