如何从迭代器<E>中创建无限流<E>？

iterator java java-8 java-stream

2022-09-01 13:00:22

看看我做的以下类：

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>

如果我使用，我可能会感到惊讶，永远不会得到无限的流。
相反，代码将在创建 in 基础方法时永远循环。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();

代码永远不会返回结果，应该如何完成？

答案 1

你的错误是认为你需要一个或一个来创建一个.对于创建无限流，单个方法提供一个又一个值就足够了。因此，对于您的类，最简单的用法是：IteratorCollectionStreamFibonacciSupplier

IntStream s=IntStream.generate(FibonacciSupplier.infinite()::next);

或者，如果您更喜欢带框内的值：

Stream<Integer> s=Stream.generate(FibonacciSupplier.infinite()::next);

请注意，在这种情况下，方法不必命名，也不必满足接口。但是，如果它与你的班级一样，这并不重要。此外，正如我们刚刚告诉流使用该方法作为一样，该方法永远不会被调用。它只是无限的。nextIteratornextSupplierhasNext

使用 your 创建有限流有点复杂：Iterator

Stream<Integer> s=StreamSupport.stream(
  Spliterators.spliteratorUnknownSize(
    FibonacciSupplier.finite(intPredicate), Spliterator.ORDERED),
  false);

在这种情况下，如果你想要一个具有未装箱值的有限值，你应该实现。IntStreamintFibonacciSupplierPrimitiveIterator.OfInt

答案 2

在 Java 8 中，没有实现接口 Stream 的公共具体类。但是，有一些静态工厂方法。其中最重要的是StreamSupport.stream。特别是，它在默认方法Collection.stream中使用 - 由大多数集合类继承：

default Stream<E> stream() {
    return StreamSupport.stream(spliterator(), false);
}

此方法的默认实现通过调用创建一个拆分器，并将创建的对象传递给工厂方法。Spliterator 是 Java 8 引入的一个新接口，用于支持并行流。它类似于迭代器，但与后者相反，拆分器可以分为几个部分，可以独立处理。有关详细信息，请参阅 Spliterator.trySplit。spliterator()

在 Java 8 中还添加了默认方法 Iterable.spliterator，以便每个 Iterable 类都自动支持 Spliterators。该实现如下所示：

default Spliterator<T> spliterator() {
    return Spliterators.spliteratorUnknownSize(iterator(), 0);
}

该方法从任意迭代器创建拆分器。如果将这两个步骤结合起来，则可以从任意迭代器创建 Stream：

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

为了获得Sptererators的印象，这里有一个非常简单的例子，不使用集合。以下类实现 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;
    }
}