Emulate Java 8 Streams. Change-Id: Ifbe0c001f1a53f5cb9c4c1a77ee203b2660d4e23

diff --git a/user/super/com/google/gwt/emul/java/util/Arrays.java b/user/super/com/google/gwt/emul/java/util/Arrays.java
index 72da442..4229fe6 100644
--- a/user/super/com/google/gwt/emul/java/util/Arrays.java
+++ b/user/super/com/google/gwt/emul/java/util/Arrays.java

@@ -35,6 +35,11 @@
 import java.util.function.IntUnaryOperator;
 import java.util.function.LongBinaryOperator;
 import java.util.function.UnaryOperator;
+import java.util.stream.DoubleStream;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
 
 import javaemul.internal.ArrayHelper;
 import javaemul.internal.LongCompareHolder;
@@ -1452,6 +1457,38 @@
         Spliterator.IMMUTABLE | Spliterator.ORDERED);
   }
 
+  public static DoubleStream stream(double[] array) {
+    return stream(array, 0, array.length);
+  }
+
+  public static DoubleStream stream(double[] array, int startInclusive, int endExclusive) {
+    return StreamSupport.doubleStream(spliterator(array, startInclusive, endExclusive), false);
+  }
+
+  public static IntStream stream(int[] array) {
+    return stream(array, 0, array.length);
+  }
+
+  public static IntStream stream(int[] array, int startInclusive, int endExclusive) {
+    return StreamSupport.intStream(spliterator(array, startInclusive, endExclusive), false);
+  }
+
+  public static LongStream stream(long[] array) {
+    return stream(array, 0, array.length);
+  }
+
+  public static LongStream stream(long[] array, int startInclusive, int endExclusive) {
+    return StreamSupport.longStream(spliterator(array, startInclusive, endExclusive), false);
+  }
+
+  public static <T> Stream<T> stream(T[] array) {
+    return stream(array, 0, array.length);
+  }
+
+  public static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusive) {
+    return StreamSupport.stream(spliterator(array, startInclusive, endExclusive), false);
+  }
+
   public static String toString(boolean[] a) {
     if (a == null) {
       return "null";

diff --git a/user/super/com/google/gwt/emul/java/util/Collection.java b/user/super/com/google/gwt/emul/java/util/Collection.java
index 379be6d..d678e05 100644
--- a/user/super/com/google/gwt/emul/java/util/Collection.java
+++ b/user/super/com/google/gwt/emul/java/util/Collection.java

@@ -18,6 +18,8 @@
 import static javaemul.internal.InternalPreconditions.checkNotNull;
 
 import java.util.function.Predicate;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
 
 /**
  * General-purpose interface for storing collections of objects.
@@ -49,6 +51,11 @@
   @Override
   Iterator<E> iterator();
 
+  default Stream<E> parallelStream() {
+    // no parallelism in gwt
+    return stream();
+  }
+
   boolean remove(Object o);
 
   boolean removeAll(Collection<?> c);
@@ -74,6 +81,10 @@
     return Spliterators.spliterator(this, 0);
   }
 
+  default Stream<E> stream() {
+    return StreamSupport.stream(spliterator(), false);
+  }
+
   Object[] toArray();
 
   <T> T[] toArray(T[] a);

diff --git a/user/super/com/google/gwt/emul/java/util/stream/BaseStream.java b/user/super/com/google/gwt/emul/java/util/stream/BaseStream.java
new file mode 100644
index 0000000..3d08e80
--- /dev/null
+++ b/user/super/com/google/gwt/emul/java/util/stream/BaseStream.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package java.util.stream;
+
+import java.util.Iterator;
+import java.util.Spliterator;
+
+/**
+ * See <a href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/BaseStream.html">
+ * the official Java API doc</a> for details.
+ *
+ * @param <T> the contents of the stream
+ * @param <S> the type of stream implementing this interface
+ */
+public interface BaseStream<T,S extends BaseStream<T,S>> extends AutoCloseable {
+  Iterator<T> iterator();
+
+  Spliterator<T> spliterator();
+
+  boolean isParallel();
+
+  S sequential();
+
+  S parallel();
+
+  S unordered();
+
+  S onClose(Runnable closeHandler);
+
+  void close();
+}

diff --git a/user/super/com/google/gwt/emul/java/util/stream/DoubleStream.java b/user/super/com/google/gwt/emul/java/util/stream/DoubleStream.java
new file mode 100644
index 0000000..492f621
--- /dev/null
+++ b/user/super/com/google/gwt/emul/java/util/stream/DoubleStream.java

@@ -0,0 +1,1028 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package java.util.stream;
+
+import static javaemul.internal.InternalPreconditions.checkCriticalState;
+import static javaemul.internal.InternalPreconditions.checkNotNull;
+import static javaemul.internal.InternalPreconditions.checkState;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.DoubleSummaryStatistics;
+import java.util.HashSet;
+import java.util.OptionalDouble;
+import java.util.PrimitiveIterator;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.DoubleBinaryOperator;
+import java.util.function.DoubleConsumer;
+import java.util.function.DoubleFunction;
+import java.util.function.DoublePredicate;
+import java.util.function.DoubleSupplier;
+import java.util.function.DoubleToIntFunction;
+import java.util.function.DoubleToLongFunction;
+import java.util.function.DoubleUnaryOperator;
+import java.util.function.IntConsumer;
+import java.util.function.LongConsumer;
+import java.util.function.ObjDoubleConsumer;
+import java.util.function.Supplier;
+
+/**
+ * See <a href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/DoubleStream.html">
+ * the official Java API doc</a> for details.
+ */
+public interface DoubleStream extends BaseStream<Double,DoubleStream> {
+
+  /**
+   * Value holder for various stream operations.
+   */
+  static final class ValueConsumer implements DoubleConsumer {
+    double value;
+
+    @Override
+    public void accept(double value) {
+      this.value = value;
+    }
+  }
+
+  static DoubleStream.Builder builder() {
+    return new Builder() {
+      private double[] items = new double[0];
+
+      @Override
+      public void accept(double t) {
+        checkState(items != null, "Builder already built");
+        items[items.length] = t;
+      }
+
+      @Override
+      public DoubleStream build() {
+        checkCriticalState(items != null, "Builder already built");
+        DoubleStream stream = Arrays.stream(items);
+        items = null;
+        return stream;
+      }
+    };
+  }
+
+  static DoubleStream concat(DoubleStream a, DoubleStream b) {
+    // This is nearly the same as flatMap, but inlined, wrapped around a single spliterator of
+    // these two objects, and without close() called as the stream progresses. Instead, close is
+    // invoked as part of the resulting stream's own onClose, so that either can fail without
+    // affecting the other, and correctly collecting suppressed exceptions.
+
+    // TODO replace this flatMap-ish spliterator with one that directly combines the two root
+    // streams
+    Spliterator<? extends DoubleStream> spliteratorOfStreams =
+        Arrays.asList(a, b).spliterator();
+    DoubleStream result = new DoubleStreamSource(null, new Spliterators.AbstractDoubleSpliterator(
+        Long.MAX_VALUE,
+        0
+    ) {
+      DoubleStream nextStream;
+      Spliterator.OfDouble next;
+
+      @Override
+      public boolean tryAdvance(DoubleConsumer action) {
+        // look for a new spliterator
+        while (advanceToNextSpliterator()) {
+          // if we have one, try to read and use it
+          if (next.tryAdvance(action)) {
+            return true;
+          } else {
+            nextStream = null;
+            // failed, null it out so we can find another
+            next = null;
+          }
+        }
+        return false;
+      }
+
+      private boolean advanceToNextSpliterator() {
+        while (next == null) {
+          if (!spliteratorOfStreams.tryAdvance(n -> {
+            if (n != null) {
+              nextStream = n;
+              next = n.spliterator();
+            }
+          })) {
+            return false;
+          }
+        }
+        return true;
+      }
+    });
+
+    result.onClose(a::close);
+    result.onClose(b::close);
+
+    return result;
+  }
+
+  static DoubleStream empty() {
+    return new EmptyDoubleStreamSource(null);
+  }
+
+  static DoubleStream generate(DoubleSupplier s) {
+    return StreamSupport.doubleStream(new Spliterators.AbstractDoubleSpliterator(
+        Long.MAX_VALUE,
+        Spliterator.IMMUTABLE | Spliterator.ORDERED
+    ) {
+      @Override
+      public boolean tryAdvance(DoubleConsumer action) {
+        action.accept(s.getAsDouble());
+        return true;
+      }
+    }, false);
+  }
+
+  static DoubleStream iterate(double seed, DoubleUnaryOperator f) {
+    return StreamSupport.doubleStream(new Spliterators.AbstractDoubleSpliterator(
+        Long.MAX_VALUE,
+        Spliterator.IMMUTABLE | Spliterator.ORDERED
+    ) {
+      private double next = seed;
+
+      @Override
+      public boolean tryAdvance(DoubleConsumer action) {
+        action.accept(next);
+        next = f.applyAsDouble(next);
+        return true;
+      }
+    }, false);
+  }
+
+  static DoubleStream of(double... values) {
+    return Arrays.stream(values);
+  }
+
+  static DoubleStream of(double t) {
+    // TODO consider a splittable that returns only a single value
+    return of(new double[]{t});
+  }
+
+  /**
+   * See
+   * <a href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/DoubleStream.Builder.html">
+   * the official Java API doc</a> for details.
+   */
+  public interface Builder extends DoubleConsumer {
+    @Override
+    void accept(double t);
+
+    default DoubleStream.Builder add(double t) {
+      accept(t);
+      return this;
+    }
+
+    DoubleStream build();
+  }
+
+  boolean allMatch(DoublePredicate predicate);
+
+  boolean anyMatch(DoublePredicate predicate);
+
+  OptionalDouble average();
+
+  Stream<Double> boxed();
+
+  <R> R collect(Supplier<R> supplier, ObjDoubleConsumer<R> accumulator, BiConsumer<R,R> combiner);
+
+  long count();
+
+  DoubleStream distinct();
+
+  DoubleStream filter(DoublePredicate predicate);
+
+  OptionalDouble findAny();
+
+  OptionalDouble findFirst();
+
+  DoubleStream flatMap(DoubleFunction<? extends DoubleStream> mapper);
+
+  void forEach(DoubleConsumer action);
+
+  void forEachOrdered(DoubleConsumer action);
+
+  PrimitiveIterator.OfDouble iterator();
+
+  DoubleStream limit(long maxSize);
+
+  DoubleStream map(DoubleUnaryOperator mapper);
+
+  IntStream mapToInt(DoubleToIntFunction mapper);
+
+  LongStream mapToLong(DoubleToLongFunction mapper);
+
+  <U> Stream<U> mapToObj(DoubleFunction<? extends U> mapper);
+
+  OptionalDouble max();
+
+  OptionalDouble min();
+
+  boolean noneMatch(DoublePredicate predicate);
+
+  DoubleStream parallel();
+
+  DoubleStream peek(DoubleConsumer action);
+
+  OptionalDouble reduce(DoubleBinaryOperator op);
+
+  double reduce(double identity, DoubleBinaryOperator op);
+
+  DoubleStream sequential();
+
+  DoubleStream skip(long n);
+
+  DoubleStream sorted();
+
+  Spliterator.OfDouble spliterator();
+
+  double sum();
+
+  DoubleSummaryStatistics summaryStatistics();
+
+  double[] toArray();
+
+  /**
+   * Represents an empty stream, doing nothing for all methods.
+   */
+  static class EmptyDoubleStreamSource extends TerminatableStream<EmptyDoubleStreamSource>
+      implements DoubleStream {
+    public EmptyDoubleStreamSource(TerminatableStream<?> previous) {
+      super(previous);
+    }
+
+    @Override
+    public DoubleStream filter(DoublePredicate predicate) {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public DoubleStream map(DoubleUnaryOperator mapper) {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public <U> Stream<U> mapToObj(DoubleFunction<? extends U> mapper) {
+      throwIfTerminated();
+      return new Stream.EmptyStreamSource<U>(this);
+    }
+
+    @Override
+    public IntStream mapToInt(DoubleToIntFunction mapper) {
+      throwIfTerminated();
+      return new IntStream.EmptyIntStreamSource(this);
+    }
+
+    @Override
+    public LongStream mapToLong(DoubleToLongFunction mapper) {
+      throwIfTerminated();
+      return new LongStream.EmptyLongStreamSource(this);
+    }
+
+    @Override
+    public DoubleStream flatMap(DoubleFunction<? extends DoubleStream> mapper) {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public DoubleStream distinct() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public DoubleStream sorted() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public DoubleStream peek(DoubleConsumer action) {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public DoubleStream limit(long maxSize) {
+      throwIfTerminated();
+      checkState(maxSize >= 0, "maxSize may not be negative");
+      return this;
+    }
+
+    @Override
+    public DoubleStream skip(long n) {
+      throwIfTerminated();
+      checkState(n >= 0, "n may not be negative");
+      return this;
+    }
+
+    @Override
+    public void forEach(DoubleConsumer action) {
+      terminate();
+      // do nothing
+    }
+
+    @Override
+    public void forEachOrdered(DoubleConsumer action) {
+      terminate();
+      // do nothing
+    }
+
+    @Override
+    public double[] toArray() {
+      terminate();
+      return new double[0];
+    }
+
+    @Override
+    public double reduce(double identity, DoubleBinaryOperator op) {
+      terminate();
+      return identity;
+    }
+
+    @Override
+    public OptionalDouble reduce(DoubleBinaryOperator op) {
+      terminate();
+      return OptionalDouble.empty();
+    }
+
+    @Override
+    public <R> R collect(Supplier<R> supplier,
+                         ObjDoubleConsumer<R> accumulator,
+                         BiConsumer<R, R> combiner) {
+      terminate();
+      return supplier.get();
+    }
+
+    @Override
+    public double sum() {
+      terminate();
+      return 0;
+    }
+
+    @Override
+    public OptionalDouble min() {
+      terminate();
+      return OptionalDouble.empty();
+    }
+
+    @Override
+    public OptionalDouble max() {
+      terminate();
+      return OptionalDouble.empty();
+    }
+
+    @Override
+    public long count() {
+      terminate();
+      return 0;
+    }
+
+    @Override
+    public OptionalDouble average() {
+      terminate();
+      return OptionalDouble.empty();
+    }
+
+    @Override
+    public DoubleSummaryStatistics summaryStatistics() {
+      terminate();
+      return new DoubleSummaryStatistics();
+    }
+
+    @Override
+    public boolean anyMatch(DoublePredicate predicate) {
+      terminate();
+      return false;
+    }
+
+    @Override
+    public boolean allMatch(DoublePredicate predicate) {
+      terminate();
+      return true;
+    }
+
+    @Override
+    public boolean noneMatch(DoublePredicate predicate) {
+      terminate();
+      return true;
+    }
+
+    @Override
+    public OptionalDouble findFirst() {
+      terminate();
+      return OptionalDouble.empty();
+    }
+
+    @Override
+    public OptionalDouble findAny() {
+      terminate();
+      return OptionalDouble.empty();
+    }
+
+    @Override
+    public Stream<Double> boxed() {
+      throwIfTerminated();
+      return new Stream.EmptyStreamSource<Double>(this);
+    }
+
+    @Override
+    public DoubleStream sequential() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public DoubleStream parallel() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public PrimitiveIterator.OfDouble iterator() {
+      return Spliterators.iterator(spliterator());
+    }
+
+    @Override
+    public Spliterator.OfDouble spliterator() {
+      terminate();
+      return Spliterators.emptyDoubleSpliterator();
+    }
+
+    @Override
+    public boolean isParallel() {
+      throwIfTerminated();
+      return false;
+    }
+
+    @Override
+    public DoubleStream unordered() {
+      throwIfTerminated();
+      return this;
+    }
+  }
+
+  /**
+   * Double to Int map spliterator.
+   */
+  static final class MapToIntSpliterator extends Spliterators.AbstractIntSpliterator {
+    private final DoubleToIntFunction map;
+    private final Spliterator.OfDouble original;
+
+    public MapToIntSpliterator(DoubleToIntFunction map, Spliterator.OfDouble original) {
+      super(
+          original.estimateSize(),
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
+      );
+      checkNotNull(map);
+      this.map = map;
+      this.original = original;
+    }
+
+    @Override
+    public boolean tryAdvance(final IntConsumer action) {
+      return original.tryAdvance((double u) -> action.accept(map.applyAsInt(u)));
+    }
+  }
+
+  /**
+   * Double to Object map spliterator.
+   * @param <T> the type of Object in the spliterator
+   */
+  static final class MapToObjSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
+    private final DoubleFunction<? extends T> map;
+    private final Spliterator.OfDouble original;
+
+    public MapToObjSpliterator(DoubleFunction<? extends T> map, Spliterator.OfDouble original) {
+      super(
+          original.estimateSize(),
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
+      );
+      checkNotNull(map);
+      this.map = map;
+      this.original = original;
+    }
+
+    @Override
+    public boolean tryAdvance(final Consumer<? super T> action) {
+      return original.tryAdvance((double u) -> action.accept(map.apply(u)));
+    }
+  }
+
+  /**
+   * Double to Long map spliterator.
+   */
+  static final class MapToLongSpliterator extends Spliterators.AbstractLongSpliterator {
+    private final DoubleToLongFunction map;
+    private final Spliterator.OfDouble original;
+
+    public MapToLongSpliterator(DoubleToLongFunction map, Spliterator.OfDouble original) {
+      super(
+          original.estimateSize(),
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
+      );
+      checkNotNull(map);
+      this.map = map;
+      this.original = original;
+    }
+
+    @Override
+    public boolean tryAdvance(final LongConsumer action) {
+      return original.tryAdvance((double u) -> action.accept(map.applyAsLong(u)));
+    }
+  }
+
+  /**
+   * Double to Double map spliterator.
+   */
+  static final class MapToDoubleSpliterator extends Spliterators.AbstractDoubleSpliterator {
+    private final DoubleUnaryOperator map;
+    private final Spliterator.OfDouble original;
+
+    public MapToDoubleSpliterator(DoubleUnaryOperator map, Spliterator.OfDouble original) {
+      super(
+          original.estimateSize(),
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
+      );
+      checkNotNull(map);
+      this.map = map;
+      this.original = original;
+    }
+
+    @Override
+    public boolean tryAdvance(final DoubleConsumer action) {
+      return original.tryAdvance((double u) -> action.accept(map.applyAsDouble(u)));
+    }
+  }
+
+  /**
+   * Double filter spliterator.
+   */
+  static final class FilterSpliterator extends Spliterators.AbstractDoubleSpliterator {
+    private final DoublePredicate filter;
+    private final Spliterator.OfDouble original;
+
+    private boolean found;
+
+    public FilterSpliterator(DoublePredicate filter, Spliterator.OfDouble original) {
+      super(original.estimateSize(), original.characteristics() & ~Spliterator.SIZED);
+      checkNotNull(filter);
+      this.filter = filter;
+      this.original = original;
+    }
+
+    @Override
+    public Comparator<? super Double> getComparator() {
+      return original.getComparator();
+    }
+
+    @Override
+    public boolean tryAdvance(final DoubleConsumer action) {
+      found = false;
+      while (!found && original.tryAdvance((double item) -> {
+        if (filter.test(item)) {
+          found = true;
+          action.accept(item);
+        }
+      })) {
+        // do nothing, work is done in tryAdvance
+      }
+
+      return found;
+    }
+  }
+
+  /**
+   * Double skip spliterator.
+   */
+  static final class SkipSpliterator extends Spliterators.AbstractDoubleSpliterator {
+    private long skip;
+    private final Spliterator.OfDouble original;
+
+    public SkipSpliterator(long skip, Spliterator.OfDouble original) {
+      super(
+          original.hasCharacteristics(Spliterator.SIZED)
+              ? Math.max(0, original.estimateSize() - skip)
+              : Long.MAX_VALUE,
+          original.characteristics()
+      );
+      this.skip = skip;
+      this.original = original;
+    }
+
+    @Override
+    public Comparator<? super Double> getComparator() {
+      return original.getComparator();
+    }
+
+    @Override
+    public boolean tryAdvance(DoubleConsumer action) {
+      while (skip > 0) {
+        if (!original.tryAdvance((double ignore) -> { })) {
+          return false;
+        }
+        skip--;
+      }
+      return original.tryAdvance(action);
+    }
+  }
+
+  /**
+   * Double limit spliterator.
+   */
+  static final class LimitSpliterator extends Spliterators.AbstractDoubleSpliterator {
+    private final long limit;
+    private final Spliterator.OfDouble original;
+    private int position = 0;
+
+    public LimitSpliterator(long limit, Spliterator.OfDouble original) {
+      super(
+          original.hasCharacteristics(Spliterator.SIZED)
+              ? Math.min(original.estimateSize(), limit)
+              : Long.MAX_VALUE,
+          original.characteristics()
+      );
+      this.limit = limit;
+      this.original = original;
+    }
+
+    @Override
+    public Comparator<? super Double> getComparator() {
+      return original.getComparator();
+    }
+
+    @Override
+    public boolean tryAdvance(DoubleConsumer action) {
+      if (limit <= position) {
+        return false;
+      }
+      boolean result = original.tryAdvance(action);
+      position++;
+      return result;
+    }
+  }
+
+  /**
+   * Main implementation of DoubleStream, wrapping a single spliterator, and an optional parent
+   * stream.
+   */
+  static class DoubleStreamSource extends TerminatableStream<DoubleStreamSource>
+      implements DoubleStream {
+    private final Spliterator.OfDouble spliterator;
+
+    public DoubleStreamSource(TerminatableStream<?> previous, Spliterator.OfDouble spliterator) {
+      super(previous);
+      this.spliterator = spliterator;
+    }
+
+    // terminals
+
+    @Override
+    public void forEach(DoubleConsumer action) {
+      forEachOrdered(action);
+    }
+
+    @Override
+    public void forEachOrdered(DoubleConsumer action) {
+      terminate();
+      spliterator.forEachRemaining(action);
+    }
+
+    @Override
+    public double[] toArray() {
+      terminate();
+      double[] entries = new double[0];
+      // this is legal in js, since the array will be backed by a JS array
+      spliterator.forEachRemaining((double value) -> entries[entries.length] = value);
+
+      return entries;
+    }
+
+    @Override
+    public double reduce(double identity, DoubleBinaryOperator op) {
+      terminate();
+      ValueConsumer holder = new ValueConsumer();
+      holder.value = identity;
+      spliterator.forEachRemaining((double value) -> {
+        holder.accept(op.applyAsDouble(holder.value, value));
+      });
+      return holder.value;
+    }
+
+    @Override
+    public OptionalDouble reduce(DoubleBinaryOperator op) {
+      ValueConsumer holder = new ValueConsumer();
+      if (spliterator.tryAdvance(holder)) {
+        return OptionalDouble.of(reduce(holder.value, op));
+      }
+      terminate();
+      return OptionalDouble.empty();
+    }
+
+    @Override
+    public <R> R collect(Supplier<R> supplier,
+                         ObjDoubleConsumer<R> accumulator,
+                         BiConsumer<R, R> combiner) {
+      terminate();
+      final R acc = supplier.get();
+      spliterator.forEachRemaining((double value) -> accumulator.accept(acc, value));
+      return acc;
+    }
+
+    @Override
+    public double sum() {
+      return summaryStatistics().getSum();
+    }
+
+    @Override
+    public OptionalDouble min() {
+      terminate();
+      final ValueConsumer holder = new ValueConsumer();
+      if (spliterator.tryAdvance((double value) -> holder.value = value)) {
+        spliterator.forEachRemaining((double value) -> {
+          holder.value = Math.min(holder.value, value);
+        });
+        return OptionalDouble.of(holder.value);
+      }
+      return OptionalDouble.empty();
+    }
+
+    @Override
+    public OptionalDouble max() {
+      terminate();
+      final ValueConsumer holder = new ValueConsumer();
+      if (spliterator.tryAdvance((double value) -> holder.value = value)) {
+        spliterator.forEachRemaining((double value) -> {
+          holder.value = Math.max(holder.value, value);
+        });
+        return OptionalDouble.of(holder.value);
+      }
+      return OptionalDouble.empty();
+    }
+
+    @Override
+    public long count() {
+      terminate();
+      long count = 0;
+      while (spliterator.tryAdvance((double value) -> { })) {
+        count++;
+      }
+      return count;
+    }
+
+    @Override
+    public OptionalDouble average() {
+      DoubleSummaryStatistics stats = summaryStatistics();
+      if (stats.getCount() == 0) {
+        return OptionalDouble.empty();
+      }
+      return OptionalDouble.of(stats.getAverage());
+    }
+
+    @Override
+    public DoubleSummaryStatistics summaryStatistics() {
+      return collect(
+          DoubleSummaryStatistics::new,
+          // TODO switch to a lambda reference once #9340 is fixed
+          (doubleSummaryStatistics, value) -> doubleSummaryStatistics.accept(value),
+          DoubleSummaryStatistics::combine
+      );
+    }
+
+    @Override
+    public boolean anyMatch(DoublePredicate predicate) {
+      return filter(predicate).findFirst().isPresent();
+    }
+
+    @Override
+    public boolean allMatch(DoublePredicate predicate) {
+      return !anyMatch(predicate.negate());
+    }
+
+    @Override
+    public boolean noneMatch(DoublePredicate predicate) {
+      return !anyMatch(predicate);
+    }
+
+    @Override
+    public OptionalDouble findFirst() {
+      terminate();
+      ValueConsumer holder = new ValueConsumer();
+      if (spliterator.tryAdvance(holder)) {
+        return OptionalDouble.of(holder.value);
+      }
+      return OptionalDouble.empty();
+    }
+
+    @Override
+    public OptionalDouble findAny() {
+      return findFirst();
+    }
+
+    @Override
+    public PrimitiveIterator.OfDouble iterator() {
+      return Spliterators.iterator(spliterator());
+    }
+
+    @Override
+    public Spliterator.OfDouble spliterator() {
+      terminate();
+      return spliterator;
+    }
+
+    // end terminals
+
+    // intermediates
+
+    @Override
+    public DoubleStream filter(DoublePredicate predicate) {
+      throwIfTerminated();
+      return new DoubleStreamSource(this, new FilterSpliterator(predicate, spliterator));
+    }
+
+    @Override
+    public DoubleStream map(DoubleUnaryOperator mapper) {
+      throwIfTerminated();
+      return new DoubleStreamSource(this, new MapToDoubleSpliterator(mapper, spliterator));
+    }
+
+    @Override
+    public <U> Stream<U> mapToObj(DoubleFunction<? extends U> mapper) {
+      throwIfTerminated();
+      return new Stream.StreamSource(this, new MapToObjSpliterator<U>(mapper, spliterator));
+    }
+
+    @Override
+    public IntStream mapToInt(DoubleToIntFunction mapper) {
+      throwIfTerminated();
+      return new IntStream.IntStreamSource(this, new MapToIntSpliterator(mapper, spliterator));
+    }
+
+    @Override
+    public LongStream mapToLong(DoubleToLongFunction mapper) {
+      throwIfTerminated();
+      return new LongStream.LongStreamSource(this, new MapToLongSpliterator(mapper, spliterator));
+    }
+
+    @Override
+    public DoubleStream flatMap(DoubleFunction<? extends DoubleStream> mapper) {
+      throwIfTerminated();
+      final Spliterator<? extends DoubleStream> spliteratorOfStreams =
+          new MapToObjSpliterator<DoubleStream>(mapper, spliterator);
+      return new DoubleStreamSource(this, new Spliterators.AbstractDoubleSpliterator(
+          Long.MAX_VALUE,
+          0
+      ) {
+        DoubleStream nextStream;
+        Spliterator.OfDouble next;
+
+        @Override
+        public boolean tryAdvance(DoubleConsumer action) {
+          // look for a new spliterator
+          while (advanceToNextSpliterator()) {
+            // if we have one, try to read and use it
+            if (next.tryAdvance(action)) {
+              return true;
+            } else {
+              nextStream.close();
+              nextStream = null;
+              // failed, null it out so we can find another
+              next = null;
+            }
+          }
+          return false;
+        }
+
+        private boolean advanceToNextSpliterator() {
+          while (next == null) {
+            if (!spliteratorOfStreams.tryAdvance(n -> {
+              if (n != null) {
+                nextStream = n;
+                next = n.spliterator();
+              }
+            })) {
+              return false;
+            }
+          }
+          return true;
+        }
+      });
+    }
+
+    @Override
+    public DoubleStream distinct() {
+      throwIfTerminated();
+      HashSet<Double> seen = new HashSet<>();
+      return filter(seen::add);
+    }
+
+    @Override
+    public DoubleStream sorted() {
+      throwIfTerminated();
+      return new DoubleStreamSource(this, new Spliterators.AbstractDoubleSpliterator(
+          spliterator.estimateSize(),
+          spliterator.characteristics() | Spliterator.SORTED
+      ) {
+        Spliterator.OfDouble ordered = null;
+
+        @Override
+        public Comparator<? super Double> getComparator() {
+          return null;
+        }
+
+        @Override
+        public boolean tryAdvance(DoubleConsumer action) {
+          if (ordered == null) {
+            double[] list = new double[0];
+            spliterator.forEachRemaining((double item) -> list[list.length] = item);
+            Arrays.sort(list);
+            ordered = Spliterators.spliterator(list, characteristics());
+          }
+          return ordered.tryAdvance(action);
+        }
+      });
+    }
+
+    @Override
+    public DoubleStream peek(DoubleConsumer action) {
+      checkNotNull(action);
+      throwIfTerminated();
+      return new DoubleStreamSource(this, new Spliterators.AbstractDoubleSpliterator(
+          spliterator.estimateSize(),
+          spliterator.characteristics()
+      ) {
+        @Override
+        public boolean tryAdvance(final DoubleConsumer innerAction) {
+          return spliterator.tryAdvance(action.andThen(innerAction));
+        }
+      });
+    }
+
+    @Override
+    public DoubleStream limit(long maxSize) {
+      throwIfTerminated();
+      checkState(maxSize >= 0, "maxSize may not be negative");
+      return new DoubleStreamSource(this, new LimitSpliterator(maxSize, spliterator));
+    }
+
+    @Override
+    public DoubleStream skip(long n) {
+      throwIfTerminated();
+      checkState(n >= 0, "n may not be negative");
+      if (n == 0) {
+        return this;
+      }
+      return new DoubleStreamSource(this, new SkipSpliterator(n, spliterator));
+    }
+
+    @Override
+    public Stream<Double> boxed() {
+      return mapToObj(Double::valueOf);
+    }
+
+    @Override
+    public DoubleStream sequential() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public DoubleStream parallel() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public boolean isParallel() {
+      throwIfTerminated();
+      return false;
+    }
+
+    @Override
+    public DoubleStream unordered() {
+      throwIfTerminated();
+      return this;
+    }
+  }
+}

diff --git a/user/super/com/google/gwt/emul/java/util/stream/IntStream.java b/user/super/com/google/gwt/emul/java/util/stream/IntStream.java
new file mode 100644
index 0000000..8a0816e
--- /dev/null
+++ b/user/super/com/google/gwt/emul/java/util/stream/IntStream.java

@@ -0,0 +1,1081 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package java.util.stream;
+
+import static javaemul.internal.InternalPreconditions.checkCriticalState;
+import static javaemul.internal.InternalPreconditions.checkNotNull;
+import static javaemul.internal.InternalPreconditions.checkState;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.IntSummaryStatistics;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.PrimitiveIterator;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.DoubleConsumer;
+import java.util.function.IntBinaryOperator;
+import java.util.function.IntConsumer;
+import java.util.function.IntFunction;
+import java.util.function.IntPredicate;
+import java.util.function.IntSupplier;
+import java.util.function.IntToDoubleFunction;
+import java.util.function.IntToLongFunction;
+import java.util.function.IntUnaryOperator;
+import java.util.function.LongConsumer;
+import java.util.function.ObjIntConsumer;
+import java.util.function.Supplier;
+
+/**
+ * See <a href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/IntStream.html">
+ * the official Java API doc</a> for details.
+ */
+public interface IntStream extends BaseStream<Integer,IntStream> {
+
+  /**
+   * Value holder for various stream operations.
+   */
+  static final class ValueConsumer implements IntConsumer {
+    int value;
+
+    @Override
+    public void accept(int value) {
+      this.value = value;
+    }
+  }
+
+  static IntStream.Builder builder() {
+    return new Builder() {
+      private int[] items = new int[0];
+
+      @Override
+      public void accept(int t) {
+        checkState(items != null, "Builder already built");
+        items[items.length] = t;
+      }
+
+      @Override
+      public IntStream build() {
+        checkCriticalState(items != null, "Builder already built");
+        IntStream stream = Arrays.stream(items);
+        items = null;
+        return stream;
+      }
+    };
+  }
+
+  static IntStream concat(IntStream a, IntStream b) {
+    // This is nearly the same as flatMap, but inlined, wrapped around a single spliterator of
+    // these two objects, and without close() called as the stream progresses. Instead, close is
+    // invoked as part of the resulting stream's own onClose, so that either can fail without
+    // affecting the other, and correctly collecting suppressed exceptions.
+
+    // TODO replace this flatMap-ish spliterator with one that directly combines the two root
+    // streams
+    Spliterator<? extends IntStream> spliteratorOfStreams =
+        Arrays.asList(a, b).spliterator();
+    IntStream result = new IntStreamSource(null, new Spliterators.AbstractIntSpliterator(Long
+        .MAX_VALUE, 0) {
+      IntStream nextStream;
+      Spliterator.OfInt next;
+
+      @Override
+      public boolean tryAdvance(IntConsumer action) {
+        // look for a new spliterator
+        while (advanceToNextSpliterator()) {
+          // if we have one, try to read and use it
+          if (next.tryAdvance(action)) {
+            return true;
+          } else {
+            nextStream = null;
+            // failed, null it out so we can find another
+            next = null;
+          }
+        }
+        return false;
+      }
+
+      private boolean advanceToNextSpliterator() {
+        while (next == null) {
+          if (!spliteratorOfStreams.tryAdvance(n -> {
+            if (n != null) {
+              nextStream = n;
+              next = n.spliterator();
+            }
+          })) {
+            return false;
+          }
+        }
+        return true;
+      }
+    });
+
+    result.onClose(a::close);
+    result.onClose(b::close);
+
+    return result;
+  }
+
+  static IntStream empty() {
+    return new EmptyIntStreamSource(null);
+  }
+
+  static IntStream generate(final IntSupplier s) {
+    return StreamSupport.intStream(new Spliterators.AbstractIntSpliterator(
+        Long.MAX_VALUE,
+        Spliterator.IMMUTABLE | Spliterator.ORDERED
+    ) {
+      @Override
+      public boolean tryAdvance(IntConsumer action) {
+        action.accept(s.getAsInt());
+        return true;
+      }
+    }, false);
+  }
+
+  static IntStream iterate(int seed, IntUnaryOperator f) {
+    return StreamSupport.intStream(new Spliterators.AbstractIntSpliterator(
+        Long.MAX_VALUE,
+        Spliterator.IMMUTABLE | Spliterator.ORDERED
+    ) {
+      private int next = seed;
+
+      @Override
+      public boolean tryAdvance(IntConsumer action) {
+        action.accept(next);
+        next = f.applyAsInt(next);
+        return true;
+      }
+    }, false);
+  }
+
+  static IntStream of(int... values) {
+    return Arrays.stream(values);
+  }
+
+  static IntStream of(int t) {
+    // TODO consider a splittable that returns only a single value
+    return of(new int[]{t});
+  }
+
+  static IntStream range(int startInclusive, int endExclusive) {
+    if (startInclusive >= endExclusive) {
+      return empty();
+    }
+    return rangeClosed(startInclusive, endExclusive - 1);
+  }
+
+  static IntStream rangeClosed(int startInclusive, int endInclusive) {
+    if (startInclusive > endInclusive) {
+      return empty();
+    }
+    int count = endInclusive - startInclusive + 1;
+
+    return StreamSupport.intStream(new Spliterators.AbstractIntSpliterator(
+        count,
+        Spliterator.IMMUTABLE | Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.ORDERED
+            | Spliterator.SORTED | Spliterator.DISTINCT
+    ) {
+      private int next = startInclusive;
+
+      @Override
+      public Comparator<? super Integer> getComparator() {
+        return null;
+      }
+
+      @Override
+      public boolean tryAdvance(IntConsumer action) {
+        if (next <= endInclusive) {
+          action.accept(next++);
+          return true;
+        }
+        return false;
+      }
+    }, false);
+  }
+
+  /**
+   * See
+   * <a href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/IntStream.Builder.html">
+   * the official Java API doc</a> for details.
+   */
+  public interface Builder extends IntConsumer {
+    @Override
+    void accept(int t);
+
+    default IntStream.Builder add(int t) {
+      accept(t);
+      return this;
+    }
+
+    IntStream build();
+  }
+
+  boolean allMatch(IntPredicate predicate);
+
+  boolean anyMatch(IntPredicate predicate);
+
+  DoubleStream asDoubleStream();
+
+  LongStream asLongStream();
+
+  OptionalDouble average();
+
+  Stream<Integer> boxed();
+
+  <R> R collect(Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R,R> combiner);
+
+  long count();
+
+  IntStream distinct();
+
+  IntStream filter(IntPredicate predicate);
+
+  OptionalInt findAny();
+
+  OptionalInt findFirst();
+
+  IntStream flatMap(IntFunction<? extends IntStream> mapper);
+
+  void forEach(IntConsumer action);
+
+  void forEachOrdered(IntConsumer action);
+
+  PrimitiveIterator.OfInt iterator();
+
+  IntStream limit(long maxSize);
+
+  IntStream map(IntUnaryOperator mapper);
+
+  DoubleStream mapToDouble(IntToDoubleFunction mapper);
+
+  LongStream mapToLong(IntToLongFunction mapper);
+
+  <U> Stream<U> mapToObj(IntFunction<? extends U> mapper);
+
+  OptionalInt max();
+
+  OptionalInt min();
+
+  boolean noneMatch(IntPredicate predicate);
+
+  IntStream parallel();
+
+  IntStream peek(IntConsumer action);
+
+  OptionalInt reduce(IntBinaryOperator op);
+
+  int reduce(int identity, IntBinaryOperator op);
+
+  IntStream sequential();
+
+  IntStream skip(long n);
+
+  IntStream sorted();
+
+  Spliterator.OfInt spliterator();
+
+  int sum();
+
+  IntSummaryStatistics summaryStatistics();
+
+  int[] toArray();
+
+  /**
+   * Represents an empty stream, doing nothing for all methods.
+   */
+  static class EmptyIntStreamSource extends TerminatableStream<EmptyIntStreamSource>
+      implements IntStream {
+    public EmptyIntStreamSource(TerminatableStream<?> previous) {
+      super(previous);
+    }
+
+    @Override
+    public IntStream filter(IntPredicate predicate) {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public IntStream map(IntUnaryOperator mapper) {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public <U> Stream<U> mapToObj(IntFunction<? extends U> mapper) {
+      throwIfTerminated();
+      return new Stream.EmptyStreamSource<U>(this);
+    }
+
+    @Override
+    public LongStream mapToLong(IntToLongFunction mapper) {
+      throwIfTerminated();
+      return new LongStream.EmptyLongStreamSource(this);
+    }
+
+    @Override
+    public DoubleStream mapToDouble(IntToDoubleFunction mapper) {
+      throwIfTerminated();
+      return new DoubleStream.EmptyDoubleStreamSource(this);
+    }
+
+    @Override
+    public IntStream flatMap(IntFunction<? extends IntStream> mapper) {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public IntStream distinct() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public IntStream sorted() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public IntStream peek(IntConsumer action) {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public IntStream limit(long maxSize) {
+      throwIfTerminated();
+      checkState(maxSize >= 0, "maxSize may not be negative");
+      return this;
+    }
+
+    @Override
+    public IntStream skip(long n) {
+      throwIfTerminated();
+      checkState(n >= 0, "n may not be negative");
+      return this;
+    }
+
+    @Override
+    public void forEach(IntConsumer action) {
+      terminate();
+      // do nothing
+    }
+
+    @Override
+    public void forEachOrdered(IntConsumer action) {
+      terminate();
+      // do nothing
+    }
+
+    @Override
+    public int[] toArray() {
+      terminate();
+      return new int[0];
+    }
+
+    @Override
+    public int reduce(int identity, IntBinaryOperator op) {
+      terminate();
+      return identity;
+    }
+
+    @Override
+    public OptionalInt reduce(IntBinaryOperator op) {
+      terminate();
+      return OptionalInt.empty();
+    }
+
+    @Override
+    public <R> R collect(Supplier<R> supplier,
+                         ObjIntConsumer<R> accumulator,
+                         BiConsumer<R, R> combiner) {
+      terminate();
+      return supplier.get();
+    }
+
+    @Override
+    public int sum() {
+      terminate();
+      return 0;
+    }
+
+    @Override
+    public OptionalInt min() {
+      terminate();
+      return OptionalInt.empty();
+    }
+
+    @Override
+    public OptionalInt max() {
+      terminate();
+      return OptionalInt.empty();
+    }
+
+    @Override
+    public long count() {
+      terminate();
+      return 0;
+    }
+
+    @Override
+    public OptionalDouble average() {
+      terminate();
+      return OptionalDouble.empty();
+    }
+
+    @Override
+    public IntSummaryStatistics summaryStatistics() {
+      terminate();
+      return new IntSummaryStatistics();
+    }
+
+    @Override
+    public boolean anyMatch(IntPredicate predicate) {
+      terminate();
+      return false;
+    }
+
+    @Override
+    public boolean allMatch(IntPredicate predicate) {
+      terminate();
+      return true;
+    }
+
+    @Override
+    public boolean noneMatch(IntPredicate predicate) {
+      terminate();
+      return true;
+    }
+
+    @Override
+    public OptionalInt findFirst() {
+      terminate();
+      return OptionalInt.empty();
+    }
+
+    @Override
+    public OptionalInt findAny() {
+      terminate();
+      return OptionalInt.empty();
+    }
+
+    @Override
+    public LongStream asLongStream() {
+      throwIfTerminated();
+      return new LongStream.EmptyLongStreamSource(this);
+    }
+
+    @Override
+    public DoubleStream asDoubleStream() {
+      throwIfTerminated();
+      return new DoubleStream.EmptyDoubleStreamSource(this);
+    }
+
+    @Override
+    public Stream<Integer> boxed() {
+      throwIfTerminated();
+      return new Stream.EmptyStreamSource<Integer>(this);
+    }
+
+    @Override
+    public IntStream sequential() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public IntStream parallel() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public PrimitiveIterator.OfInt iterator() {
+      return Spliterators.iterator(spliterator());
+    }
+
+    @Override
+    public Spliterator.OfInt spliterator() {
+      terminate();
+      return Spliterators.emptyIntSpliterator();
+    }
+
+    @Override
+    public boolean isParallel() {
+      throwIfTerminated();
+      return false;
+    }
+
+    @Override
+    public IntStream unordered() {
+      throwIfTerminated();
+      return this;
+    }
+  }
+
+  /**
+   * Int to Int map spliterator.
+   */
+  static final class MapToIntSpliterator extends Spliterators.AbstractIntSpliterator {
+    private final IntUnaryOperator map;
+    private final Spliterator.OfInt original;
+
+    public MapToIntSpliterator(IntUnaryOperator map, Spliterator.OfInt original) {
+      super(
+          original.estimateSize(),
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
+      );
+      checkNotNull(map);
+      this.map = map;
+      this.original = original;
+    }
+
+    @Override
+    public boolean tryAdvance(final IntConsumer action) {
+      return original.tryAdvance((int u) -> action.accept(map.applyAsInt(u)));
+    }
+  }
+
+  /**
+   * Int to Object map spliterator.
+   * @param <T> the type of data in the object spliterator
+   */
+  static final class MapToObjSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
+    private final IntFunction<? extends T> map;
+    private final Spliterator.OfInt original;
+
+    public MapToObjSpliterator(IntFunction<? extends T> map, Spliterator.OfInt original) {
+      super(
+          original.estimateSize(),
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
+      );
+      checkNotNull(map);
+      this.map = map;
+      this.original = original;
+    }
+
+    @Override
+    public boolean tryAdvance(final Consumer<? super T> action) {
+      return original.tryAdvance((int u) -> action.accept(map.apply(u)));
+    }
+  }
+
+  /**
+   * Int to Long map spliterator.
+   */
+  static final class MapToLongSpliterator extends Spliterators.AbstractLongSpliterator {
+    private final IntToLongFunction map;
+    private final Spliterator.OfInt original;
+
+    public MapToLongSpliterator(IntToLongFunction map, Spliterator.OfInt original) {
+      super(
+          original.estimateSize(),
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
+      );
+      checkNotNull(map);
+      this.map = map;
+      this.original = original;
+    }
+
+    @Override
+    public boolean tryAdvance(final LongConsumer action) {
+      return original.tryAdvance((int u) -> action.accept(map.applyAsLong(u)));
+    }
+  }
+
+  /**
+   * Int to Double map spliterator.
+   */
+  static final class MapToDoubleSpliterator extends Spliterators.AbstractDoubleSpliterator {
+    private final IntToDoubleFunction map;
+    private final Spliterator.OfInt original;
+
+    public MapToDoubleSpliterator(IntToDoubleFunction map, Spliterator.OfInt original) {
+      super(
+          original.estimateSize(),
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
+      );
+      checkNotNull(map);
+      this.map = map;
+      this.original = original;
+    }
+
+    @Override
+    public boolean tryAdvance(final DoubleConsumer action) {
+      return original.tryAdvance((int u) -> action.accept(map.applyAsDouble(u)));
+    }
+  }
+
+  /**
+   * Int filter spliterator.
+   */
+  static final class FilterSpliterator extends Spliterators.AbstractIntSpliterator {
+    private final IntPredicate filter;
+    private final Spliterator.OfInt original;
+
+    private boolean found;
+
+    public FilterSpliterator(IntPredicate filter, Spliterator.OfInt original) {
+      super(original.estimateSize(), original.characteristics() & ~Spliterator.SIZED);
+      checkNotNull(filter);
+      this.filter = filter;
+      this.original = original;
+    }
+
+    @Override
+    public Comparator<? super Integer> getComparator() {
+      return original.getComparator();
+    }
+
+    @Override
+    public boolean tryAdvance(final IntConsumer action) {
+      found = false;
+      while (!found && original.tryAdvance((int item) -> {
+        if (filter.test(item)) {
+          found = true;
+          action.accept(item);
+        }
+      })) {
+        // do nothing, work is done in tryAdvance
+      }
+
+      return found;
+    }
+  }
+
+  /**
+   * Int skip spliterator.
+   */
+  static final class SkipSpliterator extends Spliterators.AbstractIntSpliterator {
+    private long skip;
+    private final Spliterator.OfInt original;
+
+    public SkipSpliterator(long skip, Spliterator.OfInt original) {
+      super(
+          original.hasCharacteristics(Spliterator.SIZED)
+              ? Math.max(0, original.estimateSize() - skip)
+              : Long.MAX_VALUE,
+          original.characteristics()
+      );
+      this.skip = skip;
+      this.original = original;
+    }
+
+    @Override
+    public Comparator<? super Integer> getComparator() {
+      return original.getComparator();
+    }
+
+    @Override
+    public boolean tryAdvance(IntConsumer action) {
+      while (skip > 0) {
+        if (!original.tryAdvance((int ignore) -> { })) {
+          return false;
+        }
+        skip--;
+      }
+      return original.tryAdvance(action);
+    }
+  }
+
+  /**
+   * Int limit spliterator.
+   */
+  static final class LimitSpliterator extends Spliterators.AbstractIntSpliterator {
+    private final long limit;
+    private final Spliterator.OfInt original;
+    private int position = 0;
+
+    public LimitSpliterator(long limit, Spliterator.OfInt original) {
+      super(
+          original.hasCharacteristics(Spliterator.SIZED)
+              ? Math.min(original.estimateSize(), limit)
+              : Long.MAX_VALUE,
+          original.characteristics()
+      );
+      this.limit = limit;
+      this.original = original;
+    }
+
+    @Override
+    public Comparator<? super Integer> getComparator() {
+      return original.getComparator();
+    }
+
+    @Override
+    public boolean tryAdvance(IntConsumer action) {
+      if (limit <= position) {
+        return false;
+      }
+      boolean result = original.tryAdvance(action);
+      position++;
+      return result;
+    }
+  }
+
+  /**
+   * Main implementation of IntStream, wrapping a single spliterator, and an optional parent stream.
+   */
+  static class IntStreamSource extends TerminatableStream<IntStreamSource> implements IntStream {
+    private final Spliterator.OfInt spliterator;
+
+    public IntStreamSource(TerminatableStream<?> previous, Spliterator.OfInt spliterator) {
+      super(previous);
+      this.spliterator = spliterator;
+    }
+
+    // terminals
+    @Override
+    public Spliterator.OfInt spliterator() {
+      terminate();
+      return spliterator;
+    }
+
+    @Override
+    public PrimitiveIterator.OfInt iterator() {
+      return Spliterators.iterator(spliterator());
+    }
+
+    @Override
+    public OptionalInt findFirst() {
+      terminate();
+      ValueConsumer holder = new ValueConsumer();
+      if (spliterator.tryAdvance(holder)) {
+        return OptionalInt.of(holder.value);
+      }
+      return OptionalInt.empty();
+    }
+
+    @Override
+    public OptionalInt findAny() {
+      return findFirst();
+    }
+
+    @Override
+    public boolean noneMatch(IntPredicate predicate) {
+      return !anyMatch(predicate);
+    }
+
+    @Override
+    public boolean allMatch(IntPredicate predicate) {
+      return !anyMatch(predicate.negate());
+    }
+
+    @Override
+    public boolean anyMatch(IntPredicate predicate) {
+      return filter(predicate).findFirst().isPresent();
+    }
+
+    @Override
+    public IntSummaryStatistics summaryStatistics() {
+      return collect(
+          IntSummaryStatistics::new,
+          // TODO switch to a lambda reference once #9340 is fixed
+          (intSummaryStatistics, value) -> intSummaryStatistics.accept(value),
+          IntSummaryStatistics::combine
+      );
+    }
+
+    @Override
+    public OptionalDouble average() {
+      IntSummaryStatistics stats = summaryStatistics();
+      if (stats.getCount() == 0) {
+        return OptionalDouble.empty();
+      }
+      return OptionalDouble.of(stats.getAverage());
+    }
+
+    @Override
+    public long count() {
+      terminate();
+      long count = 0;
+      while (spliterator.tryAdvance((int value) -> { })) {
+        count++;
+      }
+      return count;
+    }
+
+    @Override
+    public OptionalInt max() {
+      terminate();
+      final ValueConsumer holder = new ValueConsumer();
+      if (spliterator.tryAdvance((int value) -> holder.value = value)) {
+        spliterator.forEachRemaining((int value) -> holder.value = Math.max(holder.value, value));
+        return OptionalInt.of(holder.value);
+      }
+      return OptionalInt.empty();
+    }
+
+    @Override
+    public OptionalInt min() {
+      terminate();
+      final ValueConsumer holder = new ValueConsumer();
+      if (spliterator.tryAdvance((int value) -> holder.value = value)) {
+        spliterator.forEachRemaining((int value) -> holder.value = Math.min(holder.value, value));
+        return OptionalInt.of(holder.value);
+      }
+      return OptionalInt.empty();
+    }
+
+    @Override
+    public int sum() {
+      return (int) summaryStatistics().getSum();
+    }
+
+    @Override
+    public <R> R collect(Supplier<R> supplier,
+                         final ObjIntConsumer<R> accumulator,
+                         BiConsumer<R, R> combiner) {
+      terminate();
+      final R acc = supplier.get();
+      spliterator.forEachRemaining((int value) -> accumulator.accept(acc, value));
+      return acc;
+    }
+
+    @Override
+    public OptionalInt reduce(IntBinaryOperator op) {
+      ValueConsumer holder = new ValueConsumer();
+      if (spliterator.tryAdvance(holder)) {
+        return OptionalInt.of(reduce(holder.value, op));
+      }
+      terminate();
+      return OptionalInt.empty();
+    }
+
+    @Override
+    public int reduce(int identity, IntBinaryOperator op) {
+      terminate();
+      ValueConsumer holder = new ValueConsumer();
+      holder.value = identity;
+      spliterator.forEachRemaining((int value) -> {
+        holder.accept(op.applyAsInt(holder.value, value));
+      });
+      return holder.value;
+    }
+
+    @Override
+    public int[] toArray() {
+      terminate();
+      int[] entries = new int[0];
+      // this is legal in js, since the array will be backed by a JS array
+      spliterator.forEachRemaining((int value) -> entries[entries.length] = value);
+
+      return entries;
+    }
+
+    @Override
+    public void forEachOrdered(IntConsumer action) {
+      terminate();
+      spliterator.forEachRemaining(action);
+    }
+
+    @Override
+    public void forEach(IntConsumer action) {
+      forEachOrdered(action);
+    }
+    // end terminals
+
+    // intermediates
+
+    @Override
+    public IntStream filter(IntPredicate predicate) {
+      throwIfTerminated();
+      return new IntStreamSource(this, new FilterSpliterator(predicate, spliterator));
+    }
+
+    @Override
+    public IntStream map(IntUnaryOperator mapper) {
+      throwIfTerminated();
+      return new IntStreamSource(this, new MapToIntSpliterator(mapper, spliterator));
+    }
+
+    @Override
+    public <U> Stream<U> mapToObj(IntFunction<? extends U> mapper) {
+      throwIfTerminated();
+      return new Stream.StreamSource(this, new MapToObjSpliterator<U>(mapper, spliterator));
+    }
+
+    @Override
+    public LongStream mapToLong(IntToLongFunction mapper) {
+      throwIfTerminated();
+      return new LongStream.LongStreamSource(this, new MapToLongSpliterator(mapper, spliterator));
+    }
+
+    @Override
+    public DoubleStream mapToDouble(IntToDoubleFunction mapper) {
+      throwIfTerminated();
+      return new DoubleStream.DoubleStreamSource(
+          this,
+          new MapToDoubleSpliterator(mapper, spliterator)
+      );
+    }
+
+    @Override
+    public IntStream flatMap(IntFunction<? extends IntStream> mapper) {
+      throwIfTerminated();
+      final Spliterator<? extends IntStream> spliteratorOfStreams =
+          new MapToObjSpliterator<>(mapper, spliterator);
+      return new IntStreamSource(this, new Spliterators.AbstractIntSpliterator(Long.MAX_VALUE, 0) {
+        IntStream nextStream;
+        Spliterator.OfInt next;
+
+        @Override
+        public boolean tryAdvance(IntConsumer action) {
+          // look for a new spliterator
+          while (advanceToNextSpliterator()) {
+            // if we have one, try to read and use it
+            if (next.tryAdvance(action)) {
+              return true;
+            } else {
+              nextStream.close();
+              nextStream = null;
+              // failed, null it out so we can find another
+              next = null;
+            }
+          }
+          return false;
+        }
+
+        private boolean advanceToNextSpliterator() {
+          while (next == null) {
+            if (!spliteratorOfStreams.tryAdvance(n -> {
+              if (n != null) {
+                nextStream = n;
+                next = n.spliterator();
+              }
+            })) {
+              return false;
+            }
+          }
+          return true;
+        }
+      });
+    }
+
+    @Override
+    public IntStream distinct() {
+      throwIfTerminated();
+      HashSet<Integer> seen = new HashSet<>();
+      return filter(seen::add);
+    }
+
+    @Override
+    public IntStream sorted() {
+      throwIfTerminated();
+      return new IntStreamSource(this, new Spliterators.AbstractIntSpliterator(
+          spliterator.estimateSize(),
+          spliterator.characteristics() | Spliterator.SORTED
+      ) {
+        Spliterator.OfInt ordered = null;
+
+        @Override
+        public Comparator<? super Integer> getComparator() {
+          return null;
+        }
+
+        @Override
+        public boolean tryAdvance(IntConsumer action) {
+          if (ordered == null) {
+            int[] list = new int[0];
+            spliterator.forEachRemaining((int item) -> list[list.length] = item);
+            Arrays.sort(list);
+            ordered = Spliterators.spliterator(list, characteristics());
+          }
+          return ordered.tryAdvance(action);
+        }
+      });
+    }
+
+    @Override
+    public IntStream peek(IntConsumer action) {
+      checkNotNull(action);
+      throwIfTerminated();
+      return new IntStreamSource(this, new Spliterators.AbstractIntSpliterator(
+          spliterator.estimateSize(),
+          spliterator.characteristics()
+      ) {
+        @Override
+        public boolean tryAdvance(final IntConsumer innerAction) {
+          return spliterator.tryAdvance(action.andThen(innerAction));
+        }
+      });
+    }
+
+    @Override
+    public IntStream limit(long maxSize) {
+      throwIfTerminated();
+      checkState(maxSize >= 0, "maxSize may not be negative");
+      return new IntStreamSource(this, new LimitSpliterator(maxSize, spliterator));
+    }
+
+    @Override
+    public IntStream skip(long n) {
+      throwIfTerminated();
+      checkState(n >= 0, "n may not be negative");
+      if (n == 0) {
+        return this;
+      }
+      return new IntStreamSource(this, new SkipSpliterator(n, spliterator));
+    }
+
+    @Override
+    public LongStream asLongStream() {
+      return mapToLong(i -> (long) i);
+    }
+
+    @Override
+    public DoubleStream asDoubleStream() {
+      return mapToDouble(i -> (double) i);
+    }
+
+    @Override
+    public Stream<Integer> boxed() {
+      return mapToObj(Integer::valueOf);
+    }
+
+    @Override
+    public IntStream sequential() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public IntStream parallel() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public boolean isParallel() {
+      throwIfTerminated();
+      return false;
+    }
+
+    @Override
+    public IntStream unordered() {
+      throwIfTerminated();
+      return this;
+    }
+  }
+}

diff --git a/user/super/com/google/gwt/emul/java/util/stream/LongStream.java b/user/super/com/google/gwt/emul/java/util/stream/LongStream.java
new file mode 100644
index 0000000..f2b6ba1
--- /dev/null
+++ b/user/super/com/google/gwt/emul/java/util/stream/LongStream.java

@@ -0,0 +1,1072 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package java.util.stream;
+
+import static javaemul.internal.InternalPreconditions.checkCriticalState;
+import static javaemul.internal.InternalPreconditions.checkNotNull;
+import static javaemul.internal.InternalPreconditions.checkState;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LongSummaryStatistics;
+import java.util.OptionalDouble;
+import java.util.OptionalLong;
+import java.util.PrimitiveIterator;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.DoubleConsumer;
+import java.util.function.IntConsumer;
+import java.util.function.LongBinaryOperator;
+import java.util.function.LongConsumer;
+import java.util.function.LongFunction;
+import java.util.function.LongPredicate;
+import java.util.function.LongSupplier;
+import java.util.function.LongToDoubleFunction;
+import java.util.function.LongToIntFunction;
+import java.util.function.LongUnaryOperator;
+import java.util.function.ObjLongConsumer;
+import java.util.function.Supplier;
+
+/**
+ * See <a href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/LongStream.html">
+ * the official Java API doc</a> for details.
+ */
+public interface LongStream extends BaseStream<Long,LongStream> {
+
+  /**
+   * Value holder for various stream operations.
+   */
+  static final class ValueConsumer implements LongConsumer {
+    long value;
+
+    @Override
+    public void accept(long value) {
+      this.value = value;
+    }
+  }
+
+  static LongStream.Builder builder() {
+    return new Builder() {
+      private long[] items = new long[0];
+
+      @Override
+      public void accept(long t) {
+        checkState(items != null, "Builder already built");
+        items[items.length] = t;
+      }
+
+      @Override
+      public LongStream build() {
+        checkCriticalState(items != null, "Builder already built");
+        LongStream stream = Arrays.stream(items);
+        items = null;
+        return stream;
+      }
+    };
+  }
+
+  static LongStream concat(LongStream a, LongStream b) {
+    // This is nearly the same as flatMap, but inlined, wrapped around a single spliterator of
+    // these two objects, and without close() called as the stream progresses. Instead, close is
+    // invoked as part of the resulting stream's own onClose, so that either can fail without
+    // affecting the other, and correctly collecting suppressed exceptions.
+
+    // TODO replace this flatMap-ish spliterator with one that directly combines the two root
+    // streams
+    Spliterator<? extends LongStream> spliteratorOfStreams =
+        Arrays.asList(a, b).spliterator();
+    LongStream result = new LongStreamSource(null, new Spliterators.AbstractLongSpliterator(Long
+        .MAX_VALUE, 0) {
+      LongStream nextStream;
+      Spliterator.OfLong next;
+
+      @Override
+      public boolean tryAdvance(LongConsumer action) {
+        // look for a new spliterator
+        while (advanceToNextSpliterator()) {
+          // if we have one, try to read and use it
+          if (next.tryAdvance(action)) {
+            return true;
+          } else {
+            nextStream = null;
+            // failed, null it out so we can find another
+            next = null;
+          }
+        }
+        return false;
+      }
+
+      private boolean advanceToNextSpliterator() {
+        while (next == null) {
+          if (!spliteratorOfStreams.tryAdvance(n -> {
+            if (n != null) {
+              nextStream = n;
+              next = n.spliterator();
+            }
+          })) {
+            return false;
+          }
+        }
+        return true;
+      }
+    });
+
+    result.onClose(a::close);
+    result.onClose(b::close);
+
+    return result;
+  }
+
+  static LongStream empty() {
+    return new EmptyLongStreamSource(null);
+  }
+
+  static LongStream generate(LongSupplier s) {
+    return StreamSupport.longStream(new Spliterators.AbstractLongSpliterator(
+        Long.MAX_VALUE,
+        Spliterator.IMMUTABLE | Spliterator.ORDERED
+    ) {
+      @Override
+      public boolean tryAdvance(LongConsumer action) {
+        action.accept(s.getAsLong());
+        return true;
+      }
+    }, false);
+  }
+
+  static LongStream iterate(long seed, LongUnaryOperator f) {
+    return StreamSupport.longStream(new Spliterators.AbstractLongSpliterator(
+        Long.MAX_VALUE,
+        Spliterator.IMMUTABLE | Spliterator.ORDERED
+    ) {
+      private long next = seed;
+
+      @Override
+      public boolean tryAdvance(LongConsumer action) {
+        action.accept(next);
+        next = f.applyAsLong(next);
+        return true;
+      }
+    }, false);
+  }
+
+  static LongStream of(long... values) {
+    return Arrays.stream(values);
+  }
+
+  static LongStream of(long t) {
+    // TODO consider a splittable that returns only a single value
+    return of(new long[]{t});
+  }
+
+  static LongStream range(long startInclusive, long endExclusive) {
+    if (startInclusive >= endExclusive) {
+      return empty();
+    }
+    return rangeClosed(startInclusive, endExclusive - 1);
+  }
+
+  static LongStream rangeClosed(long startInclusive, long endInclusive) {
+    if (startInclusive > endInclusive) {
+      return empty();
+    }
+    long count = endInclusive - startInclusive + 1;
+
+    return StreamSupport.longStream(new Spliterators.AbstractLongSpliterator(
+        count,
+        Spliterator.IMMUTABLE | Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.ORDERED
+            | Spliterator.SORTED | Spliterator.DISTINCT
+    ) {
+      private long next = startInclusive;
+
+      @Override
+      public Comparator<? super Long> getComparator() {
+        return null;
+      }
+
+      @Override
+      public boolean tryAdvance(LongConsumer action) {
+        if (next <= endInclusive) {
+          action.accept(next++);
+          return true;
+        }
+        return false;
+      }
+    }, false);
+  }
+
+  /**
+   * See
+   * <a href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/LongStream.Builder.html">
+   * the official Java API doc</a> for details.
+   */
+  public interface Builder extends LongConsumer {
+    @Override
+    void accept(long t);
+
+    default LongStream.Builder add(long t) {
+      accept(t);
+      return this;
+    }
+
+    LongStream build();
+  }
+
+  boolean allMatch(LongPredicate predicate);
+
+  boolean anyMatch(LongPredicate predicate);
+
+  DoubleStream asDoubleStream();
+
+  OptionalDouble average();
+
+  Stream<Long> boxed();
+
+  <R> R collect(Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R, R> combiner);
+
+  long count();
+
+  LongStream distinct();
+
+  LongStream filter(LongPredicate predicate);
+
+  OptionalLong findAny();
+
+  OptionalLong findFirst();
+
+  LongStream flatMap(LongFunction<? extends LongStream> mapper);
+
+  void forEach(LongConsumer action);
+
+  void forEachOrdered(LongConsumer action);
+
+  PrimitiveIterator.OfLong iterator();
+
+  LongStream limit(long maxSize);
+
+  LongStream map(LongUnaryOperator mapper);
+
+  DoubleStream mapToDouble(LongToDoubleFunction mapper);
+
+  IntStream mapToInt(LongToIntFunction mapper);
+
+  <U> Stream<U> mapToObj(LongFunction<? extends U> mapper);
+
+  OptionalLong max();
+
+  OptionalLong min();
+
+  boolean noneMatch(LongPredicate predicate);
+
+  LongStream parallel();
+
+  LongStream peek(LongConsumer action);
+
+  OptionalLong reduce(LongBinaryOperator op);
+
+  long reduce(long identity, LongBinaryOperator op);
+
+  LongStream sequential();
+
+  LongStream skip(long n);
+
+  LongStream sorted();
+
+  Spliterator.OfLong spliterator();
+
+  long sum();
+
+  LongSummaryStatistics summaryStatistics();
+
+  long[] toArray();
+
+  /**
+   * Represents an empty stream, doing nothing for all methods.
+   */
+  static class EmptyLongStreamSource extends TerminatableStream<EmptyLongStreamSource>
+      implements LongStream {
+    public EmptyLongStreamSource(TerminatableStream<?> previous) {
+      super(previous);
+    }
+
+    @Override
+    public LongStream filter(LongPredicate predicate) {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public LongStream map(LongUnaryOperator mapper) {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public <U> Stream<U> mapToObj(LongFunction<? extends U> mapper) {
+      throwIfTerminated();
+      return new Stream.EmptyStreamSource<U>(this);
+    }
+
+    @Override
+    public IntStream mapToInt(LongToIntFunction mapper) {
+      throwIfTerminated();
+      return new IntStream.EmptyIntStreamSource(this);
+    }
+
+    @Override
+    public DoubleStream mapToDouble(LongToDoubleFunction mapper) {
+      throwIfTerminated();
+      return new DoubleStream.EmptyDoubleStreamSource(this);
+    }
+
+    @Override
+    public LongStream flatMap(LongFunction<? extends LongStream> mapper) {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public LongStream distinct() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public LongStream sorted() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public LongStream peek(LongConsumer action) {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public LongStream limit(long maxSize) {
+      throwIfTerminated();
+      checkState(maxSize >= 0, "maxSize may not be negative");
+      return this;
+    }
+
+    @Override
+    public LongStream skip(long n) {
+      throwIfTerminated();
+      checkState(n >= 0, "n may not be negative");
+      return this;
+    }
+
+    @Override
+    public void forEach(LongConsumer action) {
+      terminate();
+    }
+
+    @Override
+    public void forEachOrdered(LongConsumer action) {
+      terminate();
+    }
+
+    @Override
+    public long[] toArray() {
+      terminate();
+      return new long[0];
+    }
+
+    @Override
+    public long reduce(long identity, LongBinaryOperator op) {
+      terminate();
+      return identity;
+    }
+
+    @Override
+    public OptionalLong reduce(LongBinaryOperator op) {
+      terminate();
+      return OptionalLong.empty();
+    }
+
+    @Override
+    public <R> R collect(Supplier<R> supplier,
+                         ObjLongConsumer<R> accumulator,
+                         BiConsumer<R, R> combiner) {
+      terminate();
+      return supplier.get();
+    }
+
+    @Override
+    public long sum() {
+      terminate();
+      return 0;
+    }
+
+    @Override
+    public OptionalLong min() {
+      terminate();
+      return OptionalLong.empty();
+    }
+
+    @Override
+    public OptionalLong max() {
+      terminate();
+      return OptionalLong.empty();
+    }
+
+    @Override
+    public long count() {
+      terminate();
+      return 0;
+    }
+
+    @Override
+    public OptionalDouble average() {
+      terminate();
+      return OptionalDouble.empty();
+    }
+
+    @Override
+    public LongSummaryStatistics summaryStatistics() {
+      terminate();
+      return new LongSummaryStatistics();
+    }
+
+    @Override
+    public boolean anyMatch(LongPredicate predicate) {
+      terminate();
+      return false;
+    }
+
+    @Override
+    public boolean allMatch(LongPredicate predicate) {
+      terminate();
+      return true;
+    }
+
+    @Override
+    public boolean noneMatch(LongPredicate predicate) {
+      terminate();
+      return true;
+    }
+
+    @Override
+    public OptionalLong findFirst() {
+      terminate();
+      return OptionalLong.empty();
+    }
+
+    @Override
+    public OptionalLong findAny() {
+      terminate();
+      return OptionalLong.empty();
+    }
+
+    @Override
+    public DoubleStream asDoubleStream() {
+      throwIfTerminated();
+      return new DoubleStream.EmptyDoubleStreamSource(this);
+    }
+
+    @Override
+    public Stream<Long> boxed() {
+      throwIfTerminated();
+      return new Stream.EmptyStreamSource<Long>(this);
+    }
+
+    @Override
+    public LongStream sequential() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public LongStream parallel() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public PrimitiveIterator.OfLong iterator() {
+      return Spliterators.iterator(spliterator());
+    }
+
+    @Override
+    public Spliterator.OfLong spliterator() {
+      terminate();
+      return Spliterators.emptyLongSpliterator();
+    }
+
+    @Override
+    public boolean isParallel() {
+      throwIfTerminated();
+      return false;
+    }
+
+    @Override
+    public LongStream unordered() {
+      throwIfTerminated();
+      return this;
+    }
+  }
+
+  /**
+   * Long to Int map spliterator.
+   */
+  static final class MapToIntSpliterator extends Spliterators.AbstractIntSpliterator {
+    private final LongToIntFunction map;
+    private final Spliterator.OfLong original;
+
+    public MapToIntSpliterator(LongToIntFunction map, Spliterator.OfLong original) {
+      super(
+          original.estimateSize(),
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
+      );
+      checkNotNull(map);
+      this.map = map;
+      this.original = original;
+    }
+
+    @Override
+    public boolean tryAdvance(final IntConsumer action) {
+      return original.tryAdvance((long u) -> action.accept(map.applyAsInt(u)));
+    }
+  }
+
+  /**
+   * Long to Object map spliterator.
+   * @param <T> the type of data in the object spliterator
+   */
+  static final class MapToObjSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
+    private final LongFunction<? extends T> map;
+    private final Spliterator.OfLong original;
+
+    public MapToObjSpliterator(LongFunction<? extends T> map, Spliterator.OfLong original) {
+      super(
+          original.estimateSize(),
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
+      );
+      checkNotNull(map);
+      this.map = map;
+      this.original = original;
+    }
+
+    @Override
+    public boolean tryAdvance(final Consumer<? super T> action) {
+      return original.tryAdvance((long u) -> action.accept(map.apply(u)));
+    }
+  }
+
+  /**
+   * Long to Long map spliterator.
+   */
+  static final class MapToLongSpliterator extends Spliterators.AbstractLongSpliterator {
+    private final LongUnaryOperator map;
+    private final Spliterator.OfLong original;
+
+    public MapToLongSpliterator(LongUnaryOperator map, Spliterator.OfLong original) {
+      super(
+          original.estimateSize(),
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
+      );
+      checkNotNull(map);
+      this.map = map;
+      this.original = original;
+    }
+
+    @Override
+    public boolean tryAdvance(final LongConsumer action) {
+      return original.tryAdvance((long u) -> action.accept(map.applyAsLong(u)));
+    }
+  }
+
+  /**
+   * Long to Double map Spliterator.
+   */
+  static final class MapToDoubleSpliterator extends Spliterators.AbstractDoubleSpliterator {
+    private final LongToDoubleFunction map;
+    private final Spliterator.OfLong original;
+
+    public MapToDoubleSpliterator(LongToDoubleFunction map, Spliterator.OfLong original) {
+      super(
+          original.estimateSize(),
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
+      );
+      checkNotNull(map);
+      this.map = map;
+      this.original = original;
+    }
+
+    @Override
+    public boolean tryAdvance(final DoubleConsumer action) {
+      return original.tryAdvance((long u) -> action.accept(map.applyAsDouble(u)));
+    }
+  }
+
+  /**
+   * Long filter spliterator.
+   */
+  static final class FilterSpliterator extends Spliterators.AbstractLongSpliterator {
+    private final LongPredicate filter;
+    private final Spliterator.OfLong original;
+
+    private boolean found;
+
+    public FilterSpliterator(LongPredicate filter, Spliterator.OfLong original) {
+      super(original.estimateSize(), original.characteristics() & ~Spliterator.SIZED);
+      checkNotNull(filter);
+      this.filter = filter;
+      this.original = original;
+    }
+
+    @Override
+    public Comparator<? super Long> getComparator() {
+      return original.getComparator();
+    }
+
+    @Override
+    public boolean tryAdvance(final LongConsumer action) {
+      found = false;
+      while (!found && original.tryAdvance((long item) -> {
+        if (filter.test(item)) {
+          found = true;
+          action.accept(item);
+        }
+      })) {
+        // do nothing, work is done in tryAdvance
+      }
+
+      return found;
+    }
+  }
+
+  /**
+   * Long skip spliterator.
+   */
+  static final class SkipSpliterator extends Spliterators.AbstractLongSpliterator {
+    private long skip;
+    private final Spliterator.OfLong original;
+
+    public SkipSpliterator(long skip, Spliterator.OfLong original) {
+      super(
+          original.hasCharacteristics(Spliterator.SIZED)
+              ? Math.max(0, original.estimateSize() - skip)
+              : Long.MAX_VALUE,
+          original.characteristics()
+      );
+      this.skip = skip;
+      this.original = original;
+    }
+
+    @Override
+    public Comparator<? super Long> getComparator() {
+      return original.getComparator();
+    }
+
+    @Override
+    public boolean tryAdvance(LongConsumer action) {
+      while (skip > 0) {
+        if (!original.tryAdvance((long ignore) -> { })) {
+          return false;
+        }
+        skip--;
+      }
+      return original.tryAdvance(action);
+    }
+  }
+
+  /**
+   * Long limit spliterator.
+   */
+  static final class LimitSpliterator extends Spliterators.AbstractLongSpliterator {
+    private final long limit;
+    private final Spliterator.OfLong original;
+    private int position = 0;
+
+    public LimitSpliterator(long limit, Spliterator.OfLong original) {
+      super(
+          original.hasCharacteristics(Spliterator.SIZED)
+              ? Math.min(original.estimateSize(), limit)
+              : Long.MAX_VALUE,
+          original.characteristics()
+      );
+      this.limit = limit;
+      this.original = original;
+    }
+
+    @Override
+    public Comparator<? super Long> getComparator() {
+      return original.getComparator();
+    }
+
+    @Override
+    public boolean tryAdvance(LongConsumer action) {
+      if (limit <= position) {
+        return false;
+      }
+      boolean result = original.tryAdvance(action);
+      position++;
+      return result;
+    }
+  }
+
+  /**
+   * Main implementation of LongStream, wrapping a single spliterator, and an optional parent
+   * stream.
+   */
+  static class LongStreamSource extends TerminatableStream<LongStreamSource> implements LongStream {
+    private final Spliterator.OfLong spliterator;
+
+    public LongStreamSource(TerminatableStream<?> previous, Spliterator.OfLong spliterator) {
+      super(previous);
+      this.spliterator = spliterator;
+    }
+
+    // terminals
+
+    @Override
+    public void forEach(LongConsumer action) {
+      forEachOrdered(action);
+    }
+
+    @Override
+    public void forEachOrdered(LongConsumer action) {
+      terminate();
+      spliterator.forEachRemaining(action);
+    }
+
+    @Override
+    public long[] toArray() {
+      terminate();
+      long[] entries = new long[0];
+      // this is legal in js, since the array will be backed by a JS array
+      spliterator.forEachRemaining((long value) -> entries[entries.length] = value);
+
+      return entries;
+    }
+
+    @Override
+    public long reduce(long identity, LongBinaryOperator op) {
+      terminate();
+      ValueConsumer holder = new ValueConsumer();
+      holder.value = identity;
+      spliterator.forEachRemaining((long value) -> {
+        holder.accept(op.applyAsLong(holder.value, value));
+      });
+      return holder.value;
+    }
+
+    @Override
+    public OptionalLong reduce(LongBinaryOperator op) {
+      ValueConsumer holder = new ValueConsumer();
+      if (spliterator.tryAdvance(holder)) {
+        return OptionalLong.of(reduce(holder.value, op));
+      }
+      terminate();
+      return OptionalLong.empty();
+    }
+
+    @Override
+    public <R> R collect(Supplier<R> supplier,
+                         ObjLongConsumer<R> accumulator,
+                         BiConsumer<R, R> combiner) {
+      terminate();
+      final R acc = supplier.get();
+      spliterator.forEachRemaining((long value) -> accumulator.accept(acc, value));
+      return acc;
+    }
+
+    @Override
+    public long sum() {
+      return summaryStatistics().getSum();
+    }
+
+    @Override
+    public OptionalLong min() {
+      terminate();
+      final ValueConsumer holder = new ValueConsumer();
+      if (spliterator.tryAdvance((long value) -> holder.value = value)) {
+        spliterator.forEachRemaining((long value) -> holder.value = Math.min(holder.value, value));
+        return OptionalLong.of(holder.value);
+      }
+      return OptionalLong.empty();
+    }
+
+    @Override
+    public OptionalLong max() {
+      terminate();
+      final ValueConsumer holder = new ValueConsumer();
+      if (spliterator.tryAdvance((long value) -> holder.value = value)) {
+        spliterator.forEachRemaining((long value) -> holder.value = Math.max(holder.value, value));
+        return OptionalLong.of(holder.value);
+      }
+      return OptionalLong.empty();
+    }
+
+    @Override
+    public long count() {
+      terminate();
+      long count = 0;
+      while (spliterator.tryAdvance((long value) -> { })) {
+        count++;
+      }
+      return count;
+    }
+
+    @Override
+    public OptionalDouble average() {
+      LongSummaryStatistics stats = summaryStatistics();
+      if (stats.getCount() == 0) {
+        return OptionalDouble.empty();
+      }
+      return OptionalDouble.of(stats.getAverage());
+    }
+
+    @Override
+    public LongSummaryStatistics summaryStatistics() {
+      return collect(
+          LongSummaryStatistics::new,
+          // TODO switch to a lambda reference once #9340 is fixed
+          (longSummaryStatistics, value) -> longSummaryStatistics.accept(value),
+          LongSummaryStatistics::combine
+      );
+    }
+
+    @Override
+    public boolean anyMatch(LongPredicate predicate) {
+      return filter(predicate).findFirst().isPresent();
+    }
+
+    @Override
+    public boolean allMatch(LongPredicate predicate) {
+      return !anyMatch(predicate.negate());
+    }
+
+    @Override
+    public boolean noneMatch(LongPredicate predicate) {
+      return !anyMatch(predicate);
+    }
+
+    @Override
+    public OptionalLong findFirst() {
+      terminate();
+      ValueConsumer holder = new ValueConsumer();
+      if (spliterator.tryAdvance(holder)) {
+        return OptionalLong.of(holder.value);
+      }
+      return OptionalLong.empty();
+    }
+
+    @Override
+    public OptionalLong findAny() {
+      return findFirst();
+    }
+
+    @Override
+    public PrimitiveIterator.OfLong iterator() {
+      return Spliterators.iterator(spliterator());
+    }
+
+    @Override
+    public Spliterator.OfLong spliterator() {
+      terminate();
+      return spliterator;
+    }
+    // end terminals
+
+    // intermediates
+    @Override
+    public LongStream filter(LongPredicate predicate) {
+      throwIfTerminated();
+      return new LongStreamSource(this, new FilterSpliterator(predicate, spliterator));
+    }
+
+    @Override
+    public LongStream map(LongUnaryOperator mapper) {
+      throwIfTerminated();
+      return new LongStream.LongStreamSource(this, new MapToLongSpliterator(mapper, spliterator));
+    }
+
+    @Override
+    public <U> Stream<U> mapToObj(LongFunction<? extends U> mapper) {
+      throwIfTerminated();
+      return new Stream.StreamSource(this, new MapToObjSpliterator<U>(mapper, spliterator));
+    }
+
+    @Override
+    public IntStream mapToInt(LongToIntFunction mapper) {
+      throwIfTerminated();
+      return new IntStream.IntStreamSource(this, new MapToIntSpliterator(mapper, spliterator));
+    }
+
+    @Override
+    public DoubleStream mapToDouble(LongToDoubleFunction mapper) {
+      throwIfTerminated();
+      return new DoubleStream.DoubleStreamSource(this, new MapToDoubleSpliterator(
+          mapper,
+          spliterator)
+      );
+    }
+
+    @Override
+    public LongStream flatMap(LongFunction<? extends LongStream> mapper) {
+      throwIfTerminated();
+      final Spliterator<? extends LongStream> spliteratorOfStreams = new MapToObjSpliterator<>(
+          mapper,
+          spliterator
+      );
+      return new LongStreamSource(
+          this,
+          new Spliterators.AbstractLongSpliterator(Long.MAX_VALUE, 0
+          ) {
+            LongStream nextStream;
+            Spliterator.OfLong next;
+
+            @Override
+            public boolean tryAdvance(LongConsumer action) {
+              // look for a new spliterator
+              while (advanceToNextSpliterator()) {
+                // if we have one, try to read and use it
+                if (next.tryAdvance(action)) {
+                  return true;
+                } else {
+                  nextStream.close();
+                  nextStream = null;
+                  // failed, null it out so we can find another
+                  next = null;
+                }
+              }
+              return false;
+            }
+
+            private boolean advanceToNextSpliterator() {
+              while (next == null) {
+                if (!spliteratorOfStreams.tryAdvance(n -> {
+                  if (n != null) {
+                    nextStream = n;
+                    next = n.spliterator();
+                  }
+                })) {
+                  return false;
+                }
+              }
+              return true;
+            }
+          });
+    }
+
+    @Override
+    public LongStream distinct() {
+      throwIfTerminated();
+      HashSet<Long> seen = new HashSet<>();
+      return filter(seen::add);
+    }
+
+    @Override
+    public LongStream sorted() {
+      throwIfTerminated();
+      return new LongStreamSource(this, new Spliterators.AbstractLongSpliterator(
+          spliterator.estimateSize(),
+          spliterator.characteristics() | Spliterator.SORTED
+      ) {
+        Spliterator.OfLong ordered = null;
+
+        @Override
+        public Comparator<? super Long> getComparator() {
+          return null;
+        }
+
+        @Override
+        public boolean tryAdvance(LongConsumer action) {
+          if (ordered == null) {
+            long[] list = new long[0];
+            spliterator.forEachRemaining((long item) -> list[list.length] = item);
+            Arrays.sort(list);
+            ordered = Spliterators.spliterator(list, characteristics());
+          }
+          return ordered.tryAdvance(action);
+        }
+      });
+    }
+
+    @Override
+    public LongStream peek(LongConsumer action) {
+      checkNotNull(action);
+      throwIfTerminated();
+      return new LongStreamSource(this, new Spliterators.AbstractLongSpliterator(
+          spliterator.estimateSize(),
+          spliterator.characteristics()
+      ) {
+        @Override
+        public boolean tryAdvance(final LongConsumer innerAction) {
+          return spliterator.tryAdvance(action.andThen(innerAction));
+        }
+      });
+    }
+
+    @Override
+    public LongStream limit(long maxSize) {
+      throwIfTerminated();
+      checkState(maxSize >= 0, "maxSize may not be negative");
+      return new LongStreamSource(this, new LimitSpliterator(maxSize, spliterator));
+    }
+
+    @Override
+    public LongStream skip(long n) {
+      throwIfTerminated();
+      checkState(n >= 0, "n may not be negative");
+      if (n == 0) {
+        return this;
+      }
+      return new LongStreamSource(this, new SkipSpliterator(n, spliterator));
+    }
+
+    @Override
+    public DoubleStream asDoubleStream() {
+      return mapToDouble(x -> (double) x);
+    }
+
+    @Override
+    public Stream<Long> boxed() {
+      return mapToObj(Long::valueOf);
+    }
+
+    @Override
+    public LongStream sequential() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public LongStream parallel() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public boolean isParallel() {
+      throwIfTerminated();
+      return false;
+    }
+
+    @Override
+    public LongStream unordered() {
+      throwIfTerminated();
+      return this;
+    }
+  }
+}

diff --git a/user/super/com/google/gwt/emul/java/util/stream/Stream.java b/user/super/com/google/gwt/emul/java/util/stream/Stream.java
new file mode 100644
index 0000000..b61486d
--- /dev/null
+++ b/user/super/com/google/gwt/emul/java/util/stream/Stream.java

@@ -0,0 +1,1180 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package java.util.stream;
+
+import static javaemul.internal.InternalPreconditions.checkCriticalState;
+import static javaemul.internal.InternalPreconditions.checkNotNull;
+import static javaemul.internal.InternalPreconditions.checkState;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Optional;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.BinaryOperator;
+import java.util.function.Consumer;
+import java.util.function.DoubleConsumer;
+import java.util.function.Function;
+import java.util.function.IntConsumer;
+import java.util.function.IntFunction;
+import java.util.function.LongConsumer;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.function.ToDoubleFunction;
+import java.util.function.ToIntFunction;
+import java.util.function.ToLongFunction;
+import java.util.function.UnaryOperator;
+
+/**
+ * See <a href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html">
+ * the official Java API doc</a> for details.
+ *
+ * @param <T> the type of data being streamed
+ */
+public interface Stream<T> extends BaseStream<T, Stream<T>> {
+  /**
+   * Value holder for various stream operations.
+   */
+  static final class ValueConsumer<T> implements Consumer<T> {
+    T value;
+
+    @Override
+    public void accept(T value) {
+      this.value = value;
+    }
+  }
+
+  static <T> Stream.Builder<T> builder() {
+    return new Builder<T>() {
+      private Object[] items = new Object[0];
+
+      @Override
+      public void accept(T t) {
+        checkState(items != null, "Builder already built");
+        items[items.length] = t;
+      }
+
+      @Override
+      @SuppressWarnings("unchecked")
+      public Stream<T> build() {
+        checkCriticalState(items != null, "Builder already built");
+        Stream<T> stream = (Stream<T>) Arrays.stream(items);
+        items = null;
+        return stream;
+      }
+    };
+  }
+
+  static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
+    // This is nearly the same as flatMap, but inlined, wrapped around a single spliterator of
+    // these two objects, and without close() called as the stream progresses. Instead, close is
+    // invoked as part of the resulting stream's own onClose, so that either can fail without
+    // affecting the other, and correctly collecting suppressed exceptions.
+
+    // TODO replace this flatMap-ish spliterator with one that directly combines the two root
+    // streams
+    Spliterator<? extends Stream<? extends T>> spliteratorOfStreams =
+        Arrays.asList(a, b).spliterator();
+    Stream<T> result = new StreamSource<T>(null, new Spliterators.AbstractSpliterator<T>(Long
+        .MAX_VALUE, 0) {
+      Stream<? extends T> nextStream;
+      Spliterator<? extends T> next;
+
+      @Override
+      public boolean tryAdvance(Consumer<? super T> action) {
+        // look for a new spliterator
+        while (advanceToNextSpliterator()) {
+          // if we have one, try to read and use it
+          if (next.tryAdvance(action)) {
+            return true;
+          } else {
+            nextStream = null;
+            // failed, null it out so we can find another
+            next = null;
+          }
+        }
+        return false;
+      }
+
+      private boolean advanceToNextSpliterator() {
+        while (next == null) {
+          if (!spliteratorOfStreams.tryAdvance(n -> {
+            if (n != null) {
+              nextStream = n;
+              next = n.spliterator();
+            }
+          })) {
+            return false;
+          }
+        }
+        return true;
+      }
+    });
+
+    result.onClose(a::close);
+    result.onClose(b::close);
+
+    return result;
+  }
+
+  static <T> Stream<T> empty() {
+    return new EmptyStreamSource<T>(null);
+  }
+
+  static <T> Stream<T> generate(Supplier<T> s) {
+    return StreamSupport.stream(new Spliterators.AbstractSpliterator<T>(Long.MAX_VALUE,
+        Spliterator.IMMUTABLE | Spliterator.ORDERED) {
+      @Override
+      public boolean tryAdvance(Consumer<? super T> action) {
+        action.accept(s.get());
+        return true;
+      }
+    }, false);
+  }
+
+  static <T> Stream<T> iterate(T seed, UnaryOperator<T> f) {
+    return StreamSupport.stream(new Spliterators.AbstractSpliterator<T>(Long.MAX_VALUE,
+        Spliterator.IMMUTABLE | Spliterator.ORDERED) {
+      private T next = seed;
+
+      @Override
+      public boolean tryAdvance(Consumer<? super T> action) {
+        action.accept(next);
+        next = f.apply(next);
+        return true;
+      }
+    }, false);
+  }
+
+  static <T> Stream<T> of(T t) {
+    // TODO consider a splittable that returns only a single value, either for use here or in the
+    //      singleton collection types
+    return Collections.singleton(t).stream();
+  }
+
+  static <T> Stream<T> of(T... values) {
+    return Arrays.stream(values);
+  }
+
+  /**
+   * See <a href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.Builder.html">
+   * the official Java API doc</a> for details.
+   */
+  public interface Builder<T> extends Consumer<T> {
+    @Override
+    void accept(T t);
+
+    default Stream.Builder<T> add(T t) {
+      accept(t);
+      return this;
+    }
+
+    Stream<T> build();
+  }
+
+  boolean allMatch(Predicate<? super T> predicate);
+
+  boolean anyMatch(Predicate<? super T> predicate);
+
+  <R,A> R collect(Collector<? super T,A,R> collector);
+
+  <R> R collect(Supplier<R> supplier,
+                BiConsumer<R,? super T> accumulator,
+                BiConsumer<R,R> combiner);
+
+  long count();
+
+  Stream<T> distinct();
+
+  Stream<T> filter(Predicate<? super T> predicate);
+
+  Optional<T> findAny();
+
+  Optional<T> findFirst();
+
+  <R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper);
+
+  DoubleStream flatMapToDouble(Function<? super T,? extends DoubleStream> mapper);
+
+  IntStream flatMapToInt(Function<? super T,? extends IntStream> mapper);
+
+  LongStream flatMapToLong(Function<? super T,? extends LongStream> mapper);
+
+  void forEach(Consumer<? super T> action);
+
+  void forEachOrdered(Consumer<? super T> action);
+
+  Stream<T> limit(long maxSize);
+
+  <R> Stream<R> map(Function<? super T,? extends R> mapper);
+
+  DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);
+
+  IntStream mapToInt(ToIntFunction<? super T> mapper);
+
+  LongStream mapToLong(ToLongFunction<? super T> mapper);
+
+  Optional<T> max(Comparator<? super T> comparator);
+
+  Optional<T> min(Comparator<? super T> comparator);
+
+  boolean noneMatch(Predicate<? super T> predicate);
+
+  Stream<T> peek(Consumer<? super T> action);
+
+  Optional<T> reduce(BinaryOperator<T> accumulator);
+
+  T reduce(T identity, BinaryOperator<T> accumulator);
+
+  <U> U reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner);
+
+  Stream<T> skip(long n);
+
+  Stream<T> sorted();
+
+  Stream<T> sorted(Comparator<? super T> comparator);
+
+  Object[] toArray();
+
+  <A> A[] toArray(IntFunction<A[]> generator);
+
+  /**
+   * Represents an empty stream, doing nothing for all methods.
+   */
+  static class EmptyStreamSource<T> extends TerminatableStream<EmptyStreamSource<T>>
+      implements Stream<T> {
+
+    public EmptyStreamSource(TerminatableStream<?> previous) {
+      super(previous);
+    }
+
+    @Override
+    public  Stream<T> filter(Predicate<? super T> predicate) {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public <R>  Stream<R> map(Function<? super T, ? extends R> mapper) {
+      throwIfTerminated();
+      return (Stream) this;
+    }
+
+    @Override
+    public IntStream mapToInt(ToIntFunction<? super T> mapper) {
+      throwIfTerminated();
+      return new IntStream.EmptyIntStreamSource(this);
+    }
+
+    @Override
+    public LongStream mapToLong(ToLongFunction<? super T> mapper) {
+      throwIfTerminated();
+      return new LongStream.EmptyLongStreamSource(this);
+    }
+
+    @Override
+    public DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper) {
+      throwIfTerminated();
+      return new DoubleStream.EmptyDoubleStreamSource(this);
+    }
+
+    @Override
+    public <R> Stream<R> flatMap(Function<? super T, ? extends  Stream<? extends R>> mapper) {
+      throwIfTerminated();
+      return (Stream) this;
+    }
+
+    @Override
+    public IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper) {
+      throwIfTerminated();
+      return new IntStream.EmptyIntStreamSource(this);
+    }
+
+    @Override
+    public LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper) {
+      throwIfTerminated();
+      return new LongStream.EmptyLongStreamSource(this);
+    }
+
+    @Override
+    public DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper) {
+      throwIfTerminated();
+      return new DoubleStream.EmptyDoubleStreamSource(this);
+    }
+
+    @Override
+    public Stream<T> distinct() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public Stream<T> sorted() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public Stream<T> sorted(Comparator<? super T> comparator) {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public Stream<T> peek(Consumer<? super T> action) {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public Stream<T> limit(long maxSize) {
+      throwIfTerminated();
+      checkState(maxSize >= 0, "maxSize may not be negative");
+      return this;
+    }
+
+    @Override
+    public Stream<T> skip(long n) {
+      throwIfTerminated();
+      checkState(n >= 0, "n may not be negative");
+      return this;
+    }
+
+    @Override
+    public void forEach(Consumer<? super T> action) {
+      terminate();
+      // nothing to do
+    }
+
+    @Override
+    public void forEachOrdered(Consumer<? super T> action) {
+      terminate();
+      // nothing to do
+    }
+
+    @Override
+    public Object[] toArray() {
+      terminate();
+      return new Object[0];
+    }
+
+    @Override
+    public <A> A[] toArray(IntFunction<A[]> generator) {
+      terminate();
+      return generator.apply(0);
+    }
+
+    @Override
+    public T reduce(T identity, BinaryOperator<T> accumulator) {
+      terminate();
+      return identity;
+    }
+
+    @Override
+    public Optional<T> reduce(BinaryOperator<T> accumulator) {
+      terminate();
+      return Optional.empty();
+    }
+
+    @Override
+    public <U> U reduce(U identity,
+                        BiFunction<U, ? super T, U> accumulator,
+                        BinaryOperator<U> combiner) {
+      terminate();
+      return identity;
+    }
+
+    @Override
+    public <R> R collect(Supplier<R> supplier,
+                         BiConsumer<R, ? super T> accumulator,
+                         BiConsumer<R, R> combiner) {
+      terminate();
+      return supplier.get();
+    }
+
+    @Override
+    public <R, A> R collect(Collector<? super T, A, R> collector) {
+      terminate();
+      return collector.finisher().apply(collector.supplier().get());
+    }
+
+    @Override
+    public Optional<T> min(Comparator<? super T> comparator) {
+      terminate();
+      return Optional.empty();
+    }
+
+    @Override
+    public Optional<T> max(Comparator<? super T> comparator) {
+      terminate();
+      return Optional.empty();
+    }
+
+    @Override
+    public long count() {
+      terminate();
+      return 0;
+    }
+
+    @Override
+    public boolean anyMatch(Predicate<? super T> predicate) {
+      terminate();
+      return false;
+    }
+
+    @Override
+    public boolean allMatch(Predicate<? super T> predicate) {
+      terminate();
+      return true;
+    }
+
+    @Override
+    public boolean noneMatch(Predicate<? super T> predicate) {
+      terminate();
+      return true;
+    }
+
+    @Override
+    public Optional<T> findFirst() {
+      terminate();
+      return Optional.empty();
+    }
+
+    @Override
+    public Optional<T> findAny() {
+      terminate();
+      return Optional.empty();
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+      terminate();
+      return Collections.emptyIterator();
+    }
+
+    @Override
+    public Spliterator<T> spliterator() {
+      terminate();
+      return Spliterators.emptySpliterator();
+    }
+
+    @Override
+    public boolean isParallel() {
+      throwIfTerminated();
+      return false;
+    }
+
+    @Override
+    public Stream<T> sequential() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public Stream<T> parallel() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public Stream<T> unordered() {
+      throwIfTerminated();
+      return this;
+    }
+  }
+
+  /**
+   * Object to Object map spliterator.
+   * @param <U> the input type
+   * @param <T> the output type
+   */
+  static final class MapToObjSpliterator<U, T> extends Spliterators.AbstractSpliterator<T> {
+    private final Function<? super U, ? extends T> map;
+    private final Spliterator<U> original;
+
+    public MapToObjSpliterator(Function<? super U, ? extends T> map, Spliterator<U> original) {
+      super(
+          original.estimateSize(),
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
+      );
+      checkNotNull(map);
+      this.map = map;
+      this.original = original;
+    }
+
+    @Override
+    public boolean tryAdvance(final Consumer<? super T> action) {
+      return original.tryAdvance(u -> action.accept(map.apply(u)));
+    }
+  }
+
+  /**
+   * Object to Int map spliterator.
+   * @param <T> the input type
+   */
+  static final class MapToIntSpliterator<T> extends Spliterators.AbstractIntSpliterator {
+    private final ToIntFunction<? super T> map;
+    private final Spliterator<T> original;
+
+    public MapToIntSpliterator(ToIntFunction<? super T> map, Spliterator<T> original) {
+      super(
+          original.estimateSize(),
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
+      );
+      checkNotNull(map);
+      this.map = map;
+      this.original = original;
+    }
+
+    @Override
+    public boolean tryAdvance(final IntConsumer action) {
+      return original.tryAdvance(u -> action.accept(map.applyAsInt(u)));
+    }
+  }
+
+  /**
+   * Object to Long map spliterator.
+   * @param <T> the input type
+   */
+  static final class MapToLongSpliterator<T> extends Spliterators.AbstractLongSpliterator {
+    private final ToLongFunction<? super T> map;
+    private final Spliterator<T> original;
+
+    public MapToLongSpliterator(ToLongFunction<? super T> map, Spliterator<T> original) {
+      super(
+          original.estimateSize(),
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
+      );
+      checkNotNull(map);
+      this.map = map;
+      this.original = original;
+    }
+
+    @Override
+    public boolean tryAdvance(final LongConsumer action) {
+      return original.tryAdvance(u -> action.accept(map.applyAsLong(u)));
+    }
+  }
+
+  /**
+   * Object to Double map spliterator.
+   * @param <T> the input type
+   */
+  static final class MapToDoubleSpliterator<T> extends Spliterators.AbstractDoubleSpliterator {
+    private final ToDoubleFunction<? super T> map;
+    private final Spliterator<T> original;
+
+    public MapToDoubleSpliterator(ToDoubleFunction<? super T> map, Spliterator<T> original) {
+      super(
+          original.estimateSize(),
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
+      );
+      checkNotNull(map);
+      this.map = map;
+      this.original = original;
+    }
+
+    @Override
+    public boolean tryAdvance(final DoubleConsumer action) {
+      return original.tryAdvance(u -> action.accept(map.applyAsDouble(u)));
+    }
+  }
+
+  /**
+   * Object filter spliterator.
+   * @param <T> the type of data to iterate over
+   */
+  static final class FilterSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
+    private final Predicate<? super T> filter;
+    private final Spliterator<T> original;
+
+    private boolean found;
+
+    public FilterSpliterator(Predicate<? super T> filter, Spliterator<T> original) {
+      super(original.estimateSize(), original.characteristics() & ~Spliterator.SIZED);
+      checkNotNull(filter);
+      this.filter = filter;
+      this.original = original;
+    }
+
+    @Override
+    public Comparator<? super T> getComparator() {
+      return original.getComparator();
+    }
+
+    @Override
+    public boolean tryAdvance(final Consumer<? super T> action) {
+      found = false;
+      while (!found && original.tryAdvance(item -> {
+        if (filter.test(item)) {
+          found = true;
+          action.accept(item);
+        }
+      })) {
+        // do nothing, work is done in tryAdvance
+      }
+
+      return found;
+    }
+  }
+
+  /**
+   * Object skip spliterator.
+   * @param <T> the type of data to iterate over
+   */
+  static final class SkipSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
+    private long skip;
+    private final Spliterator<T> original;
+
+    public SkipSpliterator(long skip, Spliterator<T> original) {
+      super(
+          original.hasCharacteristics(Spliterator.SIZED)
+              ? Math.max(0, original.estimateSize() - skip)
+              : Long.MAX_VALUE,
+          original.characteristics()
+      );
+      this.skip = skip;
+      this.original = original;
+    }
+
+    @Override
+    public Comparator<? super T> getComparator() {
+      return original.getComparator();
+    }
+
+    @Override
+    public boolean tryAdvance(Consumer<? super T> action) {
+      while (skip > 0) {
+        if (!original.tryAdvance(ignore -> { })) {
+          return false;
+        }
+        skip--;
+      }
+      return original.tryAdvance(action);
+    }
+  }
+
+  /**
+   * Object limit spliterator.
+   * @param <T> the type of data to iterate over
+   */
+  static final class LimitSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
+    private final long limit;
+    private final Spliterator<T> original;
+    private int position = 0;
+
+    public LimitSpliterator(long limit, Spliterator<T> original) {
+      super(
+          original.hasCharacteristics(Spliterator.SIZED)
+              ? Math.min(original.estimateSize(), limit)
+              : Long.MAX_VALUE,
+          original.characteristics()
+      );
+      this.limit = limit;
+      this.original = original;
+    }
+
+    @Override
+    public Comparator<? super T> getComparator() {
+      return original.getComparator();
+    }
+
+    @Override
+    public boolean tryAdvance(Consumer<? super T> action) {
+      if (limit <= position) {
+        return false;
+      }
+      boolean result = original.tryAdvance(action);
+      position++;
+      return result;
+    }
+  }
+
+  /**
+   * Main implementation of Stream, wrapping a single spliterator and an optional parent stream.
+   * @param <T>
+   */
+  static class StreamSource<T> extends TerminatableStream<StreamSource<T>> implements Stream<T> {
+    private final Spliterator<T> spliterator;
+
+    public StreamSource(TerminatableStream<?> prev, Spliterator<T> spliterator) {
+      super(prev);
+      this.spliterator = spliterator;
+    }
+
+    // terminal
+    @Override
+    public Spliterator<T> spliterator() {
+      terminate();
+      return spliterator;
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+      return Spliterators.iterator(spliterator());
+    }
+
+    @Override
+    public long count() {
+      terminate();
+      long count = 0;
+      while (spliterator.tryAdvance(a -> { })) {
+        count++;
+      }
+      return count;
+    }
+
+    @Override
+    public void forEach(Consumer<? super T> action) {
+      forEachOrdered(action);
+    }
+
+    @Override
+    public void forEachOrdered(Consumer<? super T> action) {
+      terminate();
+      spliterator.forEachRemaining(action);
+    }
+
+    @Override
+    public Object[] toArray() {
+      return toArray(Object[]::new);
+    }
+
+    @Override
+    public <A> A[] toArray(IntFunction<A[]> generator) {
+      List<T> collected = collect(Collectors.toList());
+      return collected.toArray(generator.apply(collected.size()));
+    }
+
+    @Override
+    public <R> R collect(Supplier<R> supplier,
+                         BiConsumer<R, ? super T> accumulator,
+                         BiConsumer<R, R> combiner) {
+      return collect(Collector.of(supplier, accumulator, (a, b) -> {
+        combiner.accept(a, b);
+        return a;
+      }));
+    }
+
+    @Override
+    public <R, A> R collect(final Collector<? super T, A, R> collector) {
+      return collector.finisher().apply(reduce(
+          collector.supplier().get(),
+          (a, t) -> {
+            collector.accumulator().accept(a, t);
+            return a;
+          },
+          collector.combiner()
+      ));
+    }
+
+    @Override
+    public Optional<T> findFirst() {
+      terminate();
+      ValueConsumer<T> holder = new ValueConsumer<T>();
+      if (spliterator.tryAdvance(holder)) {
+        return Optional.of(holder.value);
+      }
+      return Optional.empty();
+    }
+
+    @Override
+    public Optional<T> findAny() {
+      return findFirst();
+    }
+
+    @Override
+    public boolean anyMatch(Predicate<? super T> predicate) {
+      return filter(predicate).findFirst().isPresent();
+    }
+
+    @Override
+    public boolean allMatch(final Predicate<? super T> predicate) {
+      return !anyMatch(predicate.negate());
+    }
+
+    @Override
+    public boolean noneMatch(final Predicate<? super T> predicate) {
+      return !anyMatch(predicate);
+    }
+
+    @Override
+    public Optional<T> min(final Comparator<? super T> comparator) {
+      return reduce(BinaryOperator.minBy(comparator));
+    }
+
+    @Override
+    public Optional<T> max(final Comparator<? super T> comparator) {
+      return reduce(BinaryOperator.maxBy(comparator));
+    }
+
+    @Override
+    public T reduce(T identity, BinaryOperator<T> accumulator) {
+      return reduce(identity, accumulator, accumulator);
+    }
+
+    @Override
+    public Optional<T> reduce(BinaryOperator<T> accumulator) {
+      ValueConsumer<T> consumer = new ValueConsumer<T>();
+      if (!spliterator.tryAdvance(consumer)) {
+        terminate();
+        return Optional.empty();
+      }
+      return Optional.of(reduce(consumer.value, accumulator));
+    }
+
+    // combiner is ignored, since we don't parallelize
+    @Override
+    public <U> U reduce(U identity,
+                        BiFunction<U, ? super T, U> accumulator,
+                        BinaryOperator<U> combiner) {
+      terminate();
+      final ValueConsumer<U> consumer = new ValueConsumer<U>();
+      consumer.value = identity;
+      spliterator.forEachRemaining(item -> {
+        consumer.accept(accumulator.apply(consumer.value, item));
+      });
+      return consumer.value;
+    }
+    // end terminal
+
+    // intermediate
+    @Override
+    public Stream<T> filter(Predicate<? super T> predicate) {
+      throwIfTerminated();
+      return new StreamSource<>(this, new FilterSpliterator<>(predicate, spliterator));
+    }
+
+    @Override
+    public <R> Stream<R> map(Function<? super T, ? extends R> mapper) {
+      throwIfTerminated();
+      return new StreamSource<>(this, new MapToObjSpliterator<>(mapper, spliterator));
+    }
+
+    @Override
+    public IntStream mapToInt(ToIntFunction<? super T> mapper) {
+      throwIfTerminated();
+      return new IntStream.IntStreamSource(this, new MapToIntSpliterator<>(mapper, spliterator));
+    }
+
+    @Override
+    public LongStream mapToLong(ToLongFunction<? super T> mapper) {
+      throwIfTerminated();
+      return new LongStream.LongStreamSource(this, new MapToLongSpliterator<>(mapper, spliterator));
+    }
+
+    @Override
+    public DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper) {
+      throwIfTerminated();
+      return new DoubleStream.DoubleStreamSource(
+          this,
+          new MapToDoubleSpliterator<>(mapper, spliterator)
+      );
+    }
+
+    @Override
+    public <R> Stream<R> flatMap(final Function<? super T, ? extends Stream<? extends R>> mapper) {
+      throwIfTerminated();
+      final Spliterator<? extends Stream<? extends R>> spliteratorOfStreams =
+          new MapToObjSpliterator<>(mapper, spliterator);
+      return new StreamSource<R>(this, new Spliterators.AbstractSpliterator<R>(Long.MAX_VALUE, 0) {
+        Stream<? extends R> nextStream;
+        Spliterator<? extends R> next;
+
+        @Override
+        public boolean tryAdvance(Consumer<? super R> action) {
+          // look for a new spliterator
+          while (advanceToNextSpliterator()) {
+            // if we have one, try to read and use it
+            if (next.tryAdvance(action)) {
+              return true;
+            } else {
+              nextStream.close();
+              nextStream = null;
+              // failed, null it out so we can find another
+              next = null;
+            }
+          }
+          return false;
+        }
+
+        private boolean advanceToNextSpliterator() {
+          while (next == null) {
+            if (!spliteratorOfStreams.tryAdvance(n -> {
+              if (n != null) {
+                nextStream = n;
+                next = n.spliterator();
+              }
+            })) {
+              return false;
+            }
+          }
+          return true;
+        }
+      });
+    }
+
+    @Override
+    public IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper) {
+      throwIfTerminated();
+      final Spliterator<? extends IntStream> spliteratorOfStreams =
+          new MapToObjSpliterator<>(mapper, spliterator);
+      return new IntStream.IntStreamSource(
+          this,
+          new Spliterators.AbstractIntSpliterator(Long.MAX_VALUE, 0) {
+            IntStream nextStream;
+            Spliterator.OfInt next;
+
+            @Override
+            public boolean tryAdvance(IntConsumer action) {
+              // look for a new spliterator
+              while (advanceToNextSpliterator()) {
+                // if we have one, try to read and use it
+                if (next.tryAdvance(action)) {
+                  return true;
+                } else {
+                  nextStream.close();
+                  nextStream = null;
+                  // failed, null it out so we can find another
+                  next = null;
+                }
+              }
+              return false;
+            }
+
+            private boolean advanceToNextSpliterator() {
+              while (next == null) {
+                if (!spliteratorOfStreams.tryAdvance(n -> {
+                  if (n != null) {
+                    nextStream = n;
+                    next = n.spliterator();
+                  }
+                })) {
+                  return false;
+                }
+              }
+              return true;
+            }
+          }
+      );
+    }
+
+    @Override
+    public LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper) {
+      throwIfTerminated();
+      final Spliterator<? extends LongStream> spliteratorOfStreams =
+          new MapToObjSpliterator<>(mapper, spliterator);
+      return new LongStream.LongStreamSource(
+          this,
+          new Spliterators.AbstractLongSpliterator(Long.MAX_VALUE, 0) {
+            LongStream nextStream;
+            Spliterator.OfLong next;
+
+            @Override
+            public boolean tryAdvance(LongConsumer action) {
+              // look for a new spliterator
+              while (advanceToNextSpliterator()) {
+                // if we have one, try to read and use it
+                if (next.tryAdvance(action)) {
+                  return true;
+                } else {
+                  nextStream.close();
+                  nextStream = null;
+                  // failed, null it out so we can find another
+                  next = null;
+                }
+              }
+              return false;
+            }
+
+            private boolean advanceToNextSpliterator() {
+              while (next == null) {
+                if (!spliteratorOfStreams.tryAdvance(n -> {
+                  if (n != null) {
+                    nextStream = n;
+                    next = n.spliterator();
+                  }
+                })) {
+                  return false;
+                }
+              }
+              return true;
+            }
+          }
+      );
+    }
+
+    @Override
+    public DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper) {
+      throwIfTerminated();
+      final Spliterator<? extends DoubleStream> spliteratorOfStreams =
+          new MapToObjSpliterator<>(mapper, spliterator);
+      return new DoubleStream.DoubleStreamSource(
+          this,
+          new Spliterators.AbstractDoubleSpliterator(Long.MAX_VALUE, 0) {
+            DoubleStream nextStream;
+            Spliterator.OfDouble next;
+
+            @Override
+            public boolean tryAdvance(DoubleConsumer action) {
+              // look for a new spliterator
+              while (advanceToNextSpliterator()) {
+                // if we have one, try to read and use it
+                if (next.tryAdvance(action)) {
+                  return true;
+                } else {
+                  nextStream.close();
+                  nextStream = null;
+                  // failed, null it out so we can find another
+                  next = null;
+                }
+              }
+              return false;
+            }
+
+            private boolean advanceToNextSpliterator() {
+              while (next == null) {
+                if (!spliteratorOfStreams.tryAdvance(n -> {
+                  if (n != null) {
+                    nextStream = n;
+                    next = n.spliterator();
+                  }
+                })) {
+                  return false;
+                }
+              }
+              return true;
+            }
+          }
+      );
+    }
+
+    @Override
+    public Stream<T> distinct() {
+      throwIfTerminated();
+      HashSet<T> seen = new HashSet<>();
+      return filter(seen::add);
+    }
+
+    @Override
+    public Stream<T> sorted() {
+      throwIfTerminated();
+      Comparator<T> c = (Comparator) Comparator.naturalOrder();
+      return sorted(c);
+    }
+
+    @Override
+    public Stream<T> sorted(final Comparator<? super T> comparator) {
+      throwIfTerminated();
+      return new StreamSource<>(
+          this,
+          new Spliterators.AbstractSpliterator<T>(
+              spliterator.estimateSize(),
+              spliterator.characteristics() | Spliterator.SORTED
+          ) {
+            Spliterator<T> ordered = null;
+
+            @Override
+            public Comparator<? super T> getComparator() {
+              return comparator == Comparator.naturalOrder() ? null : comparator;
+            }
+
+            @Override
+            public boolean tryAdvance(Consumer<? super T> action) {
+              if (ordered == null) {
+                List<T> list = new ArrayList<>();
+                spliterator.forEachRemaining(list::add);
+                Collections.sort(list, comparator);
+                ordered = list.spliterator();
+              }
+              return ordered.tryAdvance(action);
+            }
+          }
+      );
+    }
+
+    @Override
+    public Stream<T> peek(final Consumer<? super T> action) {
+      checkNotNull(action);
+      throwIfTerminated();
+      return new StreamSource<>(
+          this,
+          new Spliterators.AbstractSpliterator<T>(
+              spliterator.estimateSize(),
+              spliterator.characteristics()
+          ) {
+            @Override
+            public boolean tryAdvance(final Consumer<? super T> innerAction) {
+              return spliterator.tryAdvance(item -> {
+                action.accept(item);
+                innerAction.accept(item);
+              });
+            }
+          }
+      );
+    }
+
+    @Override
+    public Stream<T> limit(long maxSize) {
+      throwIfTerminated();
+      checkState(maxSize >= 0, "maxSize may not be negative");
+      return new StreamSource<>(this, new LimitSpliterator<>(maxSize, spliterator));
+    }
+
+    @Override
+    public Stream<T> skip(long n) {
+      throwIfTerminated();
+      checkState(n >= 0, "n may not be negative");
+      if (n == 0) {
+        return this;
+      }
+      return new StreamSource<>(this, new SkipSpliterator<>(n, spliterator));
+    }
+
+    @Override
+    public boolean isParallel() {
+      throwIfTerminated();
+      return false;
+    }
+
+    @Override
+    public Stream<T> sequential() {
+      throwIfTerminated();
+      return this;
+    }
+
+    @Override
+    public Stream<T> parallel() {
+      throwIfTerminated();
+      // do nothing, no such thing as gwt+parallel
+      return this;
+    }
+
+    @Override
+    public Stream<T> unordered() {
+      throwIfTerminated();
+      return this;
+    }
+  }
+}

diff --git a/user/super/com/google/gwt/emul/java/util/stream/StreamSupport.java b/user/super/com/google/gwt/emul/java/util/stream/StreamSupport.java
new file mode 100644
index 0000000..12b34e3
--- /dev/null
+++ b/user/super/com/google/gwt/emul/java/util/stream/StreamSupport.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package java.util.stream;
+
+import java.util.Spliterator;
+import java.util.function.Supplier;
+
+/**
+ * See <a href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/StreamSupport.html">
+ * the official Java API doc</a> for details.
+ */
+public final class StreamSupport {
+
+  public static DoubleStream doubleStream(Spliterator.OfDouble spliterator, boolean parallel) {
+    return new DoubleStream.DoubleStreamSource(null, spliterator);
+  }
+
+  public static DoubleStream doubleStream(Supplier<? extends Spliterator.OfDouble> supplier,
+                                          int characteristics,
+                                          boolean parallel) {
+    // TODO this is somewhat convoluted, and would be better served by a lazy singleton spliterator
+    return Stream.of(supplier).map(Supplier::get).flatMapToDouble(doubleSpliterator -> {
+      return doubleStream(doubleSpliterator, parallel);
+    });
+  }
+
+  public static IntStream intStream(Spliterator.OfInt spliterator, boolean parallel) {
+    return new IntStream.IntStreamSource(null, spliterator);
+  }
+
+  public static IntStream intStream(Supplier<? extends Spliterator.OfInt> supplier,
+                                    int characteristics,
+                                    boolean parallel) {
+    // TODO this is somewhat convoluted, and would be better served by a lazy singleton spliterator
+    return Stream.of(supplier).map(Supplier::get).flatMapToInt(intSpliterator -> {
+      return intStream(intSpliterator, parallel);
+    });
+  }
+
+  public static LongStream longStream(Spliterator.OfLong spliterator, boolean parallel) {
+    return new LongStream.LongStreamSource(null, spliterator);
+  }
+
+  public static LongStream longStream(Supplier<? extends Spliterator.OfLong> supplier,
+                                      int characteristics,
+                                      final boolean parallel) {
+    // TODO this is somewhat convoluted, and would be better served by a lazy singleton spliterator
+    return Stream.of(supplier).map(Supplier::get).flatMapToLong(longSpliterator -> {
+      return longStream(longSpliterator, parallel);
+    });
+  }
+
+  public static <T> Stream<T> stream(Spliterator<T> spliterator, boolean parallel) {
+    return new Stream.StreamSource<T>(null, spliterator);
+  }
+
+  public static <T> Stream<T> stream(Supplier<? extends Spliterator<T>> supplier,
+                                     int characteristics,
+                                     final boolean parallel) {
+    // TODO this is somewhat convoluted, and would be better served by a lazy singleton spliterator
+    return Stream.of(supplier).map(Supplier::get).flatMap(spliterator -> {
+      return stream(spliterator, parallel);
+    });
+  }
+
+  private StreamSupport() {
+    // prevent instantiation
+  }
+
+}

diff --git a/user/super/com/google/gwt/emul/java/util/stream/TerminatableStream.java b/user/super/com/google/gwt/emul/java/util/stream/TerminatableStream.java
new file mode 100644
index 0000000..018331f
--- /dev/null
+++ b/user/super/com/google/gwt/emul/java/util/stream/TerminatableStream.java

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package java.util.stream;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.List;
+
+// package protected, as not part of jre
+class TerminatableStream<T extends TerminatableStream<T>> {
+  // root-only fields, ignored for non-root instances
+  private boolean terminated = false;
+  private final List<Runnable> onClose;
+
+  private final TerminatableStream<?> root;
+
+  public TerminatableStream(TerminatableStream<?> previous) {
+    if (previous == null) {
+      root = null;
+      onClose = new ArrayList<>();
+    } else {
+      root = previous;
+      onClose = null;
+    }
+  }
+
+  void throwIfTerminated() {
+    if (root != null) {
+      root.throwIfTerminated();
+    } else if (terminated) {
+      throw new IllegalStateException("Stream already terminated, can't be modified or used");
+    }
+  }
+
+  // note that not all terminals directly call this, but they must use it indirectly
+  void terminate() {
+    if (root == null) {
+      throwIfTerminated();
+      terminated = true;
+    } else {
+      root.terminate();
+    }
+  }
+
+  public T onClose(Runnable closeHandler) {
+    if (root == null) {
+      onClose.add(closeHandler);
+    } else {
+      root.onClose(closeHandler);
+    }
+
+    return (T) this;
+  }
+
+  public void close() {
+    if (root == null) {
+      terminated = true;
+
+      // TODO this might not be quite right, make sure that it behaves the same way when throwing
+      //      the same exception multiple times as JDK does.
+      LinkedHashSet<Throwable> throwables = new LinkedHashSet<>();
+      onClose.forEach((runnable) -> {
+        try {
+          runnable.run();
+        } catch (Throwable e) {
+          throwables.add(e);
+        }
+      });
+      onClose.clear();
+      if (!throwables.isEmpty()) {
+        Iterator<Throwable> iterator = throwables.iterator();
+        Throwable outer = iterator.next();
+        iterator.forEachRemaining(outer::addSuppressed);
+
+        if (outer instanceof RuntimeException) {
+          throw (RuntimeException) outer;
+        }
+        if (outer instanceof Error) {
+          throw (Error) outer;
+        }
+        assert false : "Couldn't have caught this exception from a Runnable! " + outer;
+      }
+    } else {
+      root.close();
+    }
+  }
+}
\ No newline at end of file

diff --git a/user/test/com/google/gwt/emultest/EmulJava8Suite.java b/user/test/com/google/gwt/emultest/EmulJava8Suite.java
index e898b30..572eb86 100644
--- a/user/test/com/google/gwt/emultest/EmulJava8Suite.java
+++ b/user/test/com/google/gwt/emultest/EmulJava8Suite.java

@@ -43,6 +43,11 @@
 import com.google.gwt.emultest.java8.util.TreeMapTest;
 import com.google.gwt.emultest.java8.util.VectorTest;
 import com.google.gwt.emultest.java8.util.stream.CollectorsTest;
+import com.google.gwt.emultest.java8.util.stream.DoubleStreamTest;
+import com.google.gwt.emultest.java8.util.stream.IntStreamTest;
+import com.google.gwt.emultest.java8.util.stream.LongStreamTest;
+import com.google.gwt.emultest.java8.util.stream.StreamSupportTest;
+import com.google.gwt.emultest.java8.util.stream.StreamTest;
 import com.google.gwt.junit.tools.GWTTestSuite;
 
 import junit.framework.Test;
@@ -90,6 +95,11 @@
 
     //-- java.util.stream
     suite.addTestSuite(CollectorsTest.class);
+    suite.addTestSuite(DoubleStreamTest.class);
+    suite.addTestSuite(IntStreamTest.class);
+    suite.addTestSuite(LongStreamTest.class);
+    suite.addTestSuite(StreamTest.class);
+    suite.addTestSuite(StreamSupportTest.class);
 
     return suite;
   }

diff --git a/user/test/com/google/gwt/emultest/java/util/EmulTestBase.java b/user/test/com/google/gwt/emultest/java/util/EmulTestBase.java
index a3babcc..c1fc5de 100644
--- a/user/test/com/google/gwt/emultest/java/util/EmulTestBase.java
+++ b/user/test/com/google/gwt/emultest/java/util/EmulTestBase.java

@@ -17,6 +17,7 @@
 
 import com.google.gwt.junit.client.GWTTestCase;
 
+import java.util.Arrays;
 import java.util.List;
 
 /**
@@ -41,6 +42,21 @@
     }
   }
 
+  public static void assertEquals(int[] expected, int[] actual) {
+    assertTrue("expected: " + Arrays.toString(expected) + ", actual: " + Arrays.toString(actual),
+        Arrays.equals(expected, actual));
+  }
+
+  public static void assertEquals(long[] expected, long[] actual) {
+    assertTrue("expected: " + Arrays.toString(expected) + ", actual: " + Arrays.toString(actual),
+        Arrays.equals(expected, actual));
+  }
+
+  public static void assertEquals(double[] expected, double[] actual) {
+    assertTrue("expected: " + Arrays.toString(expected) + ", actual: " + Arrays.toString(actual),
+        Arrays.equals(expected, actual));
+  }
+
   @Override
   public String getModuleName() {
     return "com.google.gwt.emultest.EmulSuite";

diff --git a/user/test/com/google/gwt/emultest/java8/util/ArraysTest.java b/user/test/com/google/gwt/emultest/java8/util/ArraysTest.java
index 3a4d42b..ffb42dd 100644
--- a/user/test/com/google/gwt/emultest/java8/util/ArraysTest.java
+++ b/user/test/com/google/gwt/emultest/java8/util/ArraysTest.java

@@ -135,4 +135,156 @@
     Arrays.setAll(array, i -> "" + (i + 1));
     assertEquals(new String[]{"1", "2", "3"}, array);
   }
+
+  public void testArrayStreamInt() {
+    int[] six = {1, 2, 3, 4, 5, 6};
+
+    // zero entries
+    assertEquals(new int[]{}, Arrays.stream(six, 0, 0).toArray());
+    assertEquals(new int[]{}, Arrays.stream(six, 1, 1).toArray());
+
+    // single entry
+    assertEquals(new int[]{1}, Arrays.stream(six, 0, 1).toArray());
+    assertEquals(new int[]{2}, Arrays.stream(six, 1, 2).toArray());
+
+    // multiple entries
+    assertEquals(new int[]{1, 2, 3}, Arrays.stream(six, 0, 3).toArray());
+    assertEquals(new int[]{4, 5, 6}, Arrays.stream(six, 3, 6).toArray());
+
+    try {
+      // start < 0
+      Arrays.stream(six, -1, 1);
+      fail("expected aioobe");
+    } catch (ArrayIndexOutOfBoundsException expected) {
+      // expected
+    }
+    try {
+      // end < start
+      Arrays.stream(six, 2, 1);
+      fail("expected aioobe");
+    } catch (ArrayIndexOutOfBoundsException expected) {
+      // expected
+    }
+    try {
+      // end > size
+      Arrays.stream(six, 0, 7);
+      fail("expected aioobe");
+    } catch (ArrayIndexOutOfBoundsException expected) {
+      // expected
+    }
+  }
+
+  public void testArrayStreamLong() {
+    long[] six = {1, 2, 3, 4, 5, 6};
+
+    // zero entries
+    assertEquals(new long[]{}, Arrays.stream(six, 0, 0).toArray());
+    assertEquals(new long[]{}, Arrays.stream(six, 1, 1).toArray());
+
+    // single entry
+    assertEquals(new long[]{1}, Arrays.stream(six, 0, 1).toArray());
+    assertEquals(new long[]{2}, Arrays.stream(six, 1, 2).toArray());
+
+    // multiple entries
+    assertEquals(new long[]{1, 2, 3}, Arrays.stream(six, 0, 3).toArray());
+    assertEquals(new long[]{4, 5, 6}, Arrays.stream(six, 3, 6).toArray());
+
+    try {
+      // start < 0
+      Arrays.stream(six, -1, 1);
+      fail("expected aioobe");
+    } catch (ArrayIndexOutOfBoundsException expected) {
+      // expected
+    }
+    try {
+      // end < start
+      Arrays.stream(six, 2, 1);
+      fail("expected aioobe");
+    } catch (ArrayIndexOutOfBoundsException expected) {
+      // expected
+    }
+    try {
+      // end > size
+      Arrays.stream(six, 0, 7);
+      fail("expected aioobe");
+    } catch (ArrayIndexOutOfBoundsException expected) {
+      // expected
+    }
+  }
+
+  public void testArrayStreamDouble() {
+    double[] six = {1, 2, 3, 4, 5, 6};
+
+    // zero entries
+    assertEquals(new double[]{}, Arrays.stream(six, 0, 0).toArray());
+    assertEquals(new double[]{}, Arrays.stream(six, 1, 1).toArray());
+
+    // single entry
+    assertEquals(new double[]{1}, Arrays.stream(six, 0, 1).toArray());
+    assertEquals(new double[]{2}, Arrays.stream(six, 1, 2).toArray());
+
+    // multiple entries
+    assertEquals(new double[]{1, 2, 3}, Arrays.stream(six, 0, 3).toArray());
+    assertEquals(new double[]{4, 5, 6}, Arrays.stream(six, 3, 6).toArray());
+
+    try {
+      // start < 0
+      Arrays.stream(six, -1, 1);
+      fail("expected aioobe");
+    } catch (ArrayIndexOutOfBoundsException expected) {
+      // expected
+    }
+    try {
+      // end < start
+      Arrays.stream(six, 2, 1);
+      fail("expected aioobe");
+    } catch (ArrayIndexOutOfBoundsException expected) {
+      // expected
+    }
+    try {
+      // end > size
+      Arrays.stream(six, 0, 7);
+      fail("expected aioobe");
+    } catch (ArrayIndexOutOfBoundsException expected) {
+      // expected
+    }
+  }
+
+  public void testArrayStreamObject() {
+    String[] six = {"1", "2", "3", "4", "5", "6"};
+
+    // zero entries
+    assertEquals(new String[]{}, Arrays.stream(six, 0, 0).toArray());
+    assertEquals(new String[]{}, Arrays.stream(six, 1, 1).toArray());
+
+    // single entry
+    assertEquals(new String[]{"1"}, Arrays.stream(six, 0, 1).toArray());
+    assertEquals(new String[]{"2"}, Arrays.stream(six, 1, 2).toArray());
+
+    // multiple entries
+    assertEquals(new String[]{"1", "2", "3"}, Arrays.stream(six, 0, 3).toArray());
+    assertEquals(new String[]{"4", "5", "6"}, Arrays.stream(six, 3, 6).toArray());
+
+    try {
+      // start < 0
+      Arrays.stream(six, -1, 1);
+      fail("expected aioobe");
+    } catch (ArrayIndexOutOfBoundsException expected) {
+      // expected
+    }
+    try {
+      // end < start
+      Arrays.stream(six, 2, 1);
+      fail("expected aioobe");
+    } catch (ArrayIndexOutOfBoundsException expected) {
+      // expected
+    }
+    try {
+      // end > size
+      Arrays.stream(six, 0, 7);
+      fail("expected aioobe");
+    } catch (ArrayIndexOutOfBoundsException expected) {
+      // expected
+    }
+  }
 }

diff --git a/user/test/com/google/gwt/emultest/java8/util/stream/DoubleStreamTest.java b/user/test/com/google/gwt/emultest/java8/util/stream/DoubleStreamTest.java
new file mode 100644
index 0000000..fb0cc17
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java8/util/stream/DoubleStreamTest.java

@@ -0,0 +1,443 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.google.gwt.emultest.java8.util.stream;
+
+import com.google.gwt.emultest.java.util.EmulTestBase;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.DoubleSummaryStatistics;
+import java.util.Iterator;
+import java.util.List;
+import java.util.OptionalDouble;
+import java.util.Spliterator;
+import java.util.function.DoubleSupplier;
+import java.util.function.Supplier;
+import java.util.stream.DoubleStream;
+import java.util.stream.Stream;
+
+/**
+ * Tests {@link DoubleStream}.
+ */
+public class DoubleStreamTest extends EmulTestBase {
+
+  public void testEmptyStream() {
+    DoubleStream empty = DoubleStream.empty();
+    assertEquals(0, empty.count());
+    try {
+      empty.count();
+      fail("second terminal operation should have thrown IllegalStateEx");
+    } catch (IllegalStateException expected) {
+      // expected
+    }
+
+    assertEquals(0, DoubleStream.empty().limit(2).toArray().length);
+    assertEquals(0L, DoubleStream.empty().count());
+    assertEquals(0L, DoubleStream.empty().limit(2).count());
+
+    assertFalse(DoubleStream.empty().findFirst().isPresent());
+    assertFalse(DoubleStream.empty().findAny().isPresent());
+    assertFalse(DoubleStream.empty().max().isPresent());
+    assertFalse(DoubleStream.empty().min().isPresent());
+    assertTrue(DoubleStream.empty().noneMatch(item -> true));
+    assertTrue(DoubleStream.empty().allMatch(item -> true));
+    assertFalse(DoubleStream.empty().anyMatch(item -> true));
+    assertEquals(new double[0], DoubleStream.empty().toArray());
+  }
+
+  public void testStreamOfOne() {
+    Supplier<DoubleStream> one = () -> DoubleStream.of(1);
+    assertEquals(new double[]{1d}, one.get().toArray());
+    assertEquals(1L, one.get().count());
+    assertEquals(1d, one.get().findFirst().getAsDouble(), 0d);
+    assertEquals(1d, one.get().findAny().getAsDouble(), 0d);
+  }
+
+  public void testBuilder() {
+    DoubleStream s = DoubleStream.builder()
+        .add(1d)
+        .add(3d)
+        .add(2d)
+        .build();
+
+    assertEquals(
+        new double[] {1d, 3d, 2d},
+        s.toArray()
+    );
+
+    DoubleStream.Builder builder = DoubleStream.builder();
+    DoubleStream built = builder.build();
+    assertEquals(0, built.count());
+    try {
+      builder.build();
+      fail("build() after build() should fail");
+    } catch (IllegalStateException expected) {
+      // expected
+    }
+    try {
+      builder.add(10d);
+      fail("add() after build() should fail");
+    } catch (IllegalStateException expected) {
+      // expected
+    }
+  }
+
+  public void testConcat() {
+    Supplier<DoubleStream> adbc = () -> {
+      return DoubleStream.concat(DoubleStream.of(1, 4), DoubleStream.of(2, 3));
+    };
+
+    assertEquals(new double[]{1d, 4d, 2d, 3d}, adbc.get().toArray());
+    assertEquals(new double[]{1d, 2d, 3d, 4d}, adbc.get().sorted().toArray());
+
+    List<String> closed = new ArrayList<>();
+    DoubleStream first = DoubleStream.of(1d).onClose(() -> closed.add("first"));
+    DoubleStream second = DoubleStream.of(2d).onClose(() -> closed.add("second"));
+
+    DoubleStream concat = DoubleStream.concat(first, second);
+
+    // read everything, make sure we saw it all and didn't close automatically
+    double collectedAll = concat.sum();
+    assertEquals(3d, collectedAll);
+    assertEquals(0, closed.size());
+
+    concat.close();
+    assertEquals(Arrays.asList("first", "second"), closed);
+  }
+
+  public void testIterate() {
+    assertEquals(
+        new double[]{10d, 11d, 12d, 13d, 14d},
+        DoubleStream.iterate(0d, l -> l + 1d)
+            .skip(10)
+            .limit(5)
+            .toArray()
+    );
+  }
+
+  public void testGenerate() {
+    // infinite, but if you limit it is already too short to skip much
+    assertEquals(new double[0], DoubleStream.generate(makeGenerator()).limit(4).skip(5).toArray());
+
+    assertEquals(
+        new double[]{10d, 11d, 12d, 13d, 14d},
+        DoubleStream.generate(makeGenerator())
+            .skip(10)
+            .limit(5)
+            .toArray()
+    );
+  }
+
+  private DoubleSupplier makeGenerator() {
+    return new DoubleSupplier() {
+      double next = 0d;
+
+      @Override
+      public double getAsDouble() {
+        return next++;
+      }
+    };
+  }
+
+  public void testToArray() {
+    assertEquals(new double[0], DoubleStream.of().toArray());
+    assertEquals(new double[] {1d}, DoubleStream.of(1d).toArray());
+    assertEquals(new double[] {3d, 2d, 0d}, DoubleStream.of(3d, 2d, 0d).toArray());
+  }
+
+  public void testReduce() {
+    double reduced = DoubleStream.of(1d, 2d, 4d).reduce(0, Double::sum);
+    assertEquals(7d, reduced, 0d);
+
+    reduced = DoubleStream.of().reduce(0, Double::sum);
+    assertEquals(0d, reduced, 0d);
+
+    OptionalDouble maybe = DoubleStream.of(1d, 4d, 8d).reduce(Double::sum);
+    assertTrue(maybe.isPresent());
+    assertEquals(13, maybe.getAsDouble(), 0d);
+    maybe = DoubleStream.of().reduce(Double::sum);
+    assertFalse(maybe.isPresent());
+  }
+
+  public void testFilter() {
+    // unconsumed stream never runs filter
+    boolean[] data = {false};
+    DoubleStream.of(1d, 2d, 3d).filter(i -> data[0] |= true);
+    assertFalse(data[0]);
+
+    // one result
+    assertEquals(
+        new double[]{1d},
+        DoubleStream.of(1d, 2d, 3d, 4d, 3d).filter(a -> a == 1).toArray()
+    );
+    // zero results
+    assertEquals(
+        new double[0],
+        DoubleStream.of(1d, 2d, 3d, 4d, 3d).filter(a -> false).toArray()
+    );
+    // two results
+    assertEquals(
+        new double[] {2d, 4d},
+        DoubleStream.of(1d, 2d, 3d, 4d, 3d).filter(a -> a % 2 == 0).toArray()
+    );
+    // all
+    assertEquals(
+        new double[] {1d, 2d, 3d, 4d, 3d},
+        DoubleStream.of(1d, 2d, 3d, 4d, 3d).filter(a -> true).toArray()
+    );
+  }
+
+  public void testMap() {
+    // unconsumed stream never runs map
+    int[] data = {0};
+    DoubleStream.of(1d, 2d, 3d).map(i -> data[0]++);
+    assertEquals(0, data[0]);
+
+    assertEquals(
+        new double[] {2d, 4d, 6d},
+        DoubleStream.of(1d, 2d, 3d).map(i -> i * 2).toArray()
+    );
+  }
+
+  public void testPeek() {
+    // unconsumed stream never peeks
+    boolean[] data = {false};
+    DoubleStream.of(1d, 2d, 3d).peek(i -> data[0] |= true);
+    assertFalse(data[0]);
+
+    // make sure we saw it all in order
+    double[] items = new double[] {1d, 2d, 3d};
+    List<Double> peeked = new ArrayList<>();
+    DoubleStream.of(items).peek(peeked::add).forEach(item -> {
+      // do nothing, just run
+    });
+    assertEquals(items.length, peeked.size());
+    for (int i = 0; i < items.length; i++) {
+      assertEquals(items[i], peeked.get(i), 0d);
+    }
+  }
+
+  // same impl, no parallel in browser
+  public void testFindFirstOrAny() {
+    OptionalDouble any = DoubleStream.of(1d, 2d).findAny();
+    assertTrue(any.isPresent());
+    assertEquals(1d, any.getAsDouble(), 0d);
+  }
+
+  public void testAnyMatch() {
+    // all
+    assertTrue(DoubleStream.of(1d, 2d).anyMatch(s -> true));
+
+    // some
+    assertTrue(DoubleStream.of(1d, 2d).anyMatch(s -> s == 1d));
+
+    // none
+    assertFalse(DoubleStream.of(1d, 2d).anyMatch(s -> false));
+  }
+
+  public void testAllMatch() {
+    // all
+    assertTrue(DoubleStream.of(1d, 2d).allMatch(s -> true));
+
+    // some
+    assertFalse(DoubleStream.of(1d, 2d).allMatch(s -> s == 1d));
+
+    // none
+    assertFalse(DoubleStream.of(1d, 2d).allMatch(s -> false));
+  }
+
+  public void testNoneMatch() {
+    // all
+    assertFalse(DoubleStream.of(1d, 2d).noneMatch(s -> true));
+
+    // some
+    assertFalse(DoubleStream.of(1d, 2d).noneMatch(s -> s == 1d));
+
+    // none
+    assertTrue(DoubleStream.of(1d, 2d).noneMatch(s -> false));
+  }
+
+  public void testFlatMap() {
+    assertEquals(0L, DoubleStream.empty().flatMap(value -> DoubleStream.of(1d)).count());
+    assertEquals(0L, DoubleStream.of(1d).flatMap(value -> DoubleStream.empty()).count());
+    assertEquals(0L, DoubleStream.of(1d).flatMap(value -> DoubleStream.of()).count());
+    assertEquals(0L, DoubleStream.of().flatMap(value -> DoubleStream.of(1d)).count());
+    assertEquals(1L, DoubleStream.of(1d).flatMap(value -> DoubleStream.of(1d)).count());
+
+    DoubleStream values = DoubleStream.of(1d, 2d, 3d);
+
+    assertEquals(
+        new double[] {1d, 2d, 2d, 4d, 3d, 6d},
+        values.flatMap(i -> DoubleStream.of(i, i * 2d)).toArray()
+    );
+  }
+
+  public void testMapToOthers() {
+    Supplier<DoubleStream> s = () -> DoubleStream.of(1d, 2d, 10d);
+
+    assertEquals(
+        new String[]{"1", "2", "10"},
+        s.get().mapToObj(DoubleStreamTest::toIntegralString).toArray(String[]::new)
+    );
+
+    assertEquals(
+        new long[]{1L, 2L, 10L},
+        s.get().mapToLong(i -> (long) i).toArray()
+    );
+
+    assertEquals(
+        new int[] {1, 2, 10},
+        s.get().mapToInt(i -> (int) i).toArray()
+    );
+  }
+
+  public void testDistinct() {
+    double[] distinct = DoubleStream.of(1d, 2d, 3d, 2d).distinct().toArray();
+    assertEquals(3, distinct.length);
+    assertEquals(1d + 2d + 3d, distinct[0] + distinct[1] + distinct[2], 0d);
+  }
+
+  public void testSorted() {
+    double[] sorted = DoubleStream.of(3d, 1d, 2d).sorted().toArray();
+    assertEquals(new double[] {1d, 2d, 3d}, sorted);
+  }
+
+  public void testMinMax() {
+    Supplier<DoubleStream> stream = () -> DoubleStream.of(2d, 3d, 4d, 1d);
+
+    assertEquals(1d, stream.get().min().orElse(0), 0d);
+    assertEquals(4d, stream.get().max().orElse(0), 0d);
+
+    assertFalse(stream.get().filter(a -> false).max().isPresent());
+    assertFalse(stream.get().filter(a -> false).min().isPresent());
+  }
+
+  public void testCountLimitSkip() {
+    Supplier<DoubleStream> stream = () -> DoubleStream.of(1d, 2d, 3d, 4d);
+
+    assertEquals(4L, stream.get().count());
+
+    assertEquals(4L, stream.get().limit(4).count());
+    assertEquals(4L, stream.get().limit(5).count());
+    assertEquals(3L, stream.get().limit(3).count());
+
+    assertEquals(3L, stream.get().skip(1).limit(3).count());
+
+    assertEquals(2L, stream.get().limit(3).skip(1).count());
+
+    assertEquals(1L, stream.get().skip(3).count());
+
+    assertEquals(new double[] {3d, 4d}, stream.get().skip(2).limit(3).toArray());
+    assertEquals(new double[] {3d}, stream.get().skip(2).limit(1).toArray());
+
+    assertEquals(new double[] {4d}, stream.get().skip(3).toArray());
+    assertEquals(new double[] {}, stream.get().skip(5).toArray());
+
+    assertEquals(new double[] {1d, 2d}, stream.get().limit(2).toArray());
+
+    assertEquals(new double[] {2d}, stream.get().limit(2).skip(1).toArray());
+  }
+
+  public void testBoxed() {
+    Supplier<DoubleStream> stream = () -> DoubleStream.of(1d, 2d);
+    Stream<Double> expected = stream.get().mapToObj(Double::valueOf);
+    assertEquals(expected.toArray(), stream.get().boxed().toArray());
+  }
+
+  public void testSummaryStats() {
+    Supplier<DoubleStream> stream = () -> DoubleStream.of(1d, 2d, 3d);
+    DoubleSummaryStatistics summaryStats = stream.get().summaryStatistics();
+    assertEquals(3L, summaryStats.getCount());
+    assertEquals(1d, summaryStats.getMin(), 0d);
+    assertEquals(2d, summaryStats.getAverage(), 0d);
+    assertEquals(3d, summaryStats.getMax(), 0d);
+    assertEquals(6d, summaryStats.getSum(), 0d);
+
+    summaryStats.accept(6L);
+    assertEquals(4L, summaryStats.getCount());
+    assertEquals(1d, summaryStats.getMin(), 0d);
+    assertEquals(3d, summaryStats.getAverage(), 0d);
+    assertEquals(6d, summaryStats.getMax(), 0d);
+    assertEquals(12d, summaryStats.getSum(), 0d);
+
+    DoubleSummaryStatistics combinedSumStats = stream.get().summaryStatistics();
+    combinedSumStats.combine(DoubleStream.of(4d, 5d, 6d, 0d).summaryStatistics());
+    assertEquals(7L, combinedSumStats.getCount());
+    assertEquals(0d, combinedSumStats.getMin(), 0d);
+    assertEquals(3d, combinedSumStats.getAverage(), 0d);
+    assertEquals(6d, combinedSumStats.getMax(), 0d);
+    assertEquals(21d, combinedSumStats.getSum(), 0d);
+  }
+
+  public void testAverage() {
+    assertFalse(DoubleStream.empty().average().isPresent());
+    assertEquals(2.0d, DoubleStream.of(1d, 2d, 3d).average().getAsDouble(), 0d);
+    assertEquals(0d, DoubleStream.of(1d, 2d, -3d).average().getAsDouble(), 0d);
+    assertEquals(-2.0d, DoubleStream.of(-1d, -2d, -3d).average().getAsDouble(), 0d);
+  }
+
+  public void testSum() {
+    assertEquals(6d, DoubleStream.of(1d, 2d, 3d).sum(), 0d);
+    assertEquals(0d, DoubleStream.of(1d, 2d, -3d).sum(), 0d);
+    assertEquals(-6d, DoubleStream.of(-1d, -2d, -3d).sum(), 0d);
+  }
+
+  public void testCollect() {
+    // noinspection StringConcatenationInsideStringBufferAppend
+    String val = DoubleStream.of(1d, 2d, 3d, 4d, 5d).collect(StringBuilder::new,
+        (stringBuilder, d) -> stringBuilder.append(toIntegralString(d)),
+        StringBuilder::append).toString();
+
+    assertEquals("12345", val);
+  }
+
+  public void testForEach() {
+    List<Double> vals = new ArrayList<>();
+    DoubleStream.of(1d, 2d, 3d, 4d, 5d).forEach(vals::add);
+    assertEquals(5, vals.size());
+    assertEquals(new Double[] {1d, 2d, 3d, 4d, 5d}, vals.toArray(new Double[vals.size()]));
+  }
+
+  public void testIterator() {
+    List<Double> vals = new ArrayList<>();
+    Iterator<Double> iterator = DoubleStream.of(1d, 2d, 3d, 4d, 5d).iterator();
+    while (iterator.hasNext()) {
+      vals.add(iterator.next());
+    }
+    assertEquals(5, vals.size());
+    assertEquals(new Double[] {1d, 2d, 3d, 4d, 5d}, vals.toArray(new Double[vals.size()]));
+  }
+
+  public void testSpliterator() {
+    Spliterator<Double> spliterator = DoubleStream.of(1d, 2d, 3d, 4d, 5d).spliterator();
+    assertEquals(5, spliterator.estimateSize());
+    assertEquals(5, spliterator.getExactSizeIfKnown());
+
+    List<Double> vals = new ArrayList<>();
+    while (spliterator.tryAdvance(vals::add)) {
+      // work is all done in the condition
+    }
+
+    assertEquals(5, vals.size());
+    assertEquals(new Double[] {1d, 2d, 3d, 4d, 5d}, vals.toArray(new Double[vals.size()]));
+  }
+
+  // See https://github.com/gwtproject/gwt/issues/8615
+  private static String toIntegralString(double value) {
+    return "" + (int) value;
+  }
+}

diff --git a/user/test/com/google/gwt/emultest/java8/util/stream/IntStreamTest.java b/user/test/com/google/gwt/emultest/java8/util/stream/IntStreamTest.java
new file mode 100644
index 0000000..232aebe
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java8/util/stream/IntStreamTest.java

@@ -0,0 +1,462 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.google.gwt.emultest.java8.util.stream;
+
+import com.google.gwt.emultest.java.util.EmulTestBase;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.IntSummaryStatistics;
+import java.util.Iterator;
+import java.util.List;
+import java.util.OptionalInt;
+import java.util.Spliterator;
+import java.util.function.IntSupplier;
+import java.util.function.Supplier;
+import java.util.stream.DoubleStream;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+import java.util.stream.Stream;
+
+/**
+ * Tests {@link IntStream}.
+ */
+public class IntStreamTest extends EmulTestBase {
+
+  public void testEmptyStream() {
+    IntStream empty = IntStream.empty();
+    assertEquals(0, empty.count());
+    try {
+      empty.count();
+      fail("second terminal operation should have thrown IllegalStateEx");
+    } catch (IllegalStateException expected) {
+      // expected
+    }
+
+    assertEquals(0, IntStream.empty().limit(2).toArray().length);
+    assertEquals(0L, IntStream.empty().count());
+    assertEquals(0L, IntStream.empty().limit(2).count());
+
+    assertFalse(IntStream.empty().findFirst().isPresent());
+    assertFalse(IntStream.empty().findAny().isPresent());
+    assertFalse(IntStream.empty().max().isPresent());
+    assertFalse(IntStream.empty().min().isPresent());
+    assertTrue(IntStream.empty().noneMatch(item -> true));
+    assertTrue(IntStream.empty().allMatch(item -> true));
+    assertFalse(IntStream.empty().anyMatch(item -> true));
+    assertEquals(new int[0], IntStream.empty().toArray());
+  }
+
+  public void testStreamOfOne() {
+    Supplier<IntStream> one = () -> IntStream.of(1);
+    assertEquals(new int[]{1}, one.get().toArray());
+    assertEquals(1L, one.get().count());
+    assertEquals(1, one.get().findFirst().getAsInt());
+    assertEquals(1, one.get().findAny().getAsInt());
+  }
+
+  public void testBuilder() {
+    IntStream s = IntStream.builder()
+        .add(1)
+        .add(3)
+        .add(2)
+        .build();
+
+    assertEquals(
+        new int[] {1, 3, 2},
+        s.toArray()
+    );
+
+    IntStream.Builder builder = IntStream.builder();
+    IntStream built = builder.build();
+    assertEquals(0, built.count());
+    try {
+      builder.build();
+      fail("build() after build() should fail");
+    } catch (IllegalStateException expected) {
+      // expected
+    }
+    try {
+      builder.add(10);
+      fail("add() after build() should fail");
+    } catch (IllegalStateException expected) {
+      // expected
+    }
+  }
+
+  public void testConcat() {
+    Supplier<IntStream> adbc = () -> IntStream.concat(IntStream.of(1, 4), IntStream.of(2, 3));
+
+    assertEquals(new int[]{1, 4, 2, 3}, adbc.get().toArray());
+    assertEquals(new int[]{1, 2, 3, 4}, adbc.get().sorted().toArray());
+
+    List<String> closed = new ArrayList<>();
+    IntStream first = IntStream.of(1).onClose(() -> closed.add("first"));
+    IntStream second = IntStream.of(2).onClose(() -> closed.add("second"));
+
+    IntStream concat = IntStream.concat(first, second);
+
+    // read everything, make sure we saw it all and didn't close automatically
+    int collectedAll = concat.sum();
+    assertEquals(3, collectedAll);
+    assertEquals(0, closed.size());
+
+    concat.close();
+    assertEquals(Arrays.asList("first", "second"), closed);
+  }
+
+  public void testIterate() {
+    assertEquals(
+        new int[]{10, 11, 12, 13, 14},
+        IntStream.iterate(0, i -> i + 1)
+            .skip(10)
+            .limit(5)
+            .toArray()
+    );
+  }
+
+  public void testGenerate() {
+    // infinite, but if you limit it is already too short to skip much
+    assertEquals(new int[0], IntStream.generate(makeGenerator()).limit(4).skip(5).toArray());
+
+    assertEquals(
+        new int[] {10, 11, 12, 13, 14},
+        IntStream.generate(makeGenerator())
+            .skip(10)
+            .limit(5)
+            .toArray()
+    );
+  }
+
+  private IntSupplier makeGenerator() {
+    return new IntSupplier() {
+      int next = 0;
+
+      @Override
+      public int getAsInt() {
+        return next++;
+      }
+    };
+  }
+
+  public void testRange() {
+    assertEquals(new int[] {1, 2, 3, 4}, IntStream.range(1, 5).toArray());
+    assertEquals(new int[] {-1, 0, 1, 2, 3, 4}, IntStream.range(-1, 5).toArray());
+    assertEquals(new int[] {}, IntStream.range(1, -5).toArray());
+    assertEquals(new int[] {}, IntStream.range(-1, -5).toArray());
+  }
+
+  public void testRangeClosed() {
+    assertEquals(new int[] {1, 2, 3, 4, 5}, IntStream.rangeClosed(1, 5).toArray());
+    assertEquals(new int[] {-1, 0, 1, 2, 3, 4, 5}, IntStream.rangeClosed(-1, 5).toArray());
+    assertEquals(new int[] {}, IntStream.rangeClosed(1, -5).toArray());
+    assertEquals(new int[] {}, IntStream.rangeClosed(-1, -5).toArray());
+  }
+
+  public void testToArray() {
+    assertEquals(new int[0], IntStream.of().toArray());
+    assertEquals(new int[] {1}, IntStream.of(1).toArray());
+    assertEquals(new int[] {3,2,0}, IntStream.of(3,2,0).toArray());
+  }
+
+  public void testReduce() {
+    int reduced = IntStream.of(1, 2, 4).reduce(0, Integer::sum);
+    assertEquals(7, reduced);
+
+    reduced = IntStream.of().reduce(0, Integer::sum);
+    assertEquals(0, reduced);
+
+    OptionalInt maybe = IntStream.of(1, 4, 8).reduce(Integer::sum);
+    assertTrue(maybe.isPresent());
+    assertEquals(13, maybe.getAsInt());
+    maybe = IntStream.of().reduce(Integer::sum);
+    assertFalse(maybe.isPresent());
+  }
+
+  public void testFilter() {
+    // unconsumed stream never runs filter
+    boolean[] data = {false};
+    IntStream.of(1, 2, 3).filter(i -> data[0] |= true);
+    assertFalse(data[0]);
+
+    // one result
+    assertEquals(
+        new int[] {1},
+        IntStream.of(1, 2, 3, 4, 3).filter(a -> a == 1).toArray()
+    );
+    // zero results
+    assertEquals(
+        new int[0],
+        IntStream.of(1, 2, 3, 4, 3).filter(a -> false).toArray()
+    );
+    // two results
+    assertEquals(
+        new int[] {2, 4},
+        IntStream.of(1, 2, 3, 4, 3).filter(a -> a % 2 == 0).toArray()
+    );
+    // all
+    assertEquals(
+        new int[] {1, 2, 3, 4, 3},
+        IntStream.of(1, 2, 3, 4, 3).filter(a -> true).toArray()
+    );
+  }
+
+  public void testMap() {
+    // unconsumed stream never runs map
+    int[] data = {0};
+    IntStream.of(1, 2, 3).map(i -> data[0]++);
+    assertEquals(0, data[0]);
+
+    assertEquals(
+        new int[] {2, 4, 6},
+        IntStream.of(1, 2, 3).map(i -> i * 2).toArray()
+    );
+  }
+
+  public void testPeek() {
+    // unconsumed stream never peeks
+    boolean[] data = {false};
+    IntStream.of(1, 2, 3).peek(i -> data[0] |= true);
+    assertFalse(data[0]);
+
+    // make sure we saw it all in order
+    int[] items = new int[] {1, 2, 3};
+    List<Integer> peeked = new ArrayList<>();
+    IntStream.of(items).peek(peeked::add).forEach(item -> {
+      // do nothing, just run
+    });
+    assertEquals(items.length, peeked.size());
+    for (int i = 0; i < items.length; i++) {
+      assertEquals(items[i], (int) peeked.get(i));
+    }
+  }
+
+  // same impl, no parallel in browser
+  public void testFindFirstOrAny() {
+    OptionalInt any = IntStream.of(1, 2).findAny();
+    assertTrue(any.isPresent());
+    assertEquals(1, any.getAsInt());
+  }
+
+  public void testAnyMatch() {
+    // all
+    assertTrue(IntStream.of(1, 2).anyMatch(s -> true));
+
+    // some
+    assertTrue(IntStream.of(1, 2).anyMatch(s -> s == 1));
+
+    // none
+    assertFalse(IntStream.of(1, 2).anyMatch(s -> false));
+  }
+
+  public void testAllMatch() {
+    // all
+    assertTrue(IntStream.of(1, 2).allMatch(s -> true));
+
+    // some
+    assertFalse(IntStream.of(1, 2).allMatch(s -> s == 1));
+
+    // none
+    assertFalse(IntStream.of(1, 2).allMatch(s -> false));
+  }
+
+  public void testNoneMatch() {
+    // all
+    assertFalse(IntStream.of(1, 2).noneMatch(s -> true));
+
+    // some
+    assertFalse(IntStream.of(1, 2).noneMatch(s -> s == 1));
+
+    // none
+    assertTrue(IntStream.of(1, 2).noneMatch(s -> false));
+  }
+
+  public void testFlatMap() {
+    assertEquals(0, IntStream.empty().flatMap(value -> IntStream.of(1)).count());
+    assertEquals(0, IntStream.of(1).flatMap(value -> IntStream.empty()).count());
+    assertEquals(0, IntStream.of(1).flatMap(value -> IntStream.of()).count());
+    assertEquals(0, IntStream.of().flatMap(value -> IntStream.of(1)).count());
+    assertEquals(1, IntStream.of(1).flatMap(value -> IntStream.of(1)).count());
+
+    IntStream values = IntStream.of(1, 2, 3);
+
+    assertEquals(
+        new int[] {1, 2, 2, 4, 3, 6},
+        values.flatMap(i -> IntStream.of(i, i * 2)).toArray()
+    );
+  }
+
+  public void testMapToOthers() {
+    Supplier<IntStream> s = () -> IntStream.of(1, 2, 10);
+
+    assertEquals(
+        new String[] {"1", "2", "10"},
+        s.get().mapToObj(String::valueOf).toArray(String[]::new)
+    );
+
+    assertEquals(
+        new long[] {1, 2, 10},
+        s.get().mapToLong(i -> (long) i).toArray()
+    );
+
+    assertEquals(
+        new double[] {1, 2, 10},
+        s.get().mapToDouble(i -> (double) i).toArray()
+    );
+  }
+
+  public void testDistinct() {
+    int[] distinct = IntStream.of(1, 2, 3, 2).distinct().toArray();
+    assertEquals(3, distinct.length);
+    assertEquals(1 + 2 + 3, distinct[0] + distinct[1] + distinct[2]);
+  }
+
+  public void testSorted() {
+    int[] sorted = IntStream.of(3, 1, 2).sorted().toArray();
+    assertEquals(new int[] {1, 2, 3}, sorted);
+  }
+
+  public void testMinMax() {
+    Supplier<IntStream> stream = () -> IntStream.of(2, 3, 4, 1);
+
+    assertEquals(1, stream.get().min().orElse(0));
+    assertEquals(4, stream.get().max().orElse(0));
+
+    assertFalse(stream.get().filter(a -> false).max().isPresent());
+    assertFalse(stream.get().filter(a -> false).min().isPresent());
+  }
+
+  public void testCountLimitSkip() {
+    Supplier<IntStream> stream = () -> IntStream.of(1, 2, 3, 4);
+
+    assertEquals(4, stream.get().count());
+
+    assertEquals(4, stream.get().limit(4).count());
+    assertEquals(4, stream.get().limit(5).count());
+    assertEquals(3, stream.get().limit(3).count());
+
+    assertEquals(3, stream.get().skip(1).limit(3).count());
+
+    assertEquals(2, stream.get().limit(3).skip(1).count());
+
+    assertEquals(1, stream.get().skip(3).count());
+
+    assertEquals(new int[] {3, 4}, stream.get().skip(2).limit(3).toArray());
+    assertEquals(new int[] {3}, stream.get().skip(2).limit(1).toArray());
+
+    assertEquals(new int[] {4}, stream.get().skip(3).toArray());
+    assertEquals(new int[] {}, stream.get().skip(5).toArray());
+
+    assertEquals(new int[] {1, 2}, stream.get().limit(2).toArray());
+
+    assertEquals(new int[] {2}, stream.get().limit(2).skip(1).toArray());
+  }
+
+  public void testBoxed() {
+    Supplier<IntStream> stream = () -> IntStream.of(1, 2);
+    Stream<Integer> expected = stream.get().mapToObj(Integer::valueOf);
+    assertEquals(expected.toArray(), stream.get().boxed().toArray());
+  }
+
+  public void testAsOtherPrimitive() {
+    Supplier<IntStream> stream = () -> IntStream.of(1, 2);
+
+    DoubleStream actualDoubleStream = stream.get().asDoubleStream();
+    assertEquals(new double[]{1, 2}, actualDoubleStream.toArray());
+
+    LongStream actualLongStream = stream.get().asLongStream();
+    assertEquals(new long[] {1, 2}, actualLongStream.toArray());
+  }
+
+  public void testSummaryStats() {
+    Supplier<IntStream> stream = () -> IntStream.of(1, 2, 3);
+    IntSummaryStatistics summaryStats = stream.get().summaryStatistics();
+    assertEquals(3, summaryStats.getCount());
+    assertEquals(1, summaryStats.getMin());
+    assertEquals(2, summaryStats.getAverage(), 0d);
+    assertEquals(3, summaryStats.getMax());
+    assertEquals(6, summaryStats.getSum());
+
+    summaryStats.accept(6);
+    assertEquals(4, summaryStats.getCount());
+    assertEquals(1, summaryStats.getMin());
+    assertEquals(3, summaryStats.getAverage(), 0d);
+    assertEquals(6, summaryStats.getMax());
+    assertEquals(12, summaryStats.getSum());
+
+    IntSummaryStatistics combinedSumStats = stream.get().summaryStatistics();
+    combinedSumStats.combine(IntStream.of(4, 5, 6, 0).summaryStatistics());
+    assertEquals(7, combinedSumStats.getCount());
+    assertEquals(0, combinedSumStats.getMin());
+    assertEquals(3, combinedSumStats.getAverage(), 0d);
+    assertEquals(6, combinedSumStats.getMax());
+    assertEquals(21, combinedSumStats.getSum());
+  }
+
+  public void testAverage() {
+    assertFalse(IntStream.empty().average().isPresent());
+    assertEquals(2.0d, IntStream.of(1, 2, 3).average().getAsDouble(), 0d);
+    assertEquals(0d, IntStream.of(1, 2, -3).average().getAsDouble(), 0d);
+    assertEquals(-2.0d, IntStream.of(-1, -2, -3).average().getAsDouble(), 0d);
+  }
+
+  public void testSum() {
+    assertEquals(6, IntStream.of(1, 2, 3).sum());
+    assertEquals(0, IntStream.of(1, 2, -3).sum());
+    assertEquals(-6, IntStream.of(-1, -2, -3).sum());
+  }
+
+  public void testCollect() {
+    String val = IntStream.of(1, 2, 3, 4, 5).collect(StringBuilder::new,
+        // TODO switch to a lambda reference once #9340 is fixed
+        (stringBuilder, i) -> stringBuilder.append(i),
+        StringBuilder::append).toString();
+
+    assertEquals("12345", val);
+  }
+
+  public void testForEach() {
+    List<Integer> vals = new ArrayList<>();
+    IntStream.of(1, 2, 3, 4, 5).forEach(vals::add);
+    assertEquals(5, vals.size());
+    assertEquals(new Integer[] {1, 2, 3, 4, 5}, vals.toArray(new Integer[vals.size()]));
+  }
+
+  public void testIterator() {
+    List<Integer> vals = new ArrayList<>();
+    Iterator<Integer> iterator = IntStream.of(1, 2, 3, 4, 5).iterator();
+    while (iterator.hasNext()) {
+      vals.add(iterator.next());
+    }
+    assertEquals(5, vals.size());
+    assertEquals(new Integer[] {1, 2, 3, 4, 5}, vals.toArray(new Integer[vals.size()]));
+  }
+
+  public void testSpliterator() {
+    Spliterator<Integer> spliterator = IntStream.of(1, 2, 3, 4, 5).spliterator();
+    assertEquals(5, spliterator.estimateSize());
+    assertEquals(5, spliterator.getExactSizeIfKnown());
+
+    List<Integer> vals = new ArrayList<>();
+    while (spliterator.tryAdvance(vals::add)) {
+      // work is all done in the condition
+    }
+
+    assertEquals(5, vals.size());
+    assertEquals(new Integer[] {1, 2, 3, 4, 5}, vals.toArray(new Integer[vals.size()]));
+  }
+}

diff --git a/user/test/com/google/gwt/emultest/java8/util/stream/LongStreamTest.java b/user/test/com/google/gwt/emultest/java8/util/stream/LongStreamTest.java
new file mode 100644
index 0000000..407f4bf
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java8/util/stream/LongStreamTest.java

@@ -0,0 +1,457 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.google.gwt.emultest.java8.util.stream;
+
+import com.google.gwt.emultest.java.util.EmulTestBase;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.LongSummaryStatistics;
+import java.util.OptionalLong;
+import java.util.Spliterator;
+import java.util.function.LongSupplier;
+import java.util.function.Supplier;
+import java.util.stream.DoubleStream;
+import java.util.stream.LongStream;
+import java.util.stream.Stream;
+
+/**
+ * Tests {@link LongStream}.
+ */
+public class LongStreamTest extends EmulTestBase {
+
+  public void testEmptyStream() {
+    LongStream empty = LongStream.empty();
+    assertEquals(0, empty.count());
+    try {
+      empty.count();
+      fail("second terminal operation should have thrown IllegalStateEx");
+    } catch (IllegalStateException expected) {
+      // expected
+    }
+
+    assertEquals(0, LongStream.empty().limit(2).toArray().length);
+    assertEquals(0L, LongStream.empty().count());
+    assertEquals(0L, LongStream.empty().limit(2).count());
+
+    assertFalse(LongStream.empty().findFirst().isPresent());
+    assertFalse(LongStream.empty().findAny().isPresent());
+    assertFalse(LongStream.empty().max().isPresent());
+    assertFalse(LongStream.empty().min().isPresent());
+    assertTrue(LongStream.empty().noneMatch(item -> true));
+    assertTrue(LongStream.empty().allMatch(item -> true));
+    assertFalse(LongStream.empty().anyMatch(item -> true));
+    assertEquals(new long[0], LongStream.empty().toArray());
+  }
+
+  public void testStreamOfOne() {
+    Supplier<LongStream> one = () -> LongStream.of(1);
+    assertEquals(new long[]{1L}, one.get().toArray());
+    assertEquals(1L, one.get().count());
+    assertEquals(1, one.get().findFirst().getAsLong());
+    assertEquals(1, one.get().findAny().getAsLong());
+  }
+
+  public void testBuilder() {
+    LongStream s = LongStream.builder()
+        .add(1L)
+        .add(3L)
+        .add(2L)
+        .build();
+
+    assertEquals(
+        new long[] {1L, 3L, 2L},
+        s.toArray()
+    );
+
+    LongStream.Builder builder = LongStream.builder();
+    LongStream built = builder.build();
+    assertEquals(0L, built.count());
+    try {
+      builder.build();
+      fail("build() after build() should fail");
+    } catch (IllegalStateException expected) {
+      // expected
+    }
+    try {
+      builder.add(10L);
+      fail("add() after build() should fail");
+    } catch (IllegalStateException expected) {
+      // expected
+    }
+  }
+
+  public void testConcat() {
+    Supplier<LongStream> adbc = () -> LongStream.concat(LongStream.of(1, 4), LongStream.of(2, 3));
+
+    assertEquals(new long[]{1L, 4L, 2L, 3L}, adbc.get().toArray());
+    assertEquals(new long[]{1L, 2L, 3L, 4L}, adbc.get().sorted().toArray());
+
+    List<String> closed = new ArrayList<>();
+    LongStream first = LongStream.of(1L).onClose(() -> closed.add("first"));
+    LongStream second = LongStream.of(2L).onClose(() -> closed.add("second"));
+
+    LongStream concat = LongStream.concat(first, second);
+
+    // read everything, make sure we saw it all and didn't close automatically
+    long collectedAll = concat.sum();
+    assertEquals(3L, collectedAll);
+    assertEquals(0, closed.size());
+
+    concat.close();
+    assertEquals(Arrays.asList("first", "second"), closed);
+  }
+
+  public void testIterate() {
+    assertEquals(
+        new long[]{10L, 11L, 12L, 13L, 14L},
+        LongStream.iterate(0L, l -> l + 1L)
+            .skip(10)
+            .limit(5)
+            .toArray()
+    );
+  }
+
+  public void testGenerate() {
+    // infinite, but if you limit it is already too short to skip much
+    assertEquals(new long[0], LongStream.generate(makeGenerator()).limit(4).skip(5).toArray());
+
+    assertEquals(
+        new long[]{10L, 11L, 12L, 13L, 14L},
+        LongStream.generate(makeGenerator())
+            .skip(10)
+            .limit(5)
+            .toArray()
+    );
+  }
+
+  private LongSupplier makeGenerator() {
+    return new LongSupplier() {
+      long next = 0L;
+
+      @Override
+      public long getAsLong() {
+        return next++;
+      }
+    };
+  }
+
+  public void testRange() {
+    assertEquals(new long[] {1L, 2L, 3L, 4L}, LongStream.range(1, 5).toArray());
+    assertEquals(new long[] {-1L, 0L, 1L, 2L, 3L, 4L}, LongStream.range(-1, 5).toArray());
+    assertEquals(new long[] {}, LongStream.range(1, -5).toArray());
+    assertEquals(new long[] {}, LongStream.range(-1, -5).toArray());
+  }
+
+  public void testRangeClosed() {
+    assertEquals(new long[] {1L, 2L, 3L, 4L, 5L}, LongStream.rangeClosed(1, 5).toArray());
+    assertEquals(new long[] {-1L, 0L, 1L, 2L, 3L, 4L, 5L}, LongStream.rangeClosed(-1, 5).toArray());
+    assertEquals(new long[] {}, LongStream.rangeClosed(1, -5).toArray());
+    assertEquals(new long[] {}, LongStream.rangeClosed(-1, -5).toArray());
+  }
+
+  public void testToArray() {
+    assertEquals(new long[0], LongStream.of().toArray());
+    assertEquals(new long[] {1L}, LongStream.of(1L).toArray());
+    assertEquals(new long[] {3L, 2L, 0L}, LongStream.of(3L,2L,0L).toArray());
+  }
+
+  public void testReduce() {
+    long reduced = LongStream.of(1L, 2L, 4L).reduce(0, Long::sum);
+    assertEquals(7, reduced);
+
+    reduced = LongStream.of().reduce(0, Long::sum);
+    assertEquals(0L, reduced);
+
+    OptionalLong maybe = LongStream.of(1L, 4L, 8L).reduce(Long::sum);
+    assertTrue(maybe.isPresent());
+    assertEquals(13L, maybe.getAsLong());
+    maybe = LongStream.of().reduce(Long::sum);
+    assertFalse(maybe.isPresent());
+  }
+
+  public void testFilter() {
+    // unconsumed stream never runs filter
+    boolean[] data = {false};
+    LongStream.of(1L, 2L, 3L).filter(i -> data[0] |= true);
+    assertFalse(data[0]);
+
+    // one result
+    assertEquals(
+        new long[] {1L},
+        LongStream.of(1L, 2L, 3L, 4L, 3L).filter(a -> a == 1).toArray()
+    );
+    // zero results
+    assertEquals(
+        new long[0],
+        LongStream.of(1L, 2L, 3L, 4L, 3L).filter(a -> false).toArray()
+    );
+    // two results
+    assertEquals(
+        new long[] {2L, 4L},
+        LongStream.of(1L, 2L, 3L, 4L, 3L).filter(a -> a % 2 == 0).toArray()
+    );
+    // all
+    assertEquals(
+        new long[] {1L, 2L, 3L, 4L, 3L},
+        LongStream.of(1L, 2L, 3L, 4L, 3L).filter(a -> true).toArray()
+    );
+  }
+
+  public void testMap() {
+    // unconsumed stream never runs map
+    int[] data = {0};
+    LongStream.of(1L, 2L, 3L).map(i -> data[0]++);
+    assertEquals(0, data[0]);
+
+    assertEquals(
+        new long[] {2L, 4L, 6L},
+        LongStream.of(1L, 2L, 3L).map(i -> i * 2).toArray()
+    );
+  }
+
+  public void testPeek() {
+    // unconsumed stream never peeks
+    boolean[] data = {false};
+    LongStream.of(1L, 2L, 3L).peek(i -> data[0] |= true);
+    assertFalse(data[0]);
+
+    // make sure we saw it all in order
+    long[] items = new long[] {1L, 2L, 3L};
+    List<Long> peeked = new ArrayList<>();
+    LongStream.of(items).peek(peeked::add).forEach(item -> {
+      // do nothing, just run
+    });
+    assertEquals(items.length, peeked.size());
+    for (int i = 0; i < items.length; i++) {
+      assertEquals(items[i], (long) peeked.get(i));
+    }
+  }
+
+  // same impl, no parallel in browser
+  public void testFindFirstOrAny() {
+    OptionalLong any = LongStream.of(1L, 2L).findAny();
+    assertTrue(any.isPresent());
+    assertEquals(1L, any.getAsLong());
+  }
+
+  public void testAnyMatch() {
+    // all
+    assertTrue(LongStream.of(1L, 2L).anyMatch(s -> true));
+
+    // some
+    assertTrue(LongStream.of(1L, 2L).anyMatch(s -> s == 1L));
+
+    // none
+    assertFalse(LongStream.of(1L, 2L).anyMatch(s -> false));
+  }
+
+  public void testAllMatch() {
+    // all
+    assertTrue(LongStream.of(1L, 2L).allMatch(s -> true));
+
+    // some
+    assertFalse(LongStream.of(1L, 2L).allMatch(s -> s == 1L));
+
+    // none
+    assertFalse(LongStream.of(1L, 2L).allMatch(s -> false));
+  }
+
+  public void testNoneMatch() {
+    // all
+    assertFalse(LongStream.of(1L, 2L).noneMatch(s -> true));
+
+    // some
+    assertFalse(LongStream.of(1L, 2L).noneMatch(s -> s == 1L));
+
+    // none
+    assertTrue(LongStream.of(1L, 2L).noneMatch(s -> false));
+  }
+
+  public void testFlatMap() {
+    assertEquals(0L, LongStream.empty().flatMap(value -> LongStream.of(1L)).count());
+    assertEquals(0L, LongStream.of(1L).flatMap(value -> LongStream.empty()).count());
+    assertEquals(0L, LongStream.of(1L).flatMap(value -> LongStream.of()).count());
+    assertEquals(0L, LongStream.of().flatMap(value -> LongStream.of(1L)).count());
+    assertEquals(1L, LongStream.of(1L).flatMap(value -> LongStream.of(1L)).count());
+
+    LongStream values = LongStream.of(1L, 2L, 3L);
+
+    assertEquals(
+        new long[] {1L, 2L, 2L, 4L, 3L, 6L},
+        values.flatMap(i -> LongStream.of(i, i * 2)).toArray()
+    );
+  }
+
+  public void testMapToOthers() {
+    Supplier<LongStream> s = () -> LongStream.of(1, 2, 10);
+
+    assertEquals(
+        new String[] {"1", "2", "10"},
+        s.get().mapToObj(String::valueOf).toArray(String[]::new)
+    );
+
+    assertEquals(
+        new int[] {1, 2, 10},
+        s.get().mapToInt(i -> (int) i).toArray()
+    );
+
+    assertEquals(
+        new double[] {1d, 2d, 10d},
+        s.get().mapToDouble(i -> (double) i).toArray()
+    );
+  }
+
+  public void testDistinct() {
+    long[] distinct = LongStream.of(1L, 2L, 3L, 2L).distinct().toArray();
+    assertEquals(3, distinct.length);
+    assertEquals(1L + 2L + 3L, distinct[0] + distinct[1] + distinct[2]);
+  }
+
+  public void testSorted() {
+    long[] sorted = LongStream.of(3L, 1L, 2L).sorted().toArray();
+    assertEquals(new long[] {1L, 2L, 3L}, sorted);
+  }
+
+  public void testMinMax() {
+    Supplier<LongStream> stream = () -> LongStream.of(2L, 3L, 4L, 1L);
+
+    assertEquals(1L, stream.get().min().orElse(0));
+    assertEquals(4L, stream.get().max().orElse(0));
+
+    assertFalse(stream.get().filter(a -> false).max().isPresent());
+    assertFalse(stream.get().filter(a -> false).min().isPresent());
+  }
+
+  public void testCountLimitSkip() {
+    Supplier<LongStream> stream = () -> LongStream.of(1L, 2L, 3L, 4L);
+
+    assertEquals(4L, stream.get().count());
+
+    assertEquals(4L, stream.get().limit(4).count());
+    assertEquals(4L, stream.get().limit(5).count());
+    assertEquals(3L, stream.get().limit(3).count());
+
+    assertEquals(3L, stream.get().skip(1).limit(3).count());
+
+    assertEquals(2L, stream.get().limit(3).skip(1).count());
+
+    assertEquals(1L, stream.get().skip(3).count());
+
+    assertEquals(new long[] {3L, 4L}, stream.get().skip(2).limit(3).toArray());
+    assertEquals(new long[] {3L}, stream.get().skip(2).limit(1).toArray());
+
+    assertEquals(new long[] {4L}, stream.get().skip(3).toArray());
+    assertEquals(new long[] {}, stream.get().skip(5).toArray());
+
+    assertEquals(new long[] {1L, 2L}, stream.get().limit(2).toArray());
+
+    assertEquals(new long[] {2L}, stream.get().limit(2).skip(1).toArray());
+  }
+
+  public void testBoxed() {
+    Supplier<LongStream> stream = () -> LongStream.of(1L, 2L);
+    Stream<Long> expected = stream.get().mapToObj(Long::valueOf);
+    assertEquals(expected.toArray(), stream.get().boxed().toArray());
+  }
+
+  public void testAsOtherPrimitive() {
+    Supplier<LongStream> stream = () -> LongStream.of(1L, 2L);
+    DoubleStream actualDoubleStream = stream.get().asDoubleStream();
+    assertEquals(new double[]{1, 2}, actualDoubleStream.toArray());
+  }
+
+  public void testSummaryStats() {
+    Supplier<LongStream> stream = () -> LongStream.of(1L, 2L, 3L);
+    LongSummaryStatistics summaryStats = stream.get().summaryStatistics();
+    assertEquals(3L, summaryStats.getCount());
+    assertEquals(1L, summaryStats.getMin());
+    assertEquals(2L, summaryStats.getAverage(), 0d);
+    assertEquals(3L, summaryStats.getMax());
+    assertEquals(6L, summaryStats.getSum());
+
+    summaryStats.accept(6L);
+    assertEquals(4L, summaryStats.getCount());
+    assertEquals(1L, summaryStats.getMin());
+    assertEquals(3L, summaryStats.getAverage(), 0d);
+    assertEquals(6L, summaryStats.getMax());
+    assertEquals(12L, summaryStats.getSum());
+
+    LongSummaryStatistics combinedSumStats = stream.get().summaryStatistics();
+    combinedSumStats.combine(LongStream.of(4L, 5L, 6L, 0L).summaryStatistics());
+    assertEquals(7L, combinedSumStats.getCount());
+    assertEquals(0L, combinedSumStats.getMin());
+    assertEquals(3L, combinedSumStats.getAverage(), 0d);
+    assertEquals(6L, combinedSumStats.getMax());
+    assertEquals(21L, combinedSumStats.getSum());
+  }
+
+  public void testAverage() {
+    assertFalse(LongStream.empty().average().isPresent());
+    assertEquals(2.0d, LongStream.of(1L, 2L, 3L).average().getAsDouble(), 0d);
+    assertEquals(0d, LongStream.of(1L, 2L, -3L).average().getAsDouble(), 0d);
+    assertEquals(-2.0d, LongStream.of(-1L, -2L, -3L).average().getAsDouble(), 0d);
+  }
+
+  public void testSum() {
+    assertEquals(6L, LongStream.of(1L, 2L, 3L).sum());
+    assertEquals(0L, LongStream.of(1L, 2L, -3L).sum());
+    assertEquals(-6L, LongStream.of(-1L, -2L, -3L).sum());
+  }
+
+  public void testCollect() {
+    String val = LongStream.of(1L, 2L, 3L, 4L, 5L).collect(StringBuilder::new,
+        // TODO switch to a lambda reference once #9340 is fixed
+        (stringBuilder, lng) -> stringBuilder.append(lng),
+        StringBuilder::append).toString();
+
+    assertEquals("12345", val);
+  }
+
+  public void testForEach() {
+    List<Long> vals = new ArrayList<>();
+    LongStream.of(1L, 2L, 3L, 4L, 5L).forEach(vals::add);
+    assertEquals(5, vals.size());
+    assertEquals(new Long[] {1L, 2L, 3L, 4L, 5L}, vals.toArray(new Long[vals.size()]));
+  }
+
+  public void testIterator() {
+    List<Long> vals = new ArrayList<>();
+    Iterator<Long> iterator = LongStream.of(1L, 2L, 3L, 4L, 5L).iterator();
+    while (iterator.hasNext()) {
+      vals.add(iterator.next());
+    }
+    assertEquals(5, vals.size());
+    assertEquals(new Long[] {1L, 2L, 3L, 4L, 5L}, vals.toArray(new Long[vals.size()]));
+  }
+
+  public void testSpliterator() {
+    Spliterator<Long> spliterator = LongStream.of(1L, 2L, 3L, 4L, 5L).spliterator();
+    assertEquals(5, spliterator.estimateSize());
+    assertEquals(5, spliterator.getExactSizeIfKnown());
+
+    List<Long> vals = new ArrayList<>();
+    while (spliterator.tryAdvance(vals::add)) {
+      // work is all done in the condition
+    }
+
+    assertEquals(5, vals.size());
+    assertEquals(new Long[] {1L, 2L, 3L, 4L, 5L}, vals.toArray(new Long[vals.size()]));
+  }
+}

diff --git a/user/test/com/google/gwt/emultest/java8/util/stream/StreamSupportTest.java b/user/test/com/google/gwt/emultest/java8/util/stream/StreamSupportTest.java
new file mode 100644
index 0000000..0ff6331
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java8/util/stream/StreamSupportTest.java

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.google.gwt.emultest.java8.util.stream;
+
+import static java.util.stream.StreamSupport.doubleStream;
+import static java.util.stream.StreamSupport.intStream;
+import static java.util.stream.StreamSupport.longStream;
+import static java.util.stream.StreamSupport.stream;
+
+import com.google.gwt.emultest.java.util.EmulTestBase;
+
+import java.util.Spliterators;
+import java.util.stream.DoubleStream;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+import java.util.stream.Stream;
+
+/**
+ * Tests {@link java.util.stream.StreamSupport}.
+ */
+public class StreamSupportTest extends EmulTestBase {
+
+  public void testDoubleStream() {
+    DoubleStream doubles = doubleStream(
+        Spliterators.spliterator(new double[] {1d, 2d, 3d, 4d}, 0),
+        false
+    );
+
+    assertNotNull(doubles);
+    assertEquals(new double[]{1d, 2d, 3d}, doubles.limit(3).toArray());
+
+    doubles = doubleStream(() -> Spliterators.spliterator(new double[] {1d, 2d, 3d, 4d}, 0), 0,
+        false);
+
+    assertNotNull(doubles);
+    assertEquals(
+        new double[] {2d, 3d},
+        doubles.skip(1).limit(2).toArray()
+    );
+  }
+
+  public void testIntStream() {
+    IntStream ints = intStream(
+        Spliterators.spliterator(new int[] {1, 2, 3, 4}, 0),
+        false
+    );
+
+    assertNotNull(ints);
+    assertEquals(new int[] {1, 2, 3}, ints.limit(3).toArray());
+
+    ints = intStream(() -> Spliterators.spliterator(new int[] {1, 2, 3, 4}, 0), 0, false);
+
+    assertNotNull(ints);
+    assertEquals(
+        new int[] {2, 3},
+        ints.skip(1).limit(2).toArray()
+    );
+  }
+
+  public void testLongStream() {
+    LongStream longs = longStream(
+        Spliterators.spliterator(new long[] {1L, 2L, 3L, 4L}, 0),
+        false
+    );
+
+    assertNotNull(longs);
+    assertEquals(new long[] {1L, 2L, 3L}, longs.limit(3).toArray());
+
+    longs = longStream(() -> Spliterators.spliterator(new long[] {1L, 2L, 3L, 4L}, 0), 0, false);
+
+    assertNotNull(longs);
+    assertEquals(
+        new long[] {2L, 3L},
+        longs.skip(1).limit(2).toArray()
+    );
+  }
+
+  public void testStream() {
+    Stream<String> strings = stream(
+        Spliterators.spliterator(new String[] {"a", "b", "c", "d"}, 0),
+        false
+    );
+
+    assertNotNull(strings);
+    assertEquals(new String[] {"a", "b", "c"}, strings.limit(3).toArray());
+
+    strings = stream(() -> Spliterators.spliterator(new String[] {"a", "b", "c", "d"}, 0), 0, false);
+
+    assertNotNull(strings);
+    assertEquals(
+        new String[] {"b", "c"},
+        strings.skip(1).limit(2).toArray()
+    );
+  }
+}

diff --git a/user/test/com/google/gwt/emultest/java8/util/stream/StreamTest.java b/user/test/com/google/gwt/emultest/java8/util/stream/StreamTest.java
new file mode 100644
index 0000000..d46bfaf
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java8/util/stream/StreamTest.java

@@ -0,0 +1,627 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.google.gwt.emultest.java8.util.stream;
+
+import static java.util.Arrays.asList;
+
+import com.google.gwt.emultest.java.util.EmulTestBase;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Optional;
+import java.util.Spliterator;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.DoubleStream;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+import java.util.stream.Stream;
+
+/**
+ * Tests {@link Stream}.
+ */
+public class StreamTest extends EmulTestBase {
+
+  public void testEmptyStream() {
+    Stream<Object> empty = Stream.empty();
+    assertEquals(0, empty.count());
+    try {
+      empty.count();
+      fail("second terminal operation should have thrown IllegalStateEx");
+    } catch (IllegalStateException expected) {
+      // expected
+    }
+
+    assertEquals(0, Stream.empty().limit(2).collect(Collectors.toList()).size());
+    assertEquals(0, Stream.empty().count());
+    assertEquals(0, Stream.empty().limit(2).count());
+
+    assertFalse(Stream.empty().findFirst().isPresent());
+    assertFalse(Stream.empty().findAny().isPresent());
+    assertFalse(Stream.<String>empty().max(Comparator.naturalOrder()).isPresent());
+    assertFalse(Stream.<String>empty().min(Comparator.naturalOrder()).isPresent());
+    assertTrue(Stream.empty().allMatch(item -> true));
+    assertFalse(Stream.empty().anyMatch(item -> true));
+    assertTrue(Stream.empty().noneMatch(item -> false));
+    assertFalse(Stream.empty().iterator().hasNext());
+    assertFalse(Stream.empty().spliterator().tryAdvance(a -> fail("should not advance")));
+    Stream.empty().spliterator().forEachRemaining(a -> fail("should not advance"));
+    assertEquals(new Object[0], Stream.empty().toArray());
+    assertEquals(new Object[0], Stream.empty().toArray(Object[]::new));
+  }
+
+  public void testStreamOfOne() {
+    Supplier<Stream<String>> one = () -> Stream.of("");
+    assertEquals(Collections.singletonList(""), one.get().collect(Collectors.toList()));
+    assertEquals(1L, one.get().count());
+    assertEquals("", one.get().findFirst().get());
+    assertEquals("", one.get().findAny().get());
+  }
+
+  public void testBuilder() {
+    Supplier<Stream<String>> s = () -> Stream.<String>builder()
+        .add("1")
+        .add("3")
+        .add("2")
+        .build();
+
+    Optional<String> max = s.get().filter(str -> !str.equals("3")).max(Comparator.naturalOrder());
+    assertTrue(max.isPresent());
+    assertEquals("2", max.get());
+
+    max = s.get().max(Comparator.reverseOrder());
+    assertTrue(max.isPresent());
+    assertEquals("1", max.get());
+
+    Stream.Builder<Object> builder = Stream.builder();
+    Stream<Object> built = builder.build();
+    assertEquals(0, built.count());
+    try {
+      builder.build();
+      fail("build() after build() should fail");
+    } catch (IllegalStateException expected) {
+      // expected
+    }
+    try {
+      builder.add("asdf");
+      fail("add() after build() should fail");
+    } catch (IllegalStateException expected) {
+      // expected
+    }
+  }
+
+  public void testConcat() {
+    Supplier<Stream<String>> adbc = () -> Stream.concat(Stream.of("a", "d"), Stream.of("b", "c"));
+
+    assertEquals(new String[]{"a", "d", "b", "c"}, adbc.get().toArray(String[]::new));
+    assertEquals(new String[]{"a", "b", "c", "d"}, adbc.get().sorted().toArray(String[]::new));
+
+    List<String> closed = new ArrayList<>();
+    Stream<String> first = Stream.of("first").onClose(() -> closed.add("first"));
+    Stream<String> second = Stream.of("second").onClose(() -> closed.add("second"));
+
+    Stream<String> concat = Stream.concat(first, second);
+
+    // read everything, make sure we saw it all and didn't close automatically
+    String collectedAll = concat.collect(Collectors.joining());
+    assertEquals("firstsecond", collectedAll);
+    assertEquals(0, closed.size());
+
+    concat.close();
+    assertEquals(Arrays.asList("first", "second"), closed);
+  }
+
+  public void testIterate() {
+    assertEquals(
+        new Integer[]{10, 11, 12, 13, 14},
+        Stream.iterate(0, i -> i + 1)
+            .skip(10)
+            .limit(5)
+            .toArray(Integer[]::new)
+    );
+  }
+
+  public void testGenerate() {
+    // infinite, but if you limit it is already too short to skip much
+    assertEquals(new Integer[]{}, Stream.generate(makeGenerator())
+        .limit(4)
+        .skip(5)
+        .toArray(Integer[]::new));
+
+    assertEquals(new Integer[]{10, 11, 12, 13, 14}, Stream.generate(makeGenerator())
+        .skip(10)
+        .limit(5)
+        .toArray(Integer[]::new));
+  }
+
+  private Supplier<Integer> makeGenerator() {
+    return new Supplier<Integer>() {
+      int next = 0;
+
+      @Override
+      public Integer get() {
+        return next++;
+      }
+    };
+  }
+
+  public void testSpliterator() {
+    final String[] values = new String[] {"a", "b", "c"};
+
+    Spliterator<String> spliterator = Stream.of(values).spliterator();
+    assertEquals(3, spliterator.estimateSize());
+    assertEquals(3, spliterator.getExactSizeIfKnown());
+
+    List<String> actualValues = new ArrayList<>();
+    while (spliterator.tryAdvance(actualValues::add)) {
+      // work is all done in the condition
+    }
+
+    assertEquals(asList(values), actualValues);
+  }
+
+  public void testIterator() {
+    final String[] values = new String[] {"a", "b", "c"};
+
+    List<String> actualValues = new ArrayList<String>();
+    Iterator<String> iterator = Stream.of(values).iterator();
+    while (iterator.hasNext()) {
+      actualValues.add(iterator.next());
+    }
+    assertEquals(asList(values), actualValues);
+  }
+
+  public void testForEach() {
+    final String[] values = new String[] {"a", "b", "c"};
+
+    List<String> actualValues = new ArrayList<>();
+    Stream.of(values).forEach(actualValues::add);
+    assertEquals(asList(values), actualValues);
+  }
+
+  // toArray
+  public void testToArray() {
+    assertEquals(
+        new Object[]{"a", "b"},
+        asList("a", "b").stream().toArray()
+    );
+    assertEquals(
+        new String[]{"a", "b"},
+        asList("a", "b").stream().toArray(String[]::new)
+    );
+  }
+
+  // reduce
+  public void testReduce() {
+    String reduced = Stream.of("a", "b", "c").reduce("", String::concat);
+    assertEquals("abc", reduced);
+
+    reduced = Stream.<String>of().reduce("initial", String::concat);
+    assertEquals("initial", reduced);
+
+    Optional<String> maybe = Stream.of("a", "b", "c").reduce(String::concat);
+    assertTrue(maybe.isPresent());
+    assertEquals("abc", maybe.get());
+    maybe = Stream.<String>of().reduce(String::concat);
+    assertFalse(maybe.isPresent());
+
+    reduced = Stream.of("a", "b", "c").reduce("", String::concat, String::concat);
+    assertEquals("abc", reduced);
+  }
+
+  public void testCollect() {
+    final String[] values = new String[] {"a", "b", "c"};
+
+    String collectedString = Stream.of(values).collect(StringBuilder::new,
+        StringBuilder::append,
+        StringBuilder::append).toString();
+    assertEquals("abc", collectedString);
+
+    List<String> collectedList = Stream.of(values).collect(Collectors.toList());
+    assertEquals(asList(values), collectedList);
+  }
+
+  public void testFilter() {
+    // unconsumed stream never runs filter
+    boolean[] data = {false};
+    Stream.of(1, 2, 3).filter(i -> data[0] |= true);
+    assertFalse(data[0]);
+
+    // one result
+    assertEquals(
+        Collections.singletonList("a"),
+        Stream.of("a", "b", "c", "d", "c").filter(a -> a.equals("a")).collect(Collectors.toList())
+    );
+    // zero results
+    assertEquals(
+        Collections.emptyList(),
+        Stream.of("a", "b", "c", "d", "c").filter(a -> false).collect(Collectors.toList())
+    );
+    // two results
+    assertEquals(
+        asList("c3", "c5"),
+        Stream.of("a1", "b2", "c3", "d4", "c5")
+            .filter(a -> a.startsWith("c"))
+            .collect(Collectors.toList())
+    );
+    // all
+    assertEquals(
+        asList("a", "b", "c", "d", "c"),
+        Stream.of("a", "b", "c", "d", "c").filter(a -> true).collect(Collectors.toList())
+    );
+  }
+
+  public void testMap() {
+    // unconsumed stream never runs map
+    boolean[] data = {false};
+    Stream.of(1, 2, 3).map(i -> data[0] |= true);
+    assertFalse(data[0]);
+
+    assertEquals(
+        asList("#1", "#2", "#3"),
+        Stream.of(1, 2, 3).map(i -> "#" + i).collect(Collectors.toList())
+    );
+  }
+
+  public void testPeek() {
+    // unconsumed stream never peeks
+    boolean[] data = {false};
+    Stream.of(1, 2, 3).peek(i -> data[0] |= true);
+    assertFalse(data[0]);
+
+    // make sure we saw it all in order
+    List<String> items = asList("a", "b", "c");
+    List<String> peeked = new ArrayList<>();
+    items.stream().peek(peeked::add).forEach(item -> {
+      // deliberately do nothing, just run
+    });
+    assertEquals(items, peeked);
+  }
+
+  // same impl, no parallel in browser
+  public void testFindFirstOrAny() {
+    Optional<String> any = Stream.of("a", "b").findAny();
+    assertTrue(any.isPresent());
+    assertEquals("a", any.get());
+  }
+
+  public void testAnyMatch() {
+    // all
+    assertTrue(Stream.of("a", "b").anyMatch(s -> true));
+
+    // some
+    assertTrue(Stream.of("a", "b").anyMatch(s -> s.equals("a")));
+
+    // none
+    assertFalse(Stream.of("a", "b").anyMatch(s -> false));
+  }
+
+  public void testAllMatch() {
+    // all
+    assertTrue(Stream.of("a", "b").allMatch(s -> true));
+
+    // some
+    assertFalse(Stream.of("a", "b").allMatch(s -> s.equals("a")));
+
+    // none
+    assertFalse(Stream.of("a", "b").allMatch(s -> false));
+  }
+
+  public void testNoneMatch() {
+    // all
+    assertFalse(Stream.of("a", "b").noneMatch(s -> true));
+
+    // some
+    assertFalse(Stream.of("a", "b").noneMatch(s -> s.equals("a")));
+
+    // none
+    assertTrue(Stream.of("a", "b").noneMatch(s -> false));
+  }
+
+  public void testFlatMap() {
+    assertEquals(0, Stream.<Stream<String>>empty().flatMap(Function.identity()).count());
+    assertEquals(0, Stream.of(Stream.<String>empty()).flatMap(Function.identity()).count());
+    assertEquals(0, Stream.of(Stream.of()).flatMap(Function.identity()).count());
+    assertEquals(1, Stream.of(Stream.of("")).flatMap(Function.identity()).count());
+
+    Stream<Stream<String>> strings = Stream.of(Stream.of("a", "b"), Stream.empty(), Stream.of("c"));
+
+    assertEquals(
+        asList("a", "b", "c"),
+        strings.flatMap(Function.identity()).collect(Collectors.toList())
+    );
+  }
+  public void testMapToPrimitives() {
+    Supplier<Stream<String>> s = () -> Stream.of("1", "2", "10");
+
+    assertEquals(
+        new int[]{1, 2, 10},
+        s.get().mapToInt(Integer::parseInt).toArray()
+    );
+
+    assertEquals(
+        new long[]{1, 2, 10},
+        s.get().mapToLong(Long::parseLong).toArray()
+    );
+
+    assertEquals(
+        new double[]{1, 2, 10},
+        s.get().mapToDouble(Double::parseDouble).toArray()
+    );
+  }
+
+  public void testFlatMapToPrimitives() {
+    assertEquals(0, Stream.<IntStream>empty().flatMapToInt(Function.identity()).count());
+    assertEquals(0, Stream.of(IntStream.empty()).flatMapToInt(Function.identity()).count());
+    assertEquals(0, Stream.of(IntStream.of()).flatMapToInt(Function.identity()).count());
+    assertEquals(1, Stream.of(IntStream.of(0)).flatMapToInt(Function.identity()).count());
+
+    Stream<IntStream> intStreams = Stream.of(
+        IntStream.of(1, 2),
+        IntStream.empty(),
+        IntStream.of(5)
+    );
+    assertEquals(
+        new int[]{1, 2, 5},
+        intStreams.flatMapToInt(Function.identity()).toArray()
+    );
+
+    Stream<LongStream> longStreams = Stream.of(
+        LongStream.of(1, 2),
+        LongStream.empty(),
+        LongStream.of(5)
+    );
+    assertEquals(
+        new long[]{1, 2, 5},
+        longStreams.flatMapToLong(Function.identity()).toArray()
+    );
+
+    Stream<DoubleStream> doubleStreams = Stream.of(
+        DoubleStream.of(1, 2),
+        DoubleStream.empty(),
+        DoubleStream.of(5)
+    );
+    assertEquals(
+        new double[]{1, 2, 5},
+        doubleStreams.flatMapToDouble(Function.identity()).toArray()
+    );
+  }
+
+  public void testDistinct() {
+    List<String> distinct = asList("a", "b", "c", "b").stream()
+        .distinct()
+        .collect(Collectors.toList());
+    assertEquals(3, distinct.size());
+    assertTrue(distinct.contains("a"));
+    assertTrue(distinct.contains("b"));
+    assertTrue(distinct.contains("c"));
+  }
+
+  public void testSorted() {
+    List<String> sorted = asList("c", "a", "b").stream().sorted().collect(Collectors.toList());
+    List<String> reversed = asList("c", "a", "b").stream()
+        .sorted(Comparator.reverseOrder())
+        .collect(Collectors.toList());
+
+    assertEquals(asList("a", "b", "c"), sorted);
+    assertEquals(asList("c", "b", "a"), reversed);
+  }
+
+  public void testMinMax() {
+    Supplier<Stream<String>> stream = () -> Stream.of("b", "c", "d", "a");
+
+    assertEquals("a", stream.get().min(Comparator.naturalOrder()).orElse(null));
+    assertEquals("d", stream.get().min(Comparator.reverseOrder()).orElse(null));
+    assertEquals("a", stream.get().max(Comparator.reverseOrder()).orElse(null));
+    assertEquals("d", stream.get().max(Comparator.naturalOrder()).orElse(null));
+
+    assertFalse(stream.get().filter(a -> false).max(Comparator.naturalOrder()).isPresent());
+    assertFalse(stream.get().filter(a -> false).min(Comparator.naturalOrder()).isPresent());
+  }
+
+  public void testCountLimitSkip() {
+    Supplier<Stream<String>> stream = () -> asList("a", "b", "c", "d").stream();
+
+    assertEquals(4, stream.get().count());
+
+    assertEquals(4, stream.get().limit(4).count());
+    assertEquals(4, stream.get().limit(5).count());
+    assertEquals(3, stream.get().limit(3).count());
+
+    assertEquals(3, stream.get().skip(1).limit(3).count());
+
+    assertEquals(2, stream.get().limit(3).skip(1).count());
+
+    assertEquals(1, stream.get().skip(3).count());
+
+    assertEquals(asList("c", "d"), stream.get().skip(2).limit(3).collect(Collectors.toList()));
+    assertEquals(Collections.singletonList("c"), stream.get()
+        .skip(2)
+        .limit(1)
+        .collect(Collectors.toList()));
+
+    assertEquals(Collections.singletonList("d"), stream.get()
+        .skip(3)
+        .collect(Collectors.toList()));
+    assertEquals(Collections.emptyList(), stream.get()
+        .skip(5)
+        .collect(Collectors.toList()));
+
+    assertEquals(asList("a", "b"), stream.get()
+        .limit(2)
+        .collect(Collectors.toList()));
+
+    assertEquals(Collections.singletonList("b"), stream.get()
+        .limit(2)
+        .skip(1)
+        .collect(Collectors.toList()));
+  }
+
+  // This frustrating test was written first on the JVM stream to discover the basic behavior before
+  // trying to implement it in GWT. As far as I can tell, none of this is clearly described in
+  // javadoc. Also note that it is *not* required to use the returned stream from calling onClose
+  public void testCloseQuirks() {
+    // all subclasses use the same close()/onClose(...) impl, just test once with Stream.empty()
+
+    Stream<Object> s = Stream.of(1);
+    s.close();
+    // allow multiple close
+    s.close();
+
+    // Add a handler, close, and attempt to re-close - handler only runs the one time
+    int[] calledCount = {0};
+    s = Stream.empty();
+    s.onClose(() -> calledCount[0]++);
+    // shouldn't have been called yet
+    assertEquals(0, calledCount[0]);
+    s.close();
+    // called once
+    assertEquals(1, calledCount[0]);
+    s.close();
+    // not called again on subsequent closes
+    assertEquals(1, calledCount[0]);
+
+    // Add a handler after close, and re-close, the handler will only go off after the _second_
+    // close
+    calledCount[0] = 0;
+    s = Stream.of(1);
+    s.close();
+    s = s.onClose(() -> calledCount[0]++);
+    // shouldn't have been called yet
+    assertEquals(0, calledCount[0]);
+    s.close();
+    // frustratingly, the JVM apparently permits each handler when added to let the stream be closed
+    // _again_
+    assertEquals(1, calledCount[0]);
+
+    // Adding yet another runnable and closing again demonstrates this - only the new one is run,
+    // the old ones are not
+    s = s.onClose(() -> calledCount[0]++);
+    s.close();
+    assertEquals(2, calledCount[0]);
+
+    // Add two handlers, ensure both are called, and neither called the second time the stream is
+    // closed
+    calledCount[0] = 0;
+    s = Stream.empty();
+    s = s.onClose(() -> calledCount[0]++);
+    s = s.onClose(() -> calledCount[0]++);
+    s.close();
+    assertEquals(2, calledCount[0]);
+    s.close();
+    assertEquals(2, calledCount[0]);
+  }
+
+  public void testClose() {
+    // terminate stream before closing, confirm that handler is called
+    Stream<Object> s = Stream.of("a", "b", "c");
+    int[] calledCount = {0};
+    s = s.onClose(() -> calledCount[0]++);
+
+    long count = s.count();
+    assertEquals(3, count);
+    assertEquals(0, calledCount[0]);
+
+    s.close();
+    assertEquals(1, calledCount[0]);
+
+    // terminate stream after closing, confirm that handler is called, and terminating fails
+    s = Stream.of("a", "b", "c");
+    calledCount[0] = 0;
+    s = s.onClose(() -> calledCount[0]++);
+
+    s.close();
+    assertEquals(1, calledCount[0]);
+
+    try {
+      s.count();
+      fail("Expected IllegalStateException");
+    } catch (IllegalStateException expected) {
+      // expected
+    }
+    assertEquals(1, calledCount[0]);
+  }
+
+  public void testCloseException() {
+    // Try a single exception, confirm we catch it
+    Stream<Object> s = Stream.of(1, 2, 3);
+
+    RuntimeException a = new RuntimeException("a");
+    s.onClose(() -> {
+      throw a;
+    });
+    try {
+      s.close();
+      fail("RuntimeException expected");
+    } catch (RuntimeException expected) {
+      assertSame(a, expected);
+      assertEquals(0, expected.getSuppressed().length);
+    }
+
+    // Throw an exception in two of the three handlers, confirm both arrive and the third was called
+    // correctly
+    s = Stream.of(1, 2, 3);
+
+    RuntimeException a2 = new RuntimeException("a");
+    IllegalStateException b = new IllegalStateException("b");
+    int[] calledCount = {0};
+    s
+        .onClose(() -> {
+          throw a2;
+        })
+        .onClose(() -> {
+          throw b;
+        })
+        .onClose(() -> calledCount[0]++);
+
+    try {
+      s.close();
+      fail("RuntimeException expected");
+    } catch (RuntimeException expected) {
+      assertSame(a2, expected);
+      assertEquals(1, expected.getSuppressed().length);
+      Throwable firstSuppressed = expected.getSuppressed()[0];
+      assertSame(b, firstSuppressed);
+    }
+    assertEquals(1, calledCount[0]);
+
+    // Throw the same exception instance twice, ensure it only arrives once
+    s = Stream.of(1, 2, 3);
+
+    RuntimeException t = new RuntimeException("a");
+    s
+        .onClose(() -> {
+          throw t;
+        })
+        .onClose(() -> {
+          throw t;
+        });
+
+    try {
+      s.close();
+      fail("RuntimeException expected");
+    } catch (RuntimeException expected) {
+      assertSame(t, expected);
+      assertEquals(0, expected.getSuppressed().length);
+    }
+  }
+}
\ No newline at end of file