Add Java 9 Stream APIs

user/super/com/google/gwt/emul/java/util/stream/Collectors.java

@@ -170,6 +170,38 @@ public static Collector<CharSequence,?,String> joining(CharSequence delimiter) {
         downstream.finisher());
   }
 
+  public static <T, U, A, R> Collector<T, ?, R> flatMapping(Function<? super T,? extends Stream<?
+      extends U>> mapper, Collector<? super U, A, R> downstream) {
+    return new CollectorImpl<>(
+        downstream.supplier(),
+        (A a, T t) -> {
+            Stream<? extends U> stream = mapper.apply(t);
+            if (stream == null) {
+              return;
+            }
+            stream.forEach(u -> {
+              downstream.accumulator().accept(a, u);
+            });
+        },
+        downstream.combiner(),
+        downstream.finisher()
+    );
+  }
+
+  public static <T, A, R> Collector<T, ?, R> filtering(Predicate<? super T> predicate,
+                                                        Collector<? super T, A, R> downstream) {
+    return new CollectorImpl<>(
+        downstream.supplier(),
+        (a, t) -> {
+          if (predicate.test(t)) {
+            downstream.accumulator().accept(a, t);
+          }
+        },
+        downstream.combiner(),
+        downstream.finisher()
+    );
+  }
+
   public static <T> Collector<T,?,Optional<T>> maxBy(Comparator<? super T> comparator) {
     return reducing(BinaryOperator.maxBy(comparator));
   }

user/super/com/google/gwt/emul/java/util/stream/DoubleStream.java

@@ -146,19 +146,35 @@ public boolean tryAdvance(DoubleConsumer action) {
   }
 
   static DoubleStream iterate(double seed, DoubleUnaryOperator f) {
+    return iterate(seed, ignore -> true, f);
+  }
+
+  static DoubleStream iterate(double seed, DoublePredicate hasNext, DoubleUnaryOperator f) {
     Spliterator.OfDouble spliterator =
         new Spliterators.AbstractDoubleSpliterator(
             Long.MAX_VALUE, Spliterator.IMMUTABLE | Spliterator.ORDERED) {
+          private boolean first = true;
           private double next = seed;
+          private boolean terminated = false;
 
           @Override
           public boolean tryAdvance(DoubleConsumer action) {
+            if (terminated) {
+              return false;
+            }
+            if (!first) {
+              next = f.applyAsDouble(next);
+            }
+            first = false;
+
+            if (!hasNext.test(next)) {
+              terminated = true;
+              return false;
+            }
             action.accept(next);
-            next = f.applyAsDouble(next);
             return true;
           }
         };
-
     return StreamSupport.doubleStream(spliterator, false);
   }
 
@@ -185,6 +201,39 @@ static DoubleStream of(double t) {
 
   DoubleStream distinct();
 
+  default DoubleStream dropWhile(DoublePredicate predicate) {
+    Spliterator.OfDouble prev = spliterator();
+    Spliterator.OfDouble spliterator =
+        new Spliterators.AbstractDoubleSpliterator(prev.estimateSize(),
+                prev.characteristics() & ~(Spliterator.SIZED | Spliterator.SUBSIZED)) {
+          private boolean drop = true;
+          private boolean found;
+
+          @Override
+          public boolean tryAdvance(DoubleConsumer action) {
+            found = false;
+            if (drop) {
+              // drop items until we find one that matches
+              while (drop && prev.tryAdvance((double item) -> {
+                if (!predicate.test(item)) {
+                  drop = false;
+                  found = true;
+                  action.accept(item);
+                }
+              })) {
+                // do nothing, work is done in tryAdvance
+              }
+              // only return true if we accepted at least one item
+              return found;
+            } else {
+              // accept one item, return result
+              return prev.tryAdvance(action);
+            }
+          }
+        };
+    return StreamSupport.doubleStream(spliterator, false);
+  }
+
   DoubleStream filter(DoublePredicate predicate);
 
   OptionalDouble findAny();
@@ -239,5 +288,34 @@ static DoubleStream of(double t) {
 
   DoubleSummaryStatistics summaryStatistics();
 
+  default DoubleStream takeWhile(DoublePredicate predicate) {
+    Spliterator.OfDouble original = spliterator();
+    Spliterator.OfDouble spliterator =
+        new Spliterators.AbstractDoubleSpliterator(original.estimateSize(),
+                original.characteristics() & ~(Spliterator.SIZED | Spliterator.SUBSIZED)) {
+          private boolean take = true;
+          private boolean found;
+
+          @Override
+          public boolean tryAdvance(DoubleConsumer action) {
+            found = false;
+            if (!take) {
+              // already failed the check
+              return false;
+            }
+            original.tryAdvance((double item) -> {
+              if (predicate.test(item)) {
+                found = true;
+                action.accept(item);
+              } else {
+                take = false;
+              }
+            });
+            return found;
+          }
+        };
+    return StreamSupport.doubleStream(spliterator, false);
+  }
+
   double[] toArray();
 }

user/super/com/google/gwt/emul/java/util/stream/IntStream.java

@@ -149,20 +149,35 @@ public boolean tryAdvance(IntConsumer action) {
   }
 
   static IntStream iterate(int seed, IntUnaryOperator f) {
+    return iterate(seed, ignore -> true, f);
+  }
 
-    AbstractIntSpliterator spliterator =
+  static IntStream iterate(int seed, IntPredicate hasNext, IntUnaryOperator f) {
+    Spliterator.OfInt spliterator =
         new Spliterators.AbstractIntSpliterator(
             Long.MAX_VALUE, Spliterator.IMMUTABLE | Spliterator.ORDERED) {
+          private boolean first = true;
           private int next = seed;
+          private boolean terminated = false;
 
           @Override
           public boolean tryAdvance(IntConsumer action) {
+            if (terminated) {
+              return false;
+            }
+            if (!first) {
+              next = f.applyAsInt(next);
+            }
+            first = false;
+
+            if (!hasNext.test(next)) {
+              terminated = true;
+              return false;
+            }
             action.accept(next);
-            next = f.applyAsInt(next);
             return true;
           }
         };
-
     return StreamSupport.intStream(spliterator, false);
   }
 
@@ -235,6 +250,39 @@ public boolean tryAdvance(IntConsumer action) {
 
   IntStream distinct();
 
+  default IntStream dropWhile(IntPredicate predicate) {
+    Spliterator.OfInt prev = spliterator();
+    Spliterator.OfInt spliterator =
+        new Spliterators.AbstractIntSpliterator(prev.estimateSize(),
+                prev.characteristics() & ~(Spliterator.SIZED | Spliterator.SUBSIZED)) {
+          private boolean drop = true;
+          private boolean found;
+
+          @Override
+          public boolean tryAdvance(IntConsumer action) {
+            found = false;
+            if (drop) {
+              // drop items until we find one that matches
+              while (drop && prev.tryAdvance((int item) -> {
+                if (!predicate.test(item)) {
+                  drop = false;
+                  found = true;
+                  action.accept(item);
+                }
+              })) {
+                // do nothing, work is done in tryAdvance
+              }
+              // only return true if we accepted at least one item
+              return found;
+            } else {
+              // accept one item, return result
+              return prev.tryAdvance(action);
+            }
+          }
+        };
+    return StreamSupport.intStream(spliterator, false);
+  }
+
   IntStream filter(IntPredicate predicate);
 
   OptionalInt findAny();
@@ -289,5 +337,34 @@ public boolean tryAdvance(IntConsumer action) {
 
   IntSummaryStatistics summaryStatistics();
 
+  default IntStream takeWhile(IntPredicate predicate) {
+    Spliterator.OfInt original = spliterator();
+    Spliterator.OfInt spliterator =
+        new Spliterators.AbstractIntSpliterator(original.estimateSize(),
+                original.characteristics() & ~(Spliterator.SIZED | Spliterator.SUBSIZED)) {
+          private boolean take = true;
+          private boolean found;
+
+          @Override
+          public boolean tryAdvance(IntConsumer action) {
+            found = false;
+            if (!take) {
+              // already failed the check
+              return false;
+            }
+            original.tryAdvance((int item) -> {
+              if (predicate.test(item)) {
+                found = true;
+                action.accept(item);
+              } else {
+                take = false;
+              }
+            });
+            return found;
+          }
+        };
+    return StreamSupport.intStream(spliterator, false);
+  }
+
   int[] toArray();
 }

user/super/com/google/gwt/emul/java/util/stream/LongStream.java

@@ -149,15 +149,32 @@ public boolean tryAdvance(LongConsumer action) {
   }
 
   static LongStream iterate(long seed, LongUnaryOperator f) {
-    AbstractLongSpliterator spliterator =
+    return iterate(seed, ignore -> true, f);
+  }
+
+  static LongStream iterate(long seed, LongPredicate hasNext, LongUnaryOperator f) {
+    Spliterator.OfLong spliterator =
         new Spliterators.AbstractLongSpliterator(
             Long.MAX_VALUE, Spliterator.IMMUTABLE | Spliterator.ORDERED) {
+          private boolean first = true;
           private long next = seed;
+          private boolean terminated = false;
 
           @Override
           public boolean tryAdvance(LongConsumer action) {
+            if (terminated) {
+              return false;
+            }
+            if (!first) {
+              next = f.applyAsLong(next);
+            }
+            first = false;
+
+            if (!hasNext.test(next)) {
+              terminated = true;
+              return false;
+            }
             action.accept(next);
-            next = f.applyAsLong(next);
             return true;
           }
         };
@@ -231,6 +248,39 @@ public boolean tryAdvance(LongConsumer action) {
 
   LongStream distinct();
 
+  default LongStream dropWhile(LongPredicate predicate) {
+    Spliterator.OfLong prev = spliterator();
+    Spliterator.OfLong spliterator =
+        new Spliterators.AbstractLongSpliterator(prev.estimateSize(),
+                prev.characteristics() & ~(Spliterator.SIZED | Spliterator.SUBSIZED)) {
+          private boolean drop = true;
+          private boolean found;
+
+          @Override
+          public boolean tryAdvance(LongConsumer action) {
+            found = false;
+            if (drop) {
+              // drop items until we find one that matches
+              while (drop && prev.tryAdvance((long item) -> {
+                if (!predicate.test(item)) {
+                  drop = false;
+                  found = true;
+                  action.accept(item);
+                }
+              })) {
+                // do nothing, work is done in tryAdvance
+              }
+              // only return true if we accepted at least one item
+              return found;
+            } else {
+              // accept one item, return result
+              return prev.tryAdvance(action);
+            }
+          }
+        };
+    return StreamSupport.longStream(spliterator, false);
+  }
+
   LongStream filter(LongPredicate predicate);
 
   OptionalLong findAny();
@@ -285,5 +335,34 @@ public boolean tryAdvance(LongConsumer action) {
 
   LongSummaryStatistics summaryStatistics();
 
+  default LongStream takeWhile(LongPredicate predicate) {
+    Spliterator.OfLong original = spliterator();
+    Spliterator.OfLong spliterator =
+        new Spliterators.AbstractLongSpliterator(original.estimateSize(),
+                original.characteristics() & ~(Spliterator.SIZED | Spliterator.SUBSIZED)) {
+          private boolean take = true;
+          private boolean found;
+
+          @Override
+          public boolean tryAdvance(LongConsumer action) {
+            found = false;
+            if (!take) {
+              // already failed the check
+              return false;
+            }
+            original.tryAdvance((long item) -> {
+              if (predicate.test(item)) {
+                found = true;
+                action.accept(item);
+              } else {
+                take = false;
+              }
+            });
+            return found;
+          }
+        };
+    return StreamSupport.longStream(spliterator, false);
+  }
+
   long[] toArray();
 }