java实现 流 collect

1399852153 · 1399852153 · commit e85328466207 · 2019-03-07T22:21:24.000+08:00
diff --git a/src/main/java/stream/Stream.java b/src/main/java/stream/Stream.java
@@ -90,22 +90,28 @@ public Stream<T> limit(int n) {
                 }
         );
 
+        // 求值链条 加入一个新的process limit
         return this;
     }
 
     @Override
     public void forEach(ForEach<T> consumer) {
+        // 终结操作 直接开始求值
         forEach(consumer,this.eval());
     }
 
     @Override
     public <R> R reduce(R initVal, Accumulate<R, T> accumulator) {
+        // 终结操作 直接开始求值
         return reduce(initVal,accumulator,this.eval());
     }
 
     @Override
     public <R, A> R collect(Collector<T, A, R> collector) {
-        A result = collect(collector,this);
+        // 终结操作 直接开始求值
+        A result = collect(collector,this.eval());
+
+        // 通过finish方法进行收尾
         return collector.finisher().apply(result);
     }
 
diff --git a/src/test/java/TestMyStream.java b/src/test/java/TestMyStream.java
@@ -1,6 +1,11 @@
+import function.Accumulate;
+import function.Supplier;
+import stream.Collector;
 import stream.Stream;
 import stream.StreamGenerator;
 
+import java.util.function.Function;
+
 /**
  * @Author xiongyx
  * @Date 2019/3/6
@@ -10,15 +15,35 @@ public class TestMyStream {
     public static void main(String[] args){
         Stream<Integer> intStream = StreamGenerator.getIntegerStream(10);
 
-        intStream = intStream.filter(TestMyStream::idOdd);
+//        intStream = intStream.filter(TestMyStream::idOdd);
 //        intStream = intStream.map(TestMyStream::scaleTwo);
         intStream = intStream.map(TestMyStream::square);
-        intStream = intStream.limit(3);
+//        intStream = intStream.limit(3);
 
 //        Integer sum = intStream.reduce(0,(v1,v2) -> v1 + v2);
 //        System.out.println(sum);
 
-        intStream.forEach(System.out::print);
+//        intStream.forEach(System.out::print);
+
+        Integer sum = intStream.collect(new Collector<Integer, Integer, Integer>() {
+            @Override
+            public Accumulate<Integer, Integer> accumulator() {
+                return (t1, t2) -> t1 + t2;
+            }
+
+            @Override
+            public Supplier<Integer> supplier() {
+                return () -> 10;
+            }
+
+            @Override
+            public Function<Integer, Integer> finisher() {
+                return integer -> integer;
+            }
+        });
+        System.out.println(sum);
+
+//        intStream.forEach(System.out::print);
     }
 
     private static boolean idOdd(int num){

Original file line number	Diff line number	Diff line change
`@@ -90,22 +90,28 @@ public Stream<T> limit(int n) {`
`90`	`90`	`}`
`91`	`91`	`);`
`92`	`92`
	`93`	`+ // 求值链条加入一个新的process limit`
`93`	`94`	`return this;`
`94`	`95`	`}`
`95`	`96`
`96`	`97`	`@Override`
`97`	`98`	`public void forEach(ForEach<T> consumer) {`
	`99`	`+ // 终结操作直接开始求值`
`98`	`100`	`forEach(consumer,this.eval());`
`99`	`101`	`}`
`100`	`102`
`101`	`103`	`@Override`
`102`	`104`	`public <R> R reduce(R initVal, Accumulate<R, T> accumulator) {`
	`105`	`+ // 终结操作直接开始求值`
`103`	`106`	`return reduce(initVal,accumulator,this.eval());`
`104`	`107`	`}`
`105`	`108`
`106`	`109`	`@Override`
`107`	`110`	`public <R, A> R collect(Collector<T, A, R> collector) {`
`108`		`- A result = collect(collector,this);`
	`111`	`+ // 终结操作直接开始求值`
	`112`	`+ A result = collect(collector,this.eval());`
	`113`	`+`
	`114`	`+ // 通过finish方法进行收尾`
`109`	`115`	`return collector.finisher().apply(result);`
`110`	`116`	`}`
`111`	`117`