diff --git a/RELEASE_NOTE_DRAFT.md b/RELEASE_NOTE_DRAFT.md index bd913350f8..7a92703824 100644 --- a/RELEASE_NOTE_DRAFT.md +++ b/RELEASE_NOTE_DRAFT.md @@ -1,4 +1,4 @@ -8.1.0 (July 2016) +8.1.0 (TBD 2017) ==================== This is the 8.1.0 minor release. @@ -6,17 +6,26 @@ This is the 8.1.0 minor release. New Functionality ----------------- -* Placeholder. +* Implement BigDecimalSummaryStatistics and BigIntegerSummaryStatistics. +* Implement SummaryStatistics and Collectors2.summarizing. +* Integrate JaCoCo for test coverage. +* Implement flatCollect on Collectors2. +* Modify PersonAndPetKataTest.getAgeStatisticsOfPets to use summaryStatistics. +* Update reference guide. +* Add Abstract primitive Stacks. +* Add the Eclipse Collections reference guide. Optimizations ------------- -* Placeholder. +* Change collect and collectWith with target collections on InternalArrayIterate to use ensureCapacity for FastLists and ArrayLists. Bug fixes --------- -* Placeholder. +* Remove JMH tests and generator codes from Javadoc output. +* Update links to point to the Eclipse Collections Kata instead of the GS Collections Kata. +* Fix addAll() method in CompositeFastList to return false on isEmpty(). Acquiring Eclipse Collections ----------------------------- diff --git a/eclipse-collections/src/main/java/org/eclipse/collections/impl/collector/BigDecimalSummaryStatistics.java b/eclipse-collections/src/main/java/org/eclipse/collections/impl/collector/BigDecimalSummaryStatistics.java new file mode 100644 index 0000000000..edf370500f --- /dev/null +++ b/eclipse-collections/src/main/java/org/eclipse/collections/impl/collector/BigDecimalSummaryStatistics.java @@ -0,0 +1,99 @@ +/* + * Copyright (c) 2016 Goldman Sachs. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * and Eclipse Distribution License v. 1.0 which accompany this distribution. + * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html + * and the Eclipse Distribution License is available at + * http://www.eclipse.org/org/documents/edl-v10.php. + */ + +package org.eclipse.collections.impl.collector; + +import java.math.BigDecimal; +import java.math.MathContext; +import java.util.Optional; + +import org.eclipse.collections.api.block.function.Function; +import org.eclipse.collections.api.block.procedure.Procedure; + +/** + * BigDecimalSummaryStatistics can be used to keep a rolling count, sum, min, max and average of BigDecimal values. + * + * @see Collectors2#summarizingBigDecimal(Function) + */ +public class BigDecimalSummaryStatistics implements Procedure +{ + private static final long serialVersionUID = 1L; + private long count; + private BigDecimal sum = BigDecimal.ZERO; + private BigDecimal min; + private BigDecimal max; + + @Override + public void value(BigDecimal each) + { + this.count++; + if (each != null) + { + this.sum = this.sum.add(each); + this.min = this.min == null ? each : this.min.min(each); + this.max = this.max == null ? each : this.max.max(each); + } + } + + public long getCount() + { + return this.count; + } + + public BigDecimal getSum() + { + return this.sum; + } + + public BigDecimal getMin() + { + return this.min; + } + + public Optional getMinOptional() + { + return Optional.ofNullable(this.min); + } + + public BigDecimal getMax() + { + return this.max; + } + + public Optional getMaxOptional() + { + return Optional.ofNullable(this.max); + } + + public BigDecimal getAverage(MathContext context) + { + return this.count == 0 ? BigDecimal.ZERO : this.getSum().divide(BigDecimal.valueOf(this.count), context); + } + + public BigDecimal getAverage() + { + return this.getAverage(MathContext.DECIMAL128); + } + + public BigDecimalSummaryStatistics merge(BigDecimalSummaryStatistics summaryStatistics) + { + this.count += summaryStatistics.count; + this.sum = this.sum.add(summaryStatistics.sum); + if (summaryStatistics.min != null) + { + this.min = this.min == null ? summaryStatistics.min : this.min.min(summaryStatistics.min); + } + if (summaryStatistics.max != null) + { + this.max = this.max == null ? summaryStatistics.max : this.max.max(summaryStatistics.max); + } + return this; + } +} diff --git a/eclipse-collections/src/main/java/org/eclipse/collections/impl/collector/BigIntegerSummaryStatistics.java b/eclipse-collections/src/main/java/org/eclipse/collections/impl/collector/BigIntegerSummaryStatistics.java new file mode 100644 index 0000000000..88d31c515f --- /dev/null +++ b/eclipse-collections/src/main/java/org/eclipse/collections/impl/collector/BigIntegerSummaryStatistics.java @@ -0,0 +1,100 @@ +/* + * Copyright (c) 2016 Goldman Sachs. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * and Eclipse Distribution License v. 1.0 which accompany this distribution. + * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html + * and the Eclipse Distribution License is available at + * http://www.eclipse.org/org/documents/edl-v10.php. + */ + +package org.eclipse.collections.impl.collector; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.math.MathContext; +import java.util.Optional; + +import org.eclipse.collections.api.block.function.Function; +import org.eclipse.collections.api.block.procedure.Procedure; + +/** + * BigIntegerSummaryStatistics can be used to keep a rolling count, sum, min, max and average of BigInteger values. + * + * @see Collectors2#summarizingBigInteger(Function) + */ +public class BigIntegerSummaryStatistics implements Procedure +{ + private static final long serialVersionUID = 1L; + private long count; + private BigInteger sum = BigInteger.ZERO; + private BigInteger min; + private BigInteger max; + + @Override + public void value(BigInteger each) + { + this.count++; + if (each != null) + { + this.sum = this.sum.add(each); + this.min = this.min == null ? each : this.min.min(each); + this.max = this.max == null ? each : this.max.max(each); + } + } + + public long getCount() + { + return this.count; + } + + public BigInteger getSum() + { + return this.sum; + } + + public BigInteger getMin() + { + return this.min; + } + + public Optional getMinOptional() + { + return Optional.ofNullable(this.min); + } + + public BigInteger getMax() + { + return this.max; + } + + public Optional getMaxOptional() + { + return Optional.ofNullable(this.max); + } + + public BigDecimal getAverage(MathContext context) + { + return this.count == 0L ? BigDecimal.ZERO : new BigDecimal(this.getSum()).divide(BigDecimal.valueOf(this.count), context); + } + + public BigDecimal getAverage() + { + return this.getAverage(MathContext.DECIMAL128); + } + + public BigIntegerSummaryStatistics merge(BigIntegerSummaryStatistics summaryStatistics) + { + this.count += summaryStatistics.count; + this.sum = this.sum.add(summaryStatistics.sum); + if (summaryStatistics.min != null) + { + this.min = this.min == null ? summaryStatistics.min : this.min.min(summaryStatistics.min); + } + if (summaryStatistics.max != null) + { + this.max = this.max == null ? summaryStatistics.max : this.max.max(summaryStatistics.max); + } + return this; + } +} diff --git a/eclipse-collections/src/main/java/org/eclipse/collections/impl/collector/Collectors2.java b/eclipse-collections/src/main/java/org/eclipse/collections/impl/collector/Collectors2.java index eb32c1212e..4761d7f40d 100644 --- a/eclipse-collections/src/main/java/org/eclipse/collections/impl/collector/Collectors2.java +++ b/eclipse-collections/src/main/java/org/eclipse/collections/impl/collector/Collectors2.java @@ -10,11 +10,11 @@ package org.eclipse.collections.impl.collector; +import java.math.BigDecimal; +import java.math.BigInteger; import java.util.Collection; import java.util.Comparator; import java.util.Iterator; -import java.util.List; -import java.util.Map; import java.util.StringJoiner; import java.util.concurrent.atomic.AtomicInteger; import java.util.function.BinaryOperator; @@ -90,7 +90,6 @@ import org.eclipse.collections.impl.tuple.Tuples; import org.eclipse.collections.impl.tuple.primitive.PrimitiveTuples; import org.eclipse.collections.impl.utility.Iterate; -import org.eclipse.collections.impl.utility.ListIterate; /** *

A set of Collectors for Eclipse Collections types and algorithms.

@@ -1687,6 +1686,30 @@ private Collectors2() return summaryStatistics.toCollector(); } + /** + * Returns a BigDecimalSummaryStatistics applying the specified function to each element of the stream or collection. + */ + public static Collector summarizingBigDecimal(Function function) + { + return Collector.of( + BigDecimalSummaryStatistics::new, + (stats, each) -> stats.value(function.apply(each)), + BigDecimalSummaryStatistics::merge, + Collector.Characteristics.UNORDERED); + } + + /** + * Returns a BigIntegerSummaryStatistics applying the specified function to each element of the stream or collection. + */ + public static Collector summarizingBigInteger(Function function) + { + return Collector.of( + BigIntegerSummaryStatistics::new, + (stats, each) -> stats.value(function.apply(each)), + BigIntegerSummaryStatistics::merge, + Collector.Characteristics.UNORDERED); + } + private static > BinaryOperator mergeCollections() { return (collection1, collection2) -> diff --git a/unit-tests/src/test/java/org/eclipse/collections/impl/collector/BigDecimalSummaryStatisticsTest.java b/unit-tests/src/test/java/org/eclipse/collections/impl/collector/BigDecimalSummaryStatisticsTest.java new file mode 100644 index 0000000000..96b061df6c --- /dev/null +++ b/unit-tests/src/test/java/org/eclipse/collections/impl/collector/BigDecimalSummaryStatisticsTest.java @@ -0,0 +1,141 @@ +/* + * Copyright (c) 2016 Goldman Sachs. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * and Eclipse Distribution License v. 1.0 which accompany this distribution. + * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html + * and the Eclipse Distribution License is available at + * http://www.eclipse.org/org/documents/edl-v10.php. + */ + +package org.eclipse.collections.impl.collector; + +import java.math.BigDecimal; +import java.util.List; + +import org.eclipse.collections.api.list.MutableList; +import org.eclipse.collections.impl.factory.primitive.IntLists; +import org.eclipse.collections.impl.list.Interval; +import org.junit.Assert; +import org.junit.Test; + +public class BigDecimalSummaryStatisticsTest +{ + @Test + public void jdkForEach() + { + BigDecimalSummaryStatistics statistics = new BigDecimalSummaryStatistics(); + List integers = Interval.oneTo(5).collect(i -> BigDecimal.valueOf((long) i)).toList(); + integers.forEach(statistics); + Assert.assertEquals(BigDecimal.valueOf(15L), statistics.getSum()); + Assert.assertEquals(5L, statistics.getCount()); + Assert.assertEquals(BigDecimal.valueOf(1L), statistics.getMin()); + Assert.assertEquals(BigDecimal.valueOf(1L), statistics.getMinOptional().get()); + Assert.assertEquals(BigDecimal.valueOf(5L), statistics.getMax()); + Assert.assertEquals(BigDecimal.valueOf(5L), statistics.getMaxOptional().get()); + Assert.assertEquals(BigDecimal.valueOf(3L), statistics.getAverage()); + } + + @Test + public void each() + { + BigDecimalSummaryStatistics statistics = new BigDecimalSummaryStatistics(); + MutableList integers = Interval.oneTo(5).collect(i -> BigDecimal.valueOf((long) i)).toList(); + integers.each(statistics); + Assert.assertEquals(BigDecimal.valueOf(15L), statistics.getSum()); + Assert.assertEquals(5L, statistics.getCount()); + Assert.assertEquals(BigDecimal.valueOf(1L), statistics.getMin()); + Assert.assertEquals(BigDecimal.valueOf(1L), statistics.getMinOptional().get()); + Assert.assertEquals(BigDecimal.valueOf(5L), statistics.getMax()); + Assert.assertEquals(BigDecimal.valueOf(5L), statistics.getMaxOptional().get()); + Assert.assertEquals(BigDecimal.valueOf(3L), statistics.getAverage()); + } + + @Test + public void merge() + { + BigDecimalSummaryStatistics statistics1 = new BigDecimalSummaryStatistics(); + MutableList integers1 = Interval.oneTo(2).collect(i -> BigDecimal.valueOf((long) i)).toList(); + integers1.each(statistics1); + BigDecimalSummaryStatistics statistics2 = new BigDecimalSummaryStatistics(); + MutableList integers2 = Interval.fromTo(3, 5).collect(i -> BigDecimal.valueOf((long) i)).toList(); + integers2.each(statistics2); + Assert.assertSame(statistics1, statistics1.merge(statistics2)); + Assert.assertEquals(BigDecimal.valueOf(15L), statistics1.getSum()); + Assert.assertEquals(5L, statistics1.getCount()); + Assert.assertEquals(BigDecimal.valueOf(1L), statistics1.getMin()); + Assert.assertEquals(BigDecimal.valueOf(1L), statistics1.getMinOptional().get()); + Assert.assertEquals(BigDecimal.valueOf(5L), statistics1.getMax()); + Assert.assertEquals(BigDecimal.valueOf(5L), statistics1.getMaxOptional().get()); + Assert.assertEquals(BigDecimal.valueOf(3L), statistics1.getAverage()); + } + + @Test + public void empty() + { + BigDecimalSummaryStatistics statistics = new BigDecimalSummaryStatistics(); + Assert.assertEquals(0L, statistics.getCount()); + Assert.assertEquals(BigDecimal.ZERO, statistics.getSum()); + Assert.assertEquals(BigDecimal.ZERO, statistics.getAverage()); + Assert.assertNull(statistics.getMin()); + Assert.assertNull(statistics.getMax()); + } + + @Test + public void summarizingBigDecimal() + { + BigDecimalSummaryStatistics statistics = + Interval.oneTo(5).stream().collect(Collectors2.summarizingBigDecimal(BigDecimal::new)); + Assert.assertEquals(BigDecimal.valueOf(15L), statistics.getSum()); + Assert.assertEquals(5L, statistics.getCount()); + Assert.assertEquals(BigDecimal.valueOf(1L), statistics.getMin()); + Assert.assertEquals(BigDecimal.valueOf(1L), statistics.getMinOptional().get()); + Assert.assertEquals(BigDecimal.valueOf(5L), statistics.getMax()); + Assert.assertEquals(BigDecimal.valueOf(5L), statistics.getMaxOptional().get()); + Assert.assertEquals(BigDecimal.valueOf(3L), statistics.getAverage()); + } + + @Test + public void average() + { + Assert.assertEquals( + new BigDecimal("3.333333333333333333333333333333333"), + IntLists.mutable.with(2, 2, 6) + .collect(Long::valueOf) + .stream() + .collect(Collectors2.summarizingBigDecimal(BigDecimal::valueOf)) + .getAverage()); + + Assert.assertEquals( + new BigDecimal("3.666666666666666666666666666666667"), + IntLists.mutable.with(2, 3, 6) + .collect(Long::valueOf) + .stream() + .collect(Collectors2.summarizingBigDecimal(BigDecimal::valueOf)) + .getAverage()); + + Assert.assertEquals( + new BigDecimal("1"), + IntLists.mutable.with(1, 1, 1) + .collect(Long::valueOf) + .stream() + .collect(Collectors2.summarizingBigDecimal(BigDecimal::valueOf)) + .getAverage()); + + Assert.assertEquals( + new BigDecimal("4"), + IntLists.mutable.with(2, 3, 4, 5, 6) + .collect(Long::valueOf) + .stream() + .collect(Collectors2.summarizingBigDecimal(BigDecimal::valueOf)) + .getAverage()); + + Assert.assertEquals( + new BigDecimal("3.8"), + IntLists.mutable.with(2, 3, 4, 5, 5) + .collect(Long::valueOf) + .stream() + .collect(Collectors2.summarizingBigDecimal(BigDecimal::valueOf)) + .getAverage()); + } +} diff --git a/unit-tests/src/test/java/org/eclipse/collections/impl/collector/BigIntegerSummaryStatisticsTest.java b/unit-tests/src/test/java/org/eclipse/collections/impl/collector/BigIntegerSummaryStatisticsTest.java new file mode 100644 index 0000000000..d4454ca129 --- /dev/null +++ b/unit-tests/src/test/java/org/eclipse/collections/impl/collector/BigIntegerSummaryStatisticsTest.java @@ -0,0 +1,146 @@ +/* + * Copyright (c) 2016 Goldman Sachs. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * and Eclipse Distribution License v. 1.0 which accompany this distribution. + * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html + * and the Eclipse Distribution License is available at + * http://www.eclipse.org/org/documents/edl-v10.php. + */ + +package org.eclipse.collections.impl.collector; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.List; + +import org.eclipse.collections.api.list.MutableList; +import org.eclipse.collections.impl.factory.primitive.IntLists; +import org.eclipse.collections.impl.list.Interval; +import org.junit.Assert; +import org.junit.Test; + +public class BigIntegerSummaryStatisticsTest +{ + @Test + public void jdkForEach() + { + BigIntegerSummaryStatistics statistics = new BigIntegerSummaryStatistics(); + List integers = Interval.oneTo(5).collect(i -> BigInteger.valueOf((long) i)).toList(); + integers.forEach(statistics); + Assert.assertEquals(BigInteger.valueOf(15L), statistics.getSum()); + Assert.assertEquals(5L, statistics.getCount()); + Assert.assertEquals(BigInteger.valueOf(1L), statistics.getMin()); + Assert.assertEquals(BigInteger.valueOf(1L), statistics.getMinOptional().get()); + Assert.assertEquals(BigInteger.valueOf(5L), statistics.getMax()); + Assert.assertEquals(BigInteger.valueOf(5L), statistics.getMaxOptional().get()); + Assert.assertEquals(BigDecimal.valueOf(3L), statistics.getAverage()); + } + + @Test + public void each() + { + BigIntegerSummaryStatistics statistics = new BigIntegerSummaryStatistics(); + MutableList integers = Interval.oneTo(5).collect(i -> BigInteger.valueOf((long) i)).toList(); + integers.each(statistics); + Assert.assertEquals(BigInteger.valueOf(15L), statistics.getSum()); + Assert.assertEquals(5L, statistics.getCount()); + Assert.assertEquals(BigInteger.valueOf(1L), statistics.getMin()); + Assert.assertEquals(BigInteger.valueOf(1L), statistics.getMinOptional().get()); + Assert.assertEquals(BigInteger.valueOf(5L), statistics.getMax()); + Assert.assertEquals(BigInteger.valueOf(5L), statistics.getMaxOptional().get()); + Assert.assertEquals(BigDecimal.valueOf(3L), statistics.getAverage()); + } + + @Test + public void merge() + { + BigIntegerSummaryStatistics statistics1 = new BigIntegerSummaryStatistics(); + MutableList integers1 = Interval.oneTo(2).collect(i -> BigInteger.valueOf((long) i)).toList(); + integers1.each(statistics1); + BigIntegerSummaryStatistics statistics2 = new BigIntegerSummaryStatistics(); + MutableList integers2 = Interval.fromTo(3, 5).collect(i -> BigInteger.valueOf((long) i)).toList(); + integers2.each(statistics2); + Assert.assertSame(statistics1, statistics1.merge(statistics2)); + Assert.assertEquals(BigInteger.valueOf(15L), statistics1.getSum()); + Assert.assertEquals(5L, statistics1.getCount()); + Assert.assertEquals(BigInteger.valueOf(1L), statistics1.getMin()); + Assert.assertEquals(BigInteger.valueOf(1L), statistics1.getMinOptional().get()); + Assert.assertEquals(BigInteger.valueOf(5L), statistics1.getMax()); + Assert.assertEquals(BigInteger.valueOf(5L), statistics1.getMaxOptional().get()); + Assert.assertEquals(BigDecimal.valueOf(3L), statistics1.getAverage()); + } + + @Test + public void empty() + { + BigIntegerSummaryStatistics statistics = new BigIntegerSummaryStatistics(); + Assert.assertEquals(0L, statistics.getCount()); + Assert.assertEquals(BigInteger.ZERO, statistics.getSum()); + Assert.assertEquals(BigDecimal.ZERO, statistics.getAverage()); + Assert.assertNull(statistics.getMin()); + Assert.assertNull(statistics.getMax()); + } + + @Test + public void summarizingBigInteger() + { + BigIntegerSummaryStatistics statistics = + Interval.oneTo(5) + .collect(Long::valueOf) + .toList() + .stream() + .collect(Collectors2.summarizingBigInteger(BigInteger::valueOf)); + Assert.assertEquals(BigInteger.valueOf(15L), statistics.getSum()); + Assert.assertEquals(5L, statistics.getCount()); + Assert.assertEquals(BigInteger.valueOf(1L), statistics.getMin()); + Assert.assertEquals(BigInteger.valueOf(1L), statistics.getMinOptional().get()); + Assert.assertEquals(BigInteger.valueOf(5L), statistics.getMax()); + Assert.assertEquals(BigInteger.valueOf(5L), statistics.getMaxOptional().get()); + Assert.assertEquals(BigDecimal.valueOf(3L), statistics.getAverage()); + } + + @Test + public void average() + { + Assert.assertEquals( + new BigDecimal("3.333333333333333333333333333333333"), + IntLists.mutable.with(2, 2, 6) + .collect(Long::valueOf) + .stream() + .collect(Collectors2.summarizingBigInteger(BigInteger::valueOf)) + .getAverage()); + + Assert.assertEquals( + new BigDecimal("3.666666666666666666666666666666667"), + IntLists.mutable.with(2, 3, 6) + .collect(Long::valueOf) + .stream() + .collect(Collectors2.summarizingBigInteger(BigInteger::valueOf)) + .getAverage()); + + Assert.assertEquals( + new BigDecimal("1"), + IntLists.mutable.with(1, 1, 1) + .collect(Long::valueOf) + .stream() + .collect(Collectors2.summarizingBigInteger(BigInteger::valueOf)) + .getAverage()); + + Assert.assertEquals( + new BigDecimal("4"), + IntLists.mutable.with(2, 3, 4, 5, 6) + .collect(Long::valueOf) + .stream() + .collect(Collectors2.summarizingBigInteger(BigInteger::valueOf)) + .getAverage()); + + Assert.assertEquals( + new BigDecimal("3.8"), + IntLists.mutable.with(2, 3, 4, 5, 5) + .collect(Long::valueOf) + .stream() + .collect(Collectors2.summarizingBigInteger(BigInteger::valueOf)) + .getAverage()); + } +} diff --git a/unit-tests/src/test/java/org/eclipse/collections/impl/collector/Collectors2AdditionalTest.java b/unit-tests/src/test/java/org/eclipse/collections/impl/collector/Collectors2AdditionalTest.java index 725bd3d8a9..6cd5dc10b0 100644 --- a/unit-tests/src/test/java/org/eclipse/collections/impl/collector/Collectors2AdditionalTest.java +++ b/unit-tests/src/test/java/org/eclipse/collections/impl/collector/Collectors2AdditionalTest.java @@ -10,6 +10,8 @@ package org.eclipse.collections.impl.collector; +import java.math.BigDecimal; +import java.math.BigInteger; import java.util.ArrayList; import java.util.Arrays; import java.util.List; @@ -764,7 +766,7 @@ public void summarizeDownstream() } @Test - public void collectStatsParallel() + public void summarizingParallel() { ValueHolder valueHolder = new ValueHolder(5, 100, 10.0); SummaryStatistics summaryStatistics = @@ -778,4 +780,30 @@ public void collectStatsParallel() Assert.assertEquals(2_500_000L, summaryStatistics.getLongStats(Integer.valueOf(0)).getSum()); Assert.assertEquals(250000.0d, summaryStatistics.getDoubleStats(Integer.valueOf(0)).getSum(), 0.0); } + + @Test + public void summarizingBigDecimalParallel() + { + ValueHolder valueHolder = new ValueHolder(5, 100, 10.0); + BigDecimalSummaryStatistics summaryStatistics = + Lists.mutable.withNValues(25_000, () -> valueHolder) + .parallelStream() + .collect(Collectors2.summarizingBigDecimal(vh -> BigDecimal.valueOf(vh.getLongValue()))); + Assert.assertEquals(BigDecimal.valueOf(2_500_000L), summaryStatistics.getSum()); + Assert.assertEquals(BigDecimal.valueOf(100L), summaryStatistics.getMin()); + Assert.assertEquals(BigDecimal.valueOf(100L), summaryStatistics.getMax()); + } + + @Test + public void summarizingBigIntegerParallel() + { + ValueHolder valueHolder = new ValueHolder(5, 100, 10.0); + BigIntegerSummaryStatistics summaryStatistics = + Lists.mutable.withNValues(25_000, () -> valueHolder) + .parallelStream() + .collect(Collectors2.summarizingBigInteger(vh -> BigInteger.valueOf(vh.getLongValue()))); + Assert.assertEquals(BigInteger.valueOf(2_500_000L), summaryStatistics.getSum()); + Assert.assertEquals(BigInteger.valueOf(100L), summaryStatistics.getMin()); + Assert.assertEquals(BigInteger.valueOf(100L), summaryStatistics.getMax()); + } }