Fibonacci在Java中使用Stream和BinaryOperator

Question

我是學生，我學習功能Java 8.我有項目要做，我不明白這個功能界面是如何工作的。 我的老師告訴我“你應該知道”，我正在尋求幫助來理解這個問題。 它應該算上Fibonacci系列

我有這個代碼

StreamUtils.generateRest(Stream.of(1, 1), (a, b) -> a + b)
    .limit(7)
    .forEach(System.out::println);

StreamUtils.generateRest(Stream.of("AAA", "BB", "KKKK"), (a, b) -> a + b)
    .limit(7)
    .forEach(System.out::println);

StreamUtils.generateRest(Stream.of(i -> 0), 
    (BinaryOperator<UnaryOperator<Integer>>) (f, g) -> (x -> x == 0 ? 1 : x * g.apply(x - 1)))
    .limit(10)
    .map(f -> f.apply(7))
    .forEach(System.out::println);

我做了這樣的事情，但它不起作用

public class StreamUtils<T> {

    public static <T> Stream generateRest(Stream<T> stream, BinaryOperator<T> binaryOperator) {
        return Stream.of(stream.reduce((a, b) -> binaryOperator.apply(a, b)));
    }

}

有人可以幫助我解釋如何解決這個問題？

Answer 1

要做第一個示例工作，您需要實現這樣的事情：

private static class StreamUtils<T> {
    public static <T> Stream generateRest(Stream<T> stream, BinaryOperator<T> binaryOperator) {
        return Stream.iterate(stream.toArray(), p -> new Object[]{p[1], binaryOperator.apply((T) p[0], (T) p[1])})
            .flatMap(p -> Stream.of(p[0]));
    }
}

它從輸入流創建數組，然后在兩個元素上應用傳遞的函數，將前一次迭代的結果移動到位置0 ，因為我們需要前兩個值來計算下一個。 然后它創建了無限的計算Fibonacci元素流。

輸出是：

1
1
2
3
5
8
13

並且版本具有正確的泛型用法，因為您的初始結構會生成原始類型。

private static class StreamUtils {
    public static <T> Stream<T> generateRest(Stream<T> stream, BinaryOperator<T> binaryOperator) {
        return Stream.iterate(stream.toArray(), p -> new Object[]{p[1], binaryOperator.apply((T) p[0], (T) p[1])})
            .flatMap(p -> Stream.of((T) p[0]));
    }
}

Answer 2

我假設有超過2個項目意味着A，B，C，A + B，B + C，C +（A + B），（A + B）+（B + C）等，並且具有1項表示A，A + A，A +（A + A），（A + A）+（A +（A + A））等，其中+是二元運算符。

基本上你將流轉換為一個數組，然后你使用Stream.generate並在每一步生成你擁有的元素后，向左移動數組以適應新元素，並返回舊的第一個元素（不再在數組中）。 請注意，由於這會產生副作用（修改外部數組），因此無法與.parallel()一起使用。

@SuppressWarnings("unchecked")
public static <T> Stream<T> generateRest(Stream<T> stream, BinaryOperator<T> binaryOperator) {
    T[] t = (T[]) stream.toArray();
    if (t.length == 1) {
        t = (T[]) new Object[] { t[0], binaryOperator.apply(t[0], t[0]) };
    }
    final T[] items = t;
    return Stream.generate(() -> {
        T first = items[0];
        T next = binaryOperator.apply(items[0], items[1]);
        System.arraycopy(items, 1, items, 0, items.length - 1);
        items[items.length - 1] = next;
        return first;
    });
}

輸出：

1
1
2
3
5
8
13
AAA
BB
KKKK
AAABB
BBKKKK
KKKKAAABB
AAABBBBKKKK
0
0
0
0
0
0
0
0
5040
5040