イテレータ<E>から無限のストリーム<E>を作成するにはどうすればよいですか?
私が作成した次のクラスを見てください。
_public class FibonacciSupplier implements Iterator<Integer> {
private final IntPredicate hasNextPredicate;
private int beforePrevious = 0;
private int previous = 1;
private FibonacciSupplier(final IntPredicate hasNextPredicate) {
this.hasNextPredicate = hasNextPredicate;
}
@Override
public boolean hasNext() {
return hasNextPredicate.test(previous);
}
@Override
public Integer next() {
int result = beforePrevious + previous;
beforePrevious = previous;
previous = result;
return result;
}
public static FibonacciSupplier infinite() {
return new FibonacciSupplier(i -> true);
}
public static FibonacciSupplier finite(final IntPredicate predicate) {
return new FibonacciSupplier(predicate);
}
}
_
そしてそれの使用法:
_public class Problem2 extends Problem<Integer> {
@Override
public void run() {
result = toList(FibonacciSupplier.finite(i -> (i <= 4_000_000)))
.stream()
.filter(i -> (i % 2 == 0))
.mapToInt(i -> i)
.sum();
}
@Override
public String getName() {
return "Problem 2";
}
private static <E> List<E> toList(final Iterator<E> iterator) {
List<E> list = new ArrayList<>();
while (iterator.hasNext()) {
list.add(iterator.next());
}
return list;
}
}
_
無限 _Stream<E>
_を作成するにはどうすればよいですか?
Stream<Integer> infiniteStream = toList(FibonacciSupplier.infinite()).stream()
を使用した場合、おそらく驚くべきことに、無限のストリームを取得することはありません。
代わりに、基になるメソッドでlist
を作成すると、コードは永久にループします。
これまでのところ、これは純粋に理論的なものですが、最初に無限ストリームから最初のx個の数値をスキップし、次に最後のy個の数値で制限したい場合は、その必要性を明確に理解できます。
_int x = MAGIC_NUMBER_X;
int y = MAGIC_NUMBER_y;
int sum = toList(FibonacciSupplier.infinite())
.stream()
.skip(x)
.limit(y)
.mapToInt(i -> i)
.sum();
_
コードが結果を返すことはありませんが、どのように行う必要がありますか?
あなたの間違いは、Iterator
を作成するためにCollection
またはStream
が必要だと考えることです。無限のストリームを作成するには、値を次々に提供する単一のメソッドで十分です。したがって、クラスFibonacciSupplier
の最も簡単な使用法は次のとおりです。
IntStream s=IntStream.generate(FibonacciSupplier.infinite()::next);
または、ボックス化された値を好む場合:
Stream<Integer> s=Stream.generate(FibonacciSupplier.infinite()::next);
この場合、メソッドにnext
という名前を付ける必要も、Iterator
インターフェースを満たす必要もないことに注意してください。ただし、クラスと同じかどうかは関係ありません。さらに、next
メソッドをSupplier
として使用するようにストリームに指示したので、hasNext
メソッドが呼び出されることはありません。それはただ無限です。
Iterator
を使用して有限ストリームを作成するのは、もう少し複雑です。
Stream<Integer> s=StreamSupport.stream(
Spliterators.spliteratorUnknownSize(
FibonacciSupplier.finite(intPredicate), Spliterator.ORDERED),
false);
この場合、ボックス化されていないIntStream
値を持つ有限のint
が必要な場合は、FibonacciSupplier
がPrimitiveIterator.OfInt
を実装する必要があります。
Java 8)には、インターフェイスを実装するパブリックの具象クラスはありません Stream 。ただし、いくつかの静的ファクトリメソッド。最も重要なものの1つは StreamSupport.stream です。特に、デフォルトメソッドCollection.stream –ほとんどのコレクションクラスに継承されます:
_default Stream<E> stream() {
return StreamSupport.stream(spliterator(), false);
}
_
このメソッドのデフォルトの実装では、spliterator()
を呼び出して Spliterator を作成し、作成したオブジェクトをファクトリメソッドに渡します。 Spliteratorは、並列ストリームをサポートするためにJava 8で導入された新しいインターフェースです)。 toIteratorですが、後者とは対照的に、Spliteratorはパーツに分割でき、個別に処理できます。-を参照してください。 Spliterator.trySplit 詳細については。
defaultメソッドIterable.spliterator もJava 8に追加されたため、すべてのIterableクラスは自動的にSpliteratorsをサポートします。実装は次のようになります。
_default Spliterator<T> spliterator() {
return Spliterators.spliteratorUnknownSize(iterator(), 0);
}
_
このメソッドは、任意のIteratorからSpliteratorを作成します。これらの2つのステップを組み合わせると、任意のイテレータからStreamを作成できます。
_<T> Stream<T> stream(Iterator<T> iterator) {
Spliterator<T> spliterator
= Spliterators.spliteratorUnknownSize(iterator, 0);
return StreamSupport.stream(spliterator, false);
}
_
Spliteratorsの印象をつかむために、コレクションを使用しない非常に単純な例を次に示します。次のクラスは、Spliteratorを実装して、整数のハーフオープン間隔で反復します。
_public final class IntRange implements Spliterator.OfInt {
private int first, last;
public IntRange(int first, int last) {
this.first = first;
this.last = last;
}
public boolean tryAdvance(IntConsumer action) {
if (first < last) {
action.accept(first++);
return true;
} else {
return false;
}
}
public OfInt trySplit() {
int size = last - first;
if (size >= 10) {
int temp = first;
first += size / 2;
return new IntRange(temp, first);
} else {
return null;
}
}
public long estimateSize() {
return Math.max(last - first, 0);
}
public int characteristics() {
return ORDERED | DISTINCT | SIZED | NONNULL
| IMMUTABLE | CONCURRENT | SUBSIZED;
}
}
_
低レベルのストリームサポートプリミティブとSpliterators
ライブラリを使用して、Iterator
からストリームを作成できます。
StreamSupport.stream()
の最後のパラメーターは、ストリームが並列ではないことを示しています。フィボナッチイテレータは以前の反復に依存しているため、必ずそのようにしてください。
return StreamSupport.stream( Spliterators.spliteratorUnknownSize( new Iterator<Node>()
{
@Override
public boolean hasNext()
{
// to implement
return ...;
}
@Override
public ContentVersion next()
{
// to implement
return ...;
}
}, Spliterator.ORDERED ), false );
別の答えを追加するには、特にサンプルコードを考えると、おそらくAbstractSpliteratorの方が適しています。制限を使用する以外に停止条件を与える[良い]方法がないため、Generateは柔軟性がありません。 Limitは述語ではなくいくつかのアイテムのみを受け入れるので、生成したいアイテムの数を知る必要があります-これは不可能かもしれません、そしてジェネレーターが私たちに渡されたブラックボックスである場合はどうなりますか?
AbstractSpliteratorは、スプリッター全体を作成する必要があることと、Iterator/Iterableを使用することの中間にあります。 AbstractSpliteratorには、最初に述語が実行されているかどうかを確認し、実行されていない場合は生成された値をアクションに渡すtryAdvanceメソッドだけがありません。 AbstractIntSpliteratorを使用したフィボナッチ数列の例を次に示します。
public class Fibonacci {
private static class FibonacciGenerator extends Spliterators.AbstractIntSpliterator
{
private IntPredicate hasNextPredicate;
private int beforePrevious = 0;
private int previous = 0;
protected FibonacciGenerator(IntPredicate hasNextPredicate)
{
super(Long.MAX_VALUE, 0);
this.hasNextPredicate = hasNextPredicate;
}
@Override
public boolean tryAdvance(IntConsumer action)
{
if (action == null)
{
throw new NullPointerException();
}
int next = Math.max(1, beforePrevious + previous);
beforePrevious = previous;
previous = next;
if (!hasNextPredicate.test(next))
{
return false;
}
action.accept(next);
return true;
}
@Override
public boolean tryAdvance(Consumer<? super Integer> action)
{
if (action == null)
{
throw new NullPointerException();
}
int next = Math.max(1, beforePrevious + previous);
beforePrevious = previous;
previous = next;
if (!hasNextPredicate.test(next))
{
return false;
}
action.accept(next);
return true;
}
}
public static void main(String args[])
{
Stream<Integer> infiniteStream = StreamSupport.stream(
new FibonacciGenerator(i -> true), false);
Stream<Integer> finiteStream = StreamSupport.stream(
new FibonacciGenerator(i -> i < 100), false);
// Print with a side-effect for the demo
infiniteStream.limit(10).forEach(System.out::println);
finiteStream.forEach(System.out::println);
}
}
詳細については、Java 8 in my blog http://thecannycoder.wordpress.com/ でジェネレーターについて説明しました。