Java 8 JDK kullanarak Yinelenebilir Akışa Dönüştür

Dönen bir arayüz var java.lang.Iterable<T>.

Bu sonucu Java 8 Stream API'sini kullanarak değiştirmek istiyorum.

Ancak yinelenebilir "akış" yapamaz.

Herhangi bir fikrin bir Akış olarak Listeye dönüştürülmeden nasıl kullanılacağı hakkında bir fikriniz var mı?

spliteratorUnknownSizeDoğrudan kullanmaktan çok daha iyi bir cevap var , bu hem daha kolay hem de daha iyi bir sonuç alıyor. Iterablebir spliterator()yöntemi vardır, bu yüzden sadece bölücünüzü almak için bunu kullanmalısınız. En kötü durumda, aynı kod (varsayılan uygulama kullanır spliteratorUnknownSize), ancak Iterablezaten bir koleksiyon olduğunuz daha yaygın durumda, daha iyi bir ayırıcı ve dolayısıyla daha iyi akış performansı (belki de iyi paralellik) elde edersiniz. Ayrıca daha az kod:

StreamSupport.stream(iterable.spliterator(), false)
             .filter(...)
             .moreStreamOps(...);

Gördüğünüz gibi, bir akıştan Iterable(ayrıca bu soruya bakın ) bir akış elde etmek çok acı verici değildir.

Guava kütüphanesini kullanabiliyorsanız, sürüm 21'den beri,

Streams.stream(iterable)

Kolayca bir Streamdışarı Iterableveya oluşturabilirsiniz Iterator:

public static <T> Stream<T> stream(Iterable<T> iterable) {
    return StreamSupport.stream(
        Spliterators.spliteratorUnknownSize(
            iterable.iterator(),
            Spliterator.ORDERED
        ),
        false
    );
}

JOOL kütüphanesini kullanmanızı öneririm , Seq.seq (yinelenebilir) çağrısının arkasındaki ayırıcı sihrini gizler ve ayrıca bir sürü ek kullanışlı işlevsellik sağlar.

Bahsedilen başka bir cevap Guava'nın bunu kullanarak desteği var:

Streams.stream(iterable);

Uygulamanın önerilen diğer cevaplardan biraz farklı bir şey yaptığını vurgulamak istiyorum. Eğer Iterabletür ise, Collectiononlar döküm.

public static <T> Stream<T> stream(Iterable<T> iterable) {
  return (iterable instanceof Collection)
    ? ((Collection<T>) iterable).stream()
    : StreamSupport.stream(iterable.spliterator(), false);
}

public static <T> Stream<T> stream(Iterator<T> iterator) {
  return StreamSupport.stream(
    Spliterators.spliteratorUnknownSize(iterator, 0),
    false
  );
}

Bu sınıfı oluşturdum:

public class Streams {
    /**
     * Converts Iterable to stream
     */
    public static <T> Stream<T>  streamOf(final Iterable<T> iterable) {
        return toStream(iterable, false);
    }

    /**
     * Converts Iterable to parallel stream
     */
    public static <T> Stream<T> parallelStreamOf(final Iterable<T> iterable) {
        return toStream(iterable, true);
    }

    private static <T> Stream<T> toStream(final Iterable<T> iterable, final boolean isParallel) {
        return StreamSupport.stream(iterable.spliterator(), isParallel);
    }
}

Bence mükemmel okunabilir çünkü ayırıcılar ve booleans (isParallel) hakkında düşünmek zorunda değilsiniz.

Bu sorun için çok basit bir çözüm , bir yöntemi tutan bir Streamable<T>arabirim oluşturmaktır .Iterable<T>default <T> stream()

interface Streamable<T> extends Iterable<T> {
    default Stream<T> stream() {
        return StreamSupport.stream(spliterator(), false);
    }
}

Artık herhangi biri yerine Iterable<T>sadece onları beyan ederek akışa açık hale getirilebilir .implements Streamable<T>Iterable<T>

Vavr'ı (eski adıyla Javaslang olarak bilinir) kullanırsanız, bu kadar kolay olabilir:

Iterable i = //...
Stream.ofAll(i);

Java 8 ile ve harici kütüphaneler olmadan bunu yapmanın başka bir yolu:

Stream.concat(collectionA.stream(), collectionB.stream())
      .collect(Collectors.toList())