feat: 带缓存功能的Stream，可以多次重发

Author: lokic

src/main/java/com/github/lokic/javaplus/Memoized.java

@@ -6,9 +6,18 @@
 import com.github.lokic.javaplus.tuple.Tuple2;
 import com.github.lokic.javaplus.tuple.Tuple3;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Spliterator;
+import java.util.Spliterators;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
+import java.util.function.Consumer;
 import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+import static java.util.stream.StreamSupport.stream;
 
 /**
  * 对执行的函数提供记忆化的功能，减少相同参数的重复调用
@@ -30,4 +39,41 @@ public static <T1, T2, T3, R> Function3<T1, T2, T3, R> of(Function3<T1, T2, T3,
         return (t1, t2, t3) -> cache.computeIfAbsent(Tuple.of(t1, t2, t3), t -> function3.apply(t.getT1(), t.getT2(), t.getT3()));
     }
 
+
+    /**
+     * 带缓存功能，可多次重放Stream
+     *
+     * @param streamSupplier
+     * @param <T>
+     * @return
+     */
+    public static <T> Supplier<Stream<T>> of(Supplier<Stream<T>> streamSupplier) {
+        final Spliterator<T> spliterator = streamSupplier.get().spliterator();
+        final List<T> cache = new ArrayList<>();
+        return () -> {
+            Spliterator<T> split = new Spliterators.AbstractSpliterator<T>(
+                    spliterator.estimateSize(), spliterator.characteristics()) {
+
+                private int index = 0;
+                private boolean hasNext = true;
+
+                @Override
+                public boolean tryAdvance(Consumer<? super T> action) {
+                    int currentIndex = index++;
+                    if (currentIndex < cache.size()) {
+                        action.accept(cache.get(currentIndex));
+                        return true;
+                    } else if (hasNext) {
+                        hasNext = spliterator.tryAdvance(item -> {
+                            cache.add(item);
+                            action.accept(item);
+                        });
+                    }
+                    return hasNext;
+                }
+            };
+            return stream(split, false);
+        };
+    }
+
 }

src/test/java/com/github/lokic/javaplus/MemoizedTest.java

@@ -0,0 +1,25 @@
+package com.github.lokic.javaplus;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class MemoizedTest {
+
+    @Test
+    public void of_stream() {
+        Supplier<Stream<Integer>> streamSupplier = Memoized.of(() -> Stream.of(1, 2, 3));
+
+        List<Integer> first = streamSupplier.get().collect(Collectors.toList());
+        Assertions.assertThat(first)
+                .containsExactly(1, 2, 3);
+
+        List<Integer> second = streamSupplier.get().collect(Collectors.toList());
+        Assertions.assertThat(second)
+                .containsExactly(1, 2, 3);
+    }
+}