diff --git a/user/super/com/google/gwt/emul/java/util/DoubleSummaryStatistics.java b/user/super/com/google/gwt/emul/java/util/DoubleSummaryStatistics.java
new file mode 100644
index 0000000..5163cdc
--- /dev/null
+++ b/user/super/com/google/gwt/emul/java/util/DoubleSummaryStatistics.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright 2015 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;
+
+import java.util.function.DoubleConsumer;
+
+/**
+ * See <a
+ * href="https://docs.oracle.com/javase/8/docs/api/java/util/DoubleSummaryStatistics.html">the
+ * official Java API doc</a> for details.
+ */
+public class DoubleSummaryStatistics implements DoubleConsumer {
+
+  private long count;
+  private double min = Double.POSITIVE_INFINITY;
+  private double max = Double.NEGATIVE_INFINITY;
+  private double sum;
+  private double sumError;
+  // Because of Kahan summation compensation a naive summation is required
+  // to keep track of infinity values correctly.
+  private double naiveSum;
+
+  @Override
+  public void accept(double value) {
+    count++;
+    min = Math.min(min, value);
+    max = Math.max(max, value);
+    naiveSum += value;
+    sum(value);
+  }
+
+  public void combine(DoubleSummaryStatistics other) {
+    count += other.count;
+    min = Math.min(min, other.min);
+    max = Math.max(max, other.max);
+    naiveSum += other.naiveSum;
+    sum(other.sum);
+    sum(other.sumError);
+  }
+
+  public double getAverage() {
+    return count > 0 ? getSum() / count : 0d;
+  }
+
+  public long getCount() {
+    return count;
+  }
+
+  public double getMin() {
+    return min;
+  }
+
+  public double getMax() {
+    return max;
+  }
+
+  public double getSum() {
+    // Adding sum and sumError here to get a better result
+    // because Kahan summation always applies error compensation
+    // on the next summation.
+    double compensatedSum = sum + sumError;
+    // sumError can be NaN if infinity values had been accepted.
+    if (Double.isNaN(compensatedSum) && Double.isInfinite(naiveSum)) {
+      return naiveSum;
+    }
+    return compensatedSum;
+  }
+
+  @Override
+  public String toString() {
+    return "DoubleSummaryStatistics[" +
+        "count = " + count +
+        ", avg = " + getAverage() +
+        ", min = " + min +
+        ", max = " + max +
+        ", sum = " + getSum() +
+        "]";
+  }
+
+  /**
+   * Adds a new value to the current sum using Kahan summation
+   * algorithm for improved summation precision.
+   *
+   * https://en.wikipedia.org/wiki/Kahan_summation_algorithm
+   *
+   * @param value the value being added to the sum
+   */
+  private void sum(double value) {
+    double compensatedValue = value - sumError;
+    double newSum = sum + compensatedValue;
+    // Logically 'summationError' always evaluates to 0
+    // but in reality it contains a small summation error
+    // that can occur because of rounding in floating point arithmetic.
+    // For example 1.0 + EPSILON with EPSILON being half machine precision
+    // (basically Math.ulp(1.0)/2) will result in 1.0.
+    // Tests should verify that GWT compiler / Closure compiler do not
+    // remove this line during optimizations.
+    // NOTE: sumError can become NaN for infinity values.
+    sumError = (newSum - sum) - compensatedValue;
+    sum = newSum;
+  }
+}
diff --git a/user/super/com/google/gwt/emul/java/util/IntSummaryStatistics.java b/user/super/com/google/gwt/emul/java/util/IntSummaryStatistics.java
new file mode 100644
index 0000000..ca78c82
--- /dev/null
+++ b/user/super/com/google/gwt/emul/java/util/IntSummaryStatistics.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2015 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;
+
+import java.util.function.IntConsumer;
+
+/**
+ * See <a
+ * href="https://docs.oracle.com/javase/8/docs/api/java/util/IntSummaryStatistics.html">the
+ * official Java API doc</a> for details.
+ */
+public class IntSummaryStatistics implements IntConsumer {
+
+  private long count;
+  private int min = Integer.MAX_VALUE;
+  private int max = Integer.MIN_VALUE;
+  private long sum;
+
+  @Override
+  public void accept(int value) {
+    count++;
+    min = Math.min(min, value);
+    max = Math.max(max, value);
+    sum += value;
+  }
+
+  public void combine(IntSummaryStatistics other) {
+    count += other.count;
+    min = Math.min(min, other.min);
+    max = Math.max(max, other.max);
+    sum += other.sum;
+  }
+
+  public double getAverage() {
+    return count > 0 ? (double) sum / count : 0d;
+  }
+
+  public long getCount() {
+    return count;
+  }
+
+  public int getMin() {
+    return min;
+  }
+
+  public int getMax() {
+    return max;
+  }
+
+  public long getSum() {
+    return sum;
+  }
+
+  @Override
+  public String toString() {
+    return "IntSummaryStatistics[" +
+        "count = " + count +
+        ", avg = " + getAverage() +
+        ", min = " + min +
+        ", max = " + max +
+        ", sum = " + sum +
+        "]";
+  }
+}
diff --git a/user/super/com/google/gwt/emul/java/util/LongSummaryStatistics.java b/user/super/com/google/gwt/emul/java/util/LongSummaryStatistics.java
new file mode 100644
index 0000000..0794c90
--- /dev/null
+++ b/user/super/com/google/gwt/emul/java/util/LongSummaryStatistics.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2015 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;
+
+import java.util.function.IntConsumer;
+import java.util.function.LongConsumer;
+
+/**
+ * See <a
+ * href="https://docs.oracle.com/javase/8/docs/api/java/util/LongSummaryStatistics.html">the
+ * official Java API doc</a> for details.
+ */
+public class LongSummaryStatistics implements LongConsumer, IntConsumer {
+
+  private long count;
+  private long min = Long.MAX_VALUE;
+  private long max = Long.MIN_VALUE;
+  private long sum;
+
+  @Override
+  public void accept(int value) {
+    accept((long) value);
+  }
+
+  @Override
+  public void accept(long value) {
+    count++;
+    min = Math.min(min, value);
+    max = Math.max(max, value);
+    sum += value;
+  }
+
+  public void combine(LongSummaryStatistics other) {
+    count += other.count;
+    min = Math.min(min, other.min);
+    max = Math.max(max, other.max);
+    sum += other.sum;
+  }
+
+  public double getAverage() {
+    return count > 0 ? (double) sum / count : 0d;
+  }
+
+  public long getCount() {
+    return count;
+  }
+
+  public long getMin() {
+    return min;
+  }
+
+  public long getMax() {
+    return max;
+  }
+
+  public long getSum() {
+    return sum;
+  }
+
+  @Override
+  public String toString() {
+    return "LongSummaryStatistics[" +
+        "count = " + count +
+        ", avg = " + getAverage() +
+        ", min = " + min +
+        ", max = " + max +
+        ", sum = " + sum +
+        "]";
+  }
+}
diff --git a/user/test/com/google/gwt/emultest/EmulJava8Suite.java b/user/test/com/google/gwt/emultest/EmulJava8Suite.java
index d713785..09394ae 100644
--- a/user/test/com/google/gwt/emultest/EmulJava8Suite.java
+++ b/user/test/com/google/gwt/emultest/EmulJava8Suite.java
@@ -15,6 +15,9 @@
  */
 package com.google.gwt.emultest;
 
+import com.google.gwt.emultest.java8.util.DoubleSummaryStatisticsTest;
+import com.google.gwt.emultest.java8.util.IntSummaryStatisticsTest;
+import com.google.gwt.emultest.java8.util.LongSummaryStatisticsTest;
 import com.google.gwt.emultest.java8.util.OptionalDoubleTest;
 import com.google.gwt.emultest.java8.util.OptionalIntTest;
 import com.google.gwt.emultest.java8.util.OptionalLongTest;
@@ -40,7 +43,9 @@
     suite.addTestSuite(OptionalDoubleTest.class);
     suite.addTestSuite(PrimitiveIteratorTest.class);
     suite.addTestSuite(StringJoinerTest.class);
-
+    suite.addTestSuite(DoubleSummaryStatisticsTest.class);
+    suite.addTestSuite(IntSummaryStatisticsTest.class);
+    suite.addTestSuite(LongSummaryStatisticsTest.class);
     return suite;
   }
 }
diff --git a/user/test/com/google/gwt/emultest/java8/util/DoubleSummaryStatisticsTest.java b/user/test/com/google/gwt/emultest/java8/util/DoubleSummaryStatisticsTest.java
new file mode 100644
index 0000000..bb4b3b0
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java8/util/DoubleSummaryStatisticsTest.java
@@ -0,0 +1,166 @@
+/*
+ * 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;
+
+import com.google.gwt.emultest.java.util.EmulTestBase;
+
+import static java.lang.Double.MAX_VALUE;
+import static java.lang.Double.MIN_VALUE;
+import static java.lang.Double.NEGATIVE_INFINITY;
+import static java.lang.Double.NaN;
+import static java.lang.Double.POSITIVE_INFINITY;
+
+import java.util.Arrays;
+import java.util.DoubleSummaryStatistics;
+import java.util.List;
+
+/**
+ * Tests {@link DoubleSummaryStatistics}.
+ */
+public class DoubleSummaryStatisticsTest extends EmulTestBase {
+
+  private DoubleSummaryStatistics stats;
+
+  @Override
+  protected void gwtSetUp() throws Exception {
+    stats = new DoubleSummaryStatistics();
+  }
+
+  public void testAverageAndSumWithCompensation() throws Exception {
+    assertEquals(0d, stats.getAverage());
+    assertEquals(0d, stats.getSum());
+
+    double initial = 1.0d;
+    long count = 1000000;
+
+    // 'precision' is the hardcoded result of Math.ulp(initial) in JVM,
+    // since GWT does not emulate Math.ulp().
+    // This value represents the distance from 'initial' (1.0d) to the
+    // previous/next double. If we add half or less of that distance/precision
+    // to 'initial' then the result will be truncated to 'initial' again due to
+    // floating point arithmetic rounding.
+    // With Kahan summation such rounding errors are detected and compensated
+    // so the summation result should (nearly) equal the expected sum.
+    double precision = 2.220446049250313E-16;
+    double value = precision / 2;
+    double expectedSum = initial + (count * value);
+    long expectedCount = count + 1;
+    double expectedAverage = expectedSum / expectedCount;
+
+    stats.accept(initial);
+    for (int i = 0; i < count; ++i) {
+      stats.accept(value);
+    }
+
+    // TODO (jnehlmeier): While delta = 0 works we probably want to allow some error?
+    // Or maybe use ulp differences instead of a delta?
+    assertEquals(expectedAverage, stats.getAverage(), 0);
+    assertEquals(expectedSum, stats.getSum(), 0);
+  }
+
+  public void testCombine() throws Exception {
+    stats.accept(1.0d);
+    stats.accept(2.0d);
+
+    DoubleSummaryStatistics otherStats = new DoubleSummaryStatistics();
+    otherStats.accept(3.0d);
+    otherStats.accept(4.0d);
+
+    stats.combine(otherStats);
+
+    assertEquals(2.5d, stats.getAverage());
+    assertEquals(1d, stats.getMin());
+    assertEquals(4d, stats.getMax());
+    assertEquals(10d, stats.getSum());
+    assertEquals(4, stats.getCount());
+  }
+
+  public void testCountMaxMin() {
+    assertEquals(0, stats.getCount());
+    assertEquals(NEGATIVE_INFINITY, stats.getMax());
+    assertEquals(POSITIVE_INFINITY, stats.getMin());
+
+    double[][] testData = {
+        //          aDouble,               max,               min
+        {               1.0,               1.0,               1.0 },
+        {              -1.0,               1.0,              -1.0 },
+        {               2.5,               2.5,              -1.0 },
+        {              -2.5,               2.5,              -2.5 },
+        {         MAX_VALUE,         MAX_VALUE,              -2.5 },
+        {         MIN_VALUE,         MAX_VALUE,              -2.5 },
+        { POSITIVE_INFINITY, POSITIVE_INFINITY,              -2.5 },
+        { NEGATIVE_INFINITY, POSITIVE_INFINITY, NEGATIVE_INFINITY },
+    };
+
+    for (int i = 0; i < testData.length; ++i) {
+      long expectedCount = i + 1;
+      double aDouble = testData[i][0];
+      double expectedMax = testData[i][1];
+      double expectedMin = testData[i][2];
+
+      stats.accept(aDouble);
+
+      assertEquals(expectedCount, stats.getCount());
+      assertEquals(expectedMax, stats.getMax());
+      assertEquals(expectedMin, stats.getMin());
+    }
+  }
+
+  public void testInfinity() {
+    stats.accept(NEGATIVE_INFINITY);
+    stats.accept(NEGATIVE_INFINITY);
+    assertEquals(NEGATIVE_INFINITY, stats.getAverage());
+    assertEquals(NEGATIVE_INFINITY, stats.getMax());
+    assertEquals(NEGATIVE_INFINITY, stats.getMin());
+    assertEquals(NEGATIVE_INFINITY, stats.getSum());
+
+    stats.accept(POSITIVE_INFINITY);
+    assertTrue(Double.isNaN(stats.getAverage()));
+    assertEquals(POSITIVE_INFINITY, stats.getMax());
+    assertEquals(NEGATIVE_INFINITY, stats.getMin());
+    assertTrue(Double.isNaN(stats.getSum()));
+
+    stats = new DoubleSummaryStatistics();
+    stats.accept(POSITIVE_INFINITY);
+    stats.accept(POSITIVE_INFINITY);
+    assertEquals(POSITIVE_INFINITY, stats.getAverage());
+    assertEquals(POSITIVE_INFINITY, stats.getMax());
+    assertEquals(POSITIVE_INFINITY, stats.getMin());
+    assertEquals(POSITIVE_INFINITY, stats.getSum());
+
+    stats.accept(NEGATIVE_INFINITY);
+    assertTrue(Double.isNaN(stats.getAverage()));
+    assertEquals(POSITIVE_INFINITY, stats.getMax());
+    assertEquals(NEGATIVE_INFINITY, stats.getMin());
+    assertTrue(Double.isNaN(stats.getSum()));
+  }
+
+  public void testNaN() {
+    List<Double> testData = Arrays.asList(
+        NaN, -1.5d, 2.5d, MAX_VALUE, MIN_VALUE, NaN,
+        NEGATIVE_INFINITY, POSITIVE_INFINITY);
+
+    stats.accept(5.0d);
+    for (Double aDouble : testData) {
+      stats.accept(aDouble);
+      assertTrue(Double.isNaN(stats.getAverage()));
+      assertTrue(Double.isNaN(stats.getMax()));
+      assertTrue(Double.isNaN(stats.getMin()));
+      assertTrue(Double.isNaN(stats.getSum()));
+    }
+  }
+}
\ No newline at end of file
diff --git a/user/test/com/google/gwt/emultest/java8/util/IntSummaryStatisticsTest.java b/user/test/com/google/gwt/emultest/java8/util/IntSummaryStatisticsTest.java
new file mode 100644
index 0000000..e1a49d2
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java8/util/IntSummaryStatisticsTest.java
@@ -0,0 +1,91 @@
+/*
+ * 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;
+
+import com.google.gwt.emultest.java.util.EmulTestBase;
+
+import static java.lang.Integer.MAX_VALUE;
+import static java.lang.Integer.MIN_VALUE;
+
+import java.util.IntSummaryStatistics;
+
+/**
+ * Tests {@link IntSummaryStatistics}.
+ */
+public class IntSummaryStatisticsTest extends EmulTestBase {
+
+  private IntSummaryStatistics stats;
+
+  @Override
+  protected void gwtSetUp() throws Exception {
+    stats = new IntSummaryStatistics();
+  }
+
+  public void testCombine() throws Exception {
+
+    stats.accept(1);
+    stats.accept(2);
+
+    IntSummaryStatistics otherStats = new IntSummaryStatistics();
+    otherStats.accept(3);
+    otherStats.accept(4);
+
+    stats.combine(otherStats);
+
+    assertEquals(2.5d, stats.getAverage());
+    assertEquals(1, stats.getMin());
+    assertEquals(4, stats.getMax());
+    assertEquals(10L, stats.getSum());
+    assertEquals(4L, stats.getCount());
+  }
+
+  public void testStats() {
+
+    assertEquals(0L, stats.getCount());
+    assertEquals(0d, stats.getAverage());
+    assertEquals(MIN_VALUE, stats.getMax());
+    assertEquals(MAX_VALUE, stats.getMin());
+    assertEquals(0L, stats.getSum());
+
+    int[][] testData = {
+        //    anInt,       max,       min,       sum
+        {         1,         1,         1,         1 },
+        {        -1,         1,        -1,         0 },
+        {         2,         2,        -1,         2 },
+        {        -2,         2,        -2,         0 },
+        { MAX_VALUE, MAX_VALUE,        -2, MAX_VALUE },
+        { MIN_VALUE, MAX_VALUE, MIN_VALUE,        -1 },
+    };
+
+    for (int i = 0; i < testData.length; ++i) {
+      long expectedCount = i + 1;
+      int anInt = testData[i][0];
+      int expectedMax = testData[i][1];
+      int expectedMin = testData[i][2];
+      long expectedSum = testData[i][3];
+      double expectedAverage = expectedSum / (double) expectedCount;
+
+      stats.accept(anInt);
+
+      assertEquals(expectedAverage, stats.getAverage());
+      assertEquals(expectedCount, stats.getCount());
+      assertEquals(expectedMax, stats.getMax());
+      assertEquals(expectedMin, stats.getMin());
+      assertEquals(expectedSum, stats.getSum());
+    }
+  }
+}
\ No newline at end of file
diff --git a/user/test/com/google/gwt/emultest/java8/util/LongSummaryStatisticsTest.java b/user/test/com/google/gwt/emultest/java8/util/LongSummaryStatisticsTest.java
new file mode 100644
index 0000000..518351c
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java8/util/LongSummaryStatisticsTest.java
@@ -0,0 +1,91 @@
+/*
+ * 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;
+
+import com.google.gwt.emultest.java.util.EmulTestBase;
+
+import static java.lang.Long.MAX_VALUE;
+import static java.lang.Long.MIN_VALUE;
+
+import java.util.LongSummaryStatistics;
+
+/**
+ * Tests {@link LongSummaryStatistics}.
+ */
+public class LongSummaryStatisticsTest extends EmulTestBase {
+
+  private LongSummaryStatistics stats;
+
+  @Override
+  protected void gwtSetUp() throws Exception {
+    stats = new LongSummaryStatistics();
+  }
+
+  public void testCombine() throws Exception {
+
+    stats.accept(1);
+    stats.accept(2);
+
+    LongSummaryStatistics otherStats = new LongSummaryStatistics();
+    otherStats.accept(3);
+    otherStats.accept(4);
+
+    stats.combine(otherStats);
+
+    assertEquals(2.5d, stats.getAverage());
+    assertEquals(1, stats.getMin());
+    assertEquals(4, stats.getMax());
+    assertEquals(10L, stats.getSum());
+    assertEquals(4L, stats.getCount());
+  }
+
+  public void testStats() {
+
+    assertEquals(0L, stats.getCount());
+    assertEquals(0d, stats.getAverage());
+    assertEquals(MIN_VALUE, stats.getMax());
+    assertEquals(MAX_VALUE, stats.getMin());
+    assertEquals(0L, stats.getSum());
+
+    long[][] testData = {
+        //    aLong,       max,       min,       sum
+        {         1,         1,         1,         1 },
+        {        -1,         1,        -1,         0 },
+        {         2,         2,        -1,         2 },
+        {        -2,         2,        -2,         0 },
+        { MAX_VALUE, MAX_VALUE,        -2, MAX_VALUE },
+        { MIN_VALUE, MAX_VALUE, MIN_VALUE,        -1 },
+    };
+
+    for (int i = 0; i < testData.length; ++i) {
+      long expectedCount = i + 1;
+      long aLong = testData[i][0];
+      long expectedMax = testData[i][1];
+      long expectedMin = testData[i][2];
+      long expectedSum = testData[i][3];
+      double expectedAverage = expectedSum / (double) expectedCount;
+
+      stats.accept(aLong);
+
+      assertEquals(expectedAverage, stats.getAverage());
+      assertEquals(expectedCount, stats.getCount());
+      assertEquals(expectedMax, stats.getMax());
+      assertEquals(expectedMin, stats.getMin());
+      assertEquals(expectedSum, stats.getSum());
+    }
+  }
+}
\ No newline at end of file