Converti Iterator in ArrayList

Dato Iterator<Element>, come possiamo convertire tale Iteratora ArrayList<Element>(o List<Element>) nella migliore e più veloce modo possibile, in modo che possiamo usare ArrayLists' operazioni su di esso, come get(index), add(element)ecc

Meglio usare una libreria come Guava :

import com.google.common.collect.Lists;

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

Un altro esempio di Guava:

ImmutableList.copyOf(myIterator);

o collezioni Apache Commons :

import org.apache.commons.collections.IteratorUtils;

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

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

In Java 8, è possibile utilizzare il nuovo forEachRemainingmetodo che è stato aggiunto Iteratorall'interfaccia:

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

Puoi copiare un iteratore in un nuovo elenco come questo:

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

Ciò presuppone che l'elenco contenga stringhe. Non c'è davvero un modo più veloce per ricreare un elenco da un iteratore, sei bloccato nel attraversarlo a mano e copiare ogni elemento in un nuovo elenco del tipo appropriato.

MODIFICARE :

Ecco un metodo generico per copiare un iteratore in un nuovo elenco in modo sicuro:

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

Usalo in questo modo:

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]

Nota che c'è una differenza tra Iterablee Iterator.

Se ne hai uno Iterable, allora con Java 8 puoi usare questa soluzione:

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

Come so Collectors.toList()crea ArrayLististanza.

In realtà a mio avviso, sembra anche buono in una riga.
Ad esempio se è necessario tornare List<Element>da un metodo:

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

Puoi anche usare IteratorUtilsda commons-collection di Apache , sebbene non supporti generici:

List list = IteratorUtils.toList(iterator);

Soluzione piuttosto concisa con Java 8 semplice usando 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());
}

Prova StickyListda Cactoos :

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

Disclaimer: sono uno degli sviluppatori.

Ecco un one-liner che utilizza Stream

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

Voglio solo sottolineare una soluzione apparentemente ovvia che NON funzionerà:

Elenco elenco = Stream.generate (iteratore :: successivo)
    .Raccogliere (Collectors.toList ());

Questo perché Stream#generate(Supplier<T>)può creare solo flussi infiniti, non si aspetta che il suo argomento venga lanciato NoSuchElementException(questo è ciò Iterator#next()che farà alla fine).

La risposta di xehpuk dovrebbe essere usata invece se il modo Iteratore → Stream → Elenco è la tua scelta.

usa google guava !

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

++

Qui in questo caso, se si desidera il modo più veloce possibile, allora for loopè meglio.

L'iteratore su una dimensione del campione di 10,000 runstake prende 40 mscome per loop2 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));  

Ciò presuppone che l'elenco contenga stringhe.