Come convertire un iteratore in un flusso?

Sto cercando un modo conciso per convertire un Iteratorin Streamo più specificamente per "visualizzare" l'iteratore come stream.

Per motivi di prestazioni, vorrei evitare una copia dell'iteratore in un nuovo elenco:

Iterator<String> sourceIterator = Arrays.asList("A", "B", "C").iterator();
Collection<String> copyList = new ArrayList<String>();
sourceIterator.forEachRemaining(copyList::add);
Stream<String> targetStream = copyList.stream();

Sulla base di alcuni suggerimenti nei commenti, ho anche cercato di utilizzare Stream.generate:

public static void main(String[] args) throws Exception {
    Iterator<String> sourceIterator = Arrays.asList("A", "B", "C").iterator();
    Stream<String> targetStream = Stream.generate(sourceIterator::next);
    targetStream.forEach(System.out::println);
}

Tuttavia, ottengo un NoSuchElementException(poiché non vi è alcuna chiamata di hasNext)

Exception in thread "main" java.util.NoSuchElementException
    at java.util.AbstractList$Itr.next(AbstractList.java:364)
    at Main$$Lambda$1/1175962212.get(Unknown Source)
    at java.util.stream.StreamSpliterators$InfiniteSupplyingSpliterator$OfRef.tryAdvance(StreamSpliterators.java:1351)
    at java.util.Spliterator.forEachRemaining(Spliterator.java:326)
    at java.util.stream.ReferencePipeline$Head.forEach(ReferencePipeline.java:580)
    at Main.main(Main.java:20)

Ho guardato StreamSupporte Collectionsnon ho trovato nulla.

Un modo è quello di creare uno Spliterator da Iterator e utilizzarlo come base per il tuo stream:

Iterator<String> sourceIterator = Arrays.asList("A", "B", "C").iterator();
Stream<String> targetStream = StreamSupport.stream(
          Spliterators.spliteratorUnknownSize(sourceIterator, Spliterator.ORDERED),
          false);

Un'alternativa forse più leggibile è usare un Iterable - e creare un Iterable da un Iterator è molto facile con lambdas perché Iterable è un'interfaccia funzionale:

Iterator<String> sourceIterator = Arrays.asList("A", "B", "C").iterator();

Iterable<String> iterable = () -> sourceIterator;
Stream<String> targetStream = StreamSupport.stream(iterable.spliterator(), false);

Dalla versione 21, fornisce la libreria Guava Streams.stream(iterator)

Si fa quello @ assylias 's risposta spettacoli .

Ottimo consiglio! Ecco la mia versione riutilizzabile:

public class StreamUtils {

    public static <T> Stream<T> asStream(Iterator<T> sourceIterator) {
        return asStream(sourceIterator, false);
    }

    public static <T> Stream<T> asStream(Iterator<T> sourceIterator, boolean parallel) {
        Iterable<T> iterable = () -> sourceIterator;
        return StreamSupport.stream(iterable.spliterator(), parallel);
    }
}

E utilizzo (assicurati di importare staticamente come stream):

List<String> aPrefixedStrings = asStream(sourceIterator)
                .filter(t -> t.startsWith("A"))
                .collect(toList());

Questo è possibile in Java 9.

Stream.generate(() -> null)
    .takeWhile(x -> iterator.hasNext())
    .map(n -> iterator.next())
    .forEach(System.out::println);

Crea Spliteratordalla classe di Iteratorutilizzo Spliteratorscontiene più di una funzione per la creazione di spliterator, ad esempio sto usando spliteratorUnknownSizequale sta ottenendo iterator come parametro, quindi crea Stream usandoStreamSupport

Spliterator<Model> spliterator = Spliterators.spliteratorUnknownSize(
        iterator, Spliterator.NONNULL);
Stream<Model> stream = StreamSupport.stream(spliterator, false);

import com.google.common.collect.Streams;

e usa Streams.stream(iterator):

Streams.stream(iterator)
       .map(v-> function(v))
       .collect(Collectors.toList());

Un altro modo per farlo su Java 9+ usando Stream :: iterate (T, Predicate, UnaryOperator) :

Stream.iterate(iterator, Iterator::hasNext, UnaryOperator.identity())
        .map(Iterator::next)
        .forEach(System.out::println);

Uso Collections.list(iterator).stream()...