From 23378219744599078a98ce5c582919a935721fe4 Mon Sep 17 00:00:00 2001 From: Bihuniak Date: Sun, 4 Aug 2019 16:50:29 +0200 Subject: [PATCH 1/9] added support for java 8 --- .../com/google/mu/util/stream/BiStream.java | 61 ++++++++----------- .../BiStreamFunctionEvaluationTest.java | 32 +++++----- .../util/stream/BiStreamInvariantsTest.java | 60 +++++++++--------- .../google/mu/util/stream/BiStreamTest.java | 53 +++++++--------- 4 files changed, 91 insertions(+), 115 deletions(-) diff --git a/core/src/main/java/com/google/mu/util/stream/BiStream.java b/core/src/main/java/com/google/mu/util/stream/BiStream.java index 97613c637a..57d8d6fb92 100644 --- a/core/src/main/java/com/google/mu/util/stream/BiStream.java +++ b/core/src/main/java/com/google/mu/util/stream/BiStream.java @@ -14,46 +14,21 @@ *****************************************************************************/ package com.google.mu.util.stream; +import java.util.*; +import java.util.Spliterators.AbstractDoubleSpliterator; +import java.util.Spliterators.AbstractIntSpliterator; +import java.util.Spliterators.AbstractLongSpliterator; +import java.util.Spliterators.AbstractSpliterator; +import java.util.function.*; +import java.util.stream.*; + import static java.util.Comparator.comparing; import static java.util.Objects.requireNonNull; import static java.util.Spliterator.ORDERED; import static java.util.function.Function.identity; import static java.util.stream.Collectors.collectingAndThen; -import static java.util.stream.Collectors.toList; -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 java.util.AbstractMap; -import java.util.Collection; -import java.util.Comparator; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Spliterator; -import java.util.Spliterators.AbstractDoubleSpliterator; -import java.util.Spliterators.AbstractIntSpliterator; -import java.util.Spliterators.AbstractLongSpliterator; -import java.util.Spliterators.AbstractSpliterator; -import java.util.function.BiConsumer; -import java.util.function.BiFunction; -import java.util.function.BiPredicate; -import java.util.function.Consumer; -import java.util.function.DoubleConsumer; -import java.util.function.Function; -import java.util.function.IntConsumer; -import java.util.function.LongConsumer; -import java.util.function.Predicate; -import java.util.function.ToDoubleBiFunction; -import java.util.function.ToIntBiFunction; -import java.util.function.ToLongBiFunction; -import java.util.stream.Collector; -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; +import static java.util.stream.Collectors.toList; +import static java.util.stream.StreamSupport.*; /** * A class similar to {@link Stream}, but operating over a sequence of pairs of objects. @@ -222,11 +197,23 @@ public abstract class BiStream { public static Collector> groupingValuesFrom( Function>> entrySource, Collector valueCollector) { - return Collectors.flatMapping( - requireNonNull(entrySource.andThen(Collection::stream)), + return flatMapping( + (Function>>) requireNonNull(entrySource.andThen(Collection::stream)), groupingBy(Map.Entry::getKey, Collectors.mapping(Map.Entry::getValue, valueCollector))); } + private static Collector flatMapping( + Function> mapper, + Collector downstream) { + + BiConsumer acc = downstream.accumulator(); + return Collector.of(downstream.supplier(), + (a, t) -> { try(Stream s=mapper.apply(t)) { + if(s!=null) s.forEachOrdered(u -> acc.accept(a, u)); + }}, + downstream.combiner(), downstream.finisher(), + downstream.characteristics().toArray(new Collector.Characteristics[0])); + } /** * Returns a {@code Collector} that will pair each input element with each element from {@code * right} into a new {@code BiStream}. For example: diff --git a/core/src/test/java/com/google/mu/util/stream/BiStreamFunctionEvaluationTest.java b/core/src/test/java/com/google/mu/util/stream/BiStreamFunctionEvaluationTest.java index b4caf851a6..0df963a91d 100644 --- a/core/src/test/java/com/google/mu/util/stream/BiStreamFunctionEvaluationTest.java +++ b/core/src/test/java/com/google/mu/util/stream/BiStreamFunctionEvaluationTest.java @@ -14,27 +14,22 @@ *****************************************************************************/ package com.google.mu.util.stream; -import static com.google.common.truth.Truth.assertThat; -import static com.google.common.truth.Truth8.assertThat; - import com.google.common.collect.LinkedListMultimap; import com.google.common.collect.Multimap; import com.google.common.truth.MultimapSubject; +import junit.framework.TestCase; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + import java.util.ArrayList; import java.util.Comparator; import java.util.List; import java.util.function.Function; -import java.util.stream.Collector; -import java.util.stream.DoubleStream; -import java.util.stream.IntStream; -import java.util.stream.LongStream; -import java.util.stream.Stream; +import java.util.stream.*; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.JUnit4; - -import junit.framework.TestCase; +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.Truth8.assertThat; /** * Tests to ensure {@link BiStream#from(Stream, Function, Function)} maintains the invariant that @@ -367,12 +362,17 @@ private static Function trackCallHistory( }; } - private static MultimapSubject assertKeyValues(BiStream stream) { - Multimap multimap = stream.collect(BiStreamFunctionEvaluationTest::toLinkedListMultimap); + private static MultimapSubject assertKeyValues(BiStream stream) { + Multimap multimap = stream.collect(new BiCollector>() { + @Override + public Collector> bisecting(Function toKey, Function toValue) { + return BiStreamFunctionEvaluationTest.toLinkedListMultimap(toKey,toValue); + } + }); return assertThat(multimap); } - private static Collector> toLinkedListMultimap( + public static Collector> toLinkedListMultimap( Function toKey, Function toValue) { return Collector.of( LinkedListMultimap::create, diff --git a/core/src/test/java/com/google/mu/util/stream/BiStreamInvariantsTest.java b/core/src/test/java/com/google/mu/util/stream/BiStreamInvariantsTest.java index 60e48a1b8f..2dc17ca325 100644 --- a/core/src/test/java/com/google/mu/util/stream/BiStreamInvariantsTest.java +++ b/core/src/test/java/com/google/mu/util/stream/BiStreamInvariantsTest.java @@ -14,39 +14,27 @@ *****************************************************************************/ package com.google.mu.util.stream; -import static com.google.common.collect.ImmutableList.toImmutableList; -import static com.google.mu.util.stream.BiCollectors.toMap; -import static com.google.common.truth.Truth.assertThat; -import static com.google.common.truth.Truth8.assertThat; -import static java.util.Arrays.asList; -import static java.util.function.Function.identity; - -import com.google.common.collect.ImmutableList; -import com.google.common.collect.ImmutableListMultimap; -import com.google.common.collect.ImmutableMultimap; -import com.google.common.collect.ImmutableSet; -import com.google.common.collect.LinkedListMultimap; -import com.google.common.collect.ListMultimap; -import com.google.common.collect.Multimap; -import com.google.common.collect.MultimapBuilder; -import com.google.common.collect.Sets; +import com.google.common.collect.*; import com.google.common.truth.MultimapSubject; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.Comparator; -import java.util.List; -import java.util.Map; -import java.util.concurrent.atomic.AtomicInteger; -import java.util.function.Function; -import java.util.stream.Collector; -import java.util.stream.Stream; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.junit.runners.Parameterized.Parameter; import org.junit.runners.Parameterized.Parameters; +import java.util.*; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.function.Function; +import java.util.stream.Collector; +import java.util.stream.Stream; + +import static com.google.common.collect.ImmutableList.toImmutableList; +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.Truth8.assertThat; +import static com.google.mu.util.stream.BiCollectors.toMap; +import static java.util.Arrays.asList; +import static java.util.function.Function.identity; + @RunWith(Parameterized.class) public class BiStreamInvariantsTest { @@ -303,7 +291,12 @@ public void collect() { @Test public void collect_toImmutableListMultimapWithInflexibleMapperTypes() { ImmutableListMultimap multimap = - of("one", 1, "one", 10, "two", 2).collect(BiStreamInvariantsTest::toImmutableMultimap); + of("one", 1, "one", 10, "two", 2).collect(new BiCollector>() { + @Override + public Collector> bisecting(Function toKey, Function toValue) { + return BiStreamInvariantsTest.toImmutableMultimap(toKey,toValue); + } + }); assertThat(multimap) .containsExactlyEntriesIn(ImmutableListMultimap.of("one", 1, "one", 10, "two", 2)); } @@ -495,19 +488,24 @@ private BiStream of(K k1, V v1, K k2, V v2, K k3, V v3) { return variant.wrap(factory.newBiStream(k1, v1, k2, v2, k3, v3)); } - static MultimapSubject assertKeyValues(BiStream stream) { - Multimap multimap = stream.collect(BiStreamInvariantsTest::toLinkedListMultimap); + static MultimapSubject assertKeyValues(BiStream stream) { + Multimap multimap = stream.collect(new BiCollector>() { + @Override + public Collector> bisecting(Function toKey, Function toValue) { + return BiStreamInvariantsTest.toLinkedListMultimap(toKey,toValue); + } + }); return assertThat(multimap); } // Intentionally declare the parameter types without wildcards, to make sure // BiCollector can still work with such naive method references. - private static Collector> toImmutableMultimap( + public static Collector> toImmutableMultimap( Function keyMapper, Function valueMapper) { return ImmutableListMultimap.toImmutableListMultimap(keyMapper, valueMapper); } - private static Collector> toLinkedListMultimap( + private static Collector> toLinkedListMultimap( Function toKey, Function toValue) { return Collector.of( LinkedListMultimap::create, diff --git a/core/src/test/java/com/google/mu/util/stream/BiStreamTest.java b/core/src/test/java/com/google/mu/util/stream/BiStreamTest.java index 82417d4d77..fb44fe908f 100644 --- a/core/src/test/java/com/google/mu/util/stream/BiStreamTest.java +++ b/core/src/test/java/com/google/mu/util/stream/BiStreamTest.java @@ -14,6 +14,20 @@ *****************************************************************************/ package com.google.mu.util.stream; +import com.google.common.collect.*; +import com.google.common.truth.IterableSubject; +import com.google.common.truth.MultimapSubject; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.function.Function; +import java.util.stream.*; + import static com.google.common.collect.ImmutableList.toImmutableList; import static com.google.common.truth.Truth.assertThat; import static com.google.common.truth.Truth8.assertThat; @@ -23,34 +37,6 @@ import static java.util.stream.Collectors.toList; import static org.junit.jupiter.api.Assertions.assertThrows; -import java.util.Collections; -import java.util.HashMap; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ConcurrentMap; -import java.util.concurrent.atomic.AtomicBoolean; -import java.util.function.Function; -import java.util.stream.Collector; -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; - -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.JUnit4; - -import com.google.common.collect.ImmutableList; -import com.google.common.collect.ImmutableMap; -import com.google.common.collect.ImmutableMultimap; -import com.google.common.collect.LinkedListMultimap; -import com.google.common.collect.Multimap; -import com.google.common.truth.IterableSubject; -import com.google.common.truth.MultimapSubject; - @RunWith(JUnit4.class) public class BiStreamTest { @@ -594,12 +580,17 @@ public class BiStreamTest { .inOrder(); } - static MultimapSubject assertKeyValues(BiStream stream) { - Multimap multimap = stream.collect(BiStreamTest::toLinkedListMultimap); + static MultimapSubject assertKeyValues(BiStream stream) { + Multimap multimap = stream.collect(new BiCollector>() { + @Override + public Collector> bisecting(Function toKey, Function toValue) { + return BiStreamTest.toLinkedListMultimap(toKey,toValue); + } + }); return assertThat(multimap); } - private static Collector> toLinkedListMultimap( + public static Collector> toLinkedListMultimap( Function toKey, Function toValue) { return Collector.of( LinkedListMultimap::create, From 0a065f9740ce16359ebb0d94b35e186514e6bacb Mon Sep 17 00:00:00 2001 From: Bihuniak Date: Sun, 4 Aug 2019 17:32:24 +0200 Subject: [PATCH 2/9] fix pom.xml to compile with java 8 --- pom.xml | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 7d04687ba3..981a8e570b 100644 --- a/pom.xml +++ b/pom.xml @@ -145,7 +145,7 @@ maven-compiler-plugin 3.8.1 - 9 + 8 true @@ -227,6 +227,10 @@ maven-compiler-plugin + + 1.8 + 1.8 + From ab6d93653bf70c69a3cd954556aabe56fa239034 Mon Sep 17 00:00:00 2001 From: Bihuniak Date: Sun, 4 Aug 2019 18:25:45 +0200 Subject: [PATCH 3/9] added java 8 support for mug-examples module --- .../HowToCollectToCustomTypesTest.java | 36 +++++++++++++----- .../examples/HowToConcatenateMapsTest.java | 29 +++++++++------ .../examples/HowToDoGroupingFluentlyTest.java | 37 +++++++++++-------- pom.xml | 1 - 4 files changed, 67 insertions(+), 36 deletions(-) diff --git a/examples/src/test/java/examples/HowToCollectToCustomTypesTest.java b/examples/src/test/java/examples/HowToCollectToCustomTypesTest.java index 9bd6479857..87964123a7 100644 --- a/examples/src/test/java/examples/HowToCollectToCustomTypesTest.java +++ b/examples/src/test/java/examples/HowToCollectToCustomTypesTest.java @@ -1,16 +1,19 @@ package examples; -import static com.google.common.truth.Truth.assertThat; - -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.JUnit4; - import com.google.common.collect.ImmutableListMultimap; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableRangeMap; import com.google.common.collect.Range; +import com.google.mu.util.stream.BiCollector; import com.google.mu.util.stream.BiStream; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +import java.util.function.Function; +import java.util.stream.Collector; + +import static com.google.common.truth.Truth.assertThat; /** Some examples to show how {@link BiStream#collect} can be used to collect to custom types. */ @RunWith(JUnit4.class) @@ -18,14 +21,24 @@ public class HowToCollectToCustomTypesTest { @Test public void how_to_collect_to_immutableMap() { BiStream biStream = BiStream.of("one", 1, "two", 2); - ImmutableMap map = biStream.collect(ImmutableMap::toImmutableMap); + ImmutableMap map = biStream.collect(new BiCollector>() { + @Override + public Collector> bisecting(Function toKey, Function toValue) { + return ImmutableMap.toImmutableMap(toKey,toValue); + } + }); assertThat(map).containsExactly("one", 1, "two", 2); } @Test public void how_to_collect_to_immutableListMultimap() { BiStream biStream = BiStream.of("one", 1, "two", 2); ImmutableListMultimap map = - biStream.collect(ImmutableListMultimap::toImmutableListMultimap); + biStream.collect(new BiCollector>() { + @Override + public Collector> bisecting(Function toKey, Function toValue) { + return ImmutableListMultimap.toImmutableListMultimap(toKey,toValue); + } + }); assertThat(map).containsExactly("one", 1, "two", 2); } @@ -33,7 +46,12 @@ public class HowToCollectToCustomTypesTest { BiStream, String> biStream = BiStream.of(Range.closed(10, 19), "ten", Range.closed(20, 29), "twenty"); ImmutableRangeMap map = - biStream.collect(ImmutableRangeMap::toImmutableRangeMap); + biStream.collect(new BiCollector, String, ImmutableRangeMap>() { + @Override + public Collector> bisecting(Function> toKey, Function toValue) { + return ImmutableRangeMap.toImmutableRangeMap(toKey,toValue); + } + }); assertThat(map.get(12)).isEqualTo("ten"); } } diff --git a/examples/src/test/java/examples/HowToConcatenateMapsTest.java b/examples/src/test/java/examples/HowToConcatenateMapsTest.java index ff45728a5e..e9400358d4 100644 --- a/examples/src/test/java/examples/HowToConcatenateMapsTest.java +++ b/examples/src/test/java/examples/HowToConcatenateMapsTest.java @@ -1,19 +1,21 @@ package examples; -import static com.google.common.truth.Truth.assertThat; -import static com.google.mu.util.stream.BiStream.concat; -import static com.google.mu.util.stream.BiStream.concatenating; - -import java.util.Map; -import java.util.stream.Stream; - +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSetMultimap; +import com.google.mu.util.stream.BiCollector; +import com.google.mu.util.stream.BiStream; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; -import com.google.common.collect.ImmutableMap; -import com.google.common.collect.ImmutableSetMultimap; -import com.google.mu.util.stream.BiStream; +import java.util.Map; +import java.util.function.Function; +import java.util.stream.Collector; +import java.util.stream.Stream; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.mu.util.stream.BiStream.concat; +import static com.google.mu.util.stream.BiStream.concatenating; /** Some examples to show how to easily concatenate {@code Map}s and {@code Multimap}s. */ @RunWith(JUnit4.class) @@ -30,7 +32,12 @@ public class HowToConcatenateMapsTest { ImmutableMap english = ImmutableMap.of(1, "one", 2, "two"); ImmutableMap spanish = ImmutableMap.of(1, "uno", 2, "dos"); ImmutableSetMultimap combined = concat(english, spanish) - .collect(ImmutableSetMultimap::toImmutableSetMultimap); + .collect(new BiCollector>() { + @Override + public Collector> bisecting(Function toKey, Function toValue) { + return ImmutableSetMultimap.toImmutableSetMultimap(toKey,toValue); + } + }); assertThat(combined).containsExactly(1, "one", 1, "uno", 2, "two", 2, "dos"); } diff --git a/examples/src/test/java/examples/HowToDoGroupingFluentlyTest.java b/examples/src/test/java/examples/HowToDoGroupingFluentlyTest.java index 8f4b44c7fb..e76e7d69f6 100644 --- a/examples/src/test/java/examples/HowToDoGroupingFluentlyTest.java +++ b/examples/src/test/java/examples/HowToDoGroupingFluentlyTest.java @@ -1,24 +1,26 @@ package examples; -import static com.google.common.collect.ImmutableSet.toImmutableSet; -import static com.google.common.truth.Truth.assertThat; -import static com.google.mu.util.stream.BiStream.groupingBy; -import static com.google.mu.util.stream.BiStream.groupingValuesFrom; -import static java.util.Arrays.asList; - -import java.util.List; -import java.util.Map; -import java.util.stream.Stream; - -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.JUnit4; - import com.google.common.collect.ImmutableListMultimap; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Multimap; +import com.google.mu.util.stream.BiCollector; import com.google.mu.util.stream.BiStream; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +import java.util.List; +import java.util.Map; +import java.util.function.Function; +import java.util.stream.Collector; +import java.util.stream.Stream; + +import static com.google.common.collect.ImmutableSet.toImmutableSet; +import static com.google.common.truth.Truth.assertThat; +import static com.google.mu.util.stream.BiStream.groupingBy; +import static com.google.mu.util.stream.BiStream.groupingValuesFrom; +import static java.util.Arrays.asList; /** Some examples to show fluent grouping using {@link BiStream}. */ @RunWith(JUnit4.class) @@ -27,7 +29,12 @@ public class HowToDoGroupingFluentlyTest { @Test public void how_to_fluently_group_elements_into_guava_collections() { Map> byLeastSignificantDigit = Stream.of(1, 2, 11, 32) .collect(groupingBy(n -> n % 10, toImmutableSet())) - .collect(ImmutableMap::toImmutableMap); + .collect(new BiCollector, ImmutableMap>>() { + @Override + public Collector>> bisecting(Function toKey, Function> toValue) { + return ImmutableMap.toImmutableMap(toKey,toValue); + } + }); assertThat(byLeastSignificantDigit) .containsExactly(1, ImmutableSet.of(1, 11), 2, ImmutableSet.of(2, 32)); } diff --git a/pom.xml b/pom.xml index 981a8e570b..2c81e9b0f7 100644 --- a/pom.xml +++ b/pom.xml @@ -145,7 +145,6 @@ maven-compiler-plugin 3.8.1 - 8 true From 7d2e6b9b0002cbd3e616abaaf88b86e624b3aef3 Mon Sep 17 00:00:00 2001 From: bihu1 <49233167+bihu1@users.noreply.github.com> Date: Sun, 4 Aug 2019 20:36:49 +0200 Subject: [PATCH 4/9] Update README.md --- README.md | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 8a3197334d..676b50b68f 100644 --- a/README.md +++ b/README.md @@ -16,11 +16,15 @@ A small Java 8 utilities library ([javadoc](http://google.github.io/mug/apidocs/ Add the following to pom.xml: ``` + + jitpack.io + https://jitpack.io + - com.google.mug - mug - 3.0 - + com.github.bihu1 + mug + mug-root-3.3 + ``` ## Stream From ea25118de5f54ffb66f55ef80f592115f2fb767f Mon Sep 17 00:00:00 2001 From: bihu1 <49233167+bihu1@users.noreply.github.com> Date: Sun, 4 Aug 2019 20:38:16 +0200 Subject: [PATCH 5/9] Update README.md --- README.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index 676b50b68f..69836bc932 100644 --- a/README.md +++ b/README.md @@ -16,15 +16,15 @@ A small Java 8 utilities library ([javadoc](http://google.github.io/mug/apidocs/ Add the following to pom.xml: ``` - - jitpack.io - https://jitpack.io - - - com.github.bihu1 - mug - mug-root-3.3 - + + jitpack.io + https://jitpack.io + + + com.github.bihu1 + mug + mug-root-3.3 + ``` ## Stream From eb89fac0a361ed69c46bc0d3268be40991a8d637 Mon Sep 17 00:00:00 2001 From: bihu1 <49233167+bihu1@users.noreply.github.com> Date: Tue, 6 Aug 2019 11:35:43 +0200 Subject: [PATCH 6/9] Update README.md --- README.md | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 69836bc932..f14f2e4dca 100644 --- a/README.md +++ b/README.md @@ -16,14 +16,10 @@ A small Java 8 utilities library ([javadoc](http://google.github.io/mug/apidocs/ Add the following to pom.xml: ``` - - jitpack.io - https://jitpack.io - - com.github.bihu1 - mug - mug-root-3.3 + com.google.mug + mug + 3.0 ``` From 6bda80c9838c1b612545d816e26959c8aa08fd01 Mon Sep 17 00:00:00 2001 From: bihu1 <49233167+bihu1@users.noreply.github.com> Date: Tue, 6 Aug 2019 11:37:10 +0200 Subject: [PATCH 7/9] Update README.md --- README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index f14f2e4dca..8a3197334d 100644 --- a/README.md +++ b/README.md @@ -16,11 +16,11 @@ A small Java 8 utilities library ([javadoc](http://google.github.io/mug/apidocs/ Add the following to pom.xml: ``` - - com.google.mug - mug - 3.0 - + + com.google.mug + mug + 3.0 + ``` ## Stream From 706d6ba60b76f44908112420aa841b417d4aaaab Mon Sep 17 00:00:00 2001 From: Bihuniak Date: Tue, 6 Aug 2019 12:03:47 +0200 Subject: [PATCH 8/9] added stackoverflow tag --- core/src/main/java/com/google/mu/util/stream/BiStream.java | 1 + 1 file changed, 1 insertion(+) diff --git a/core/src/main/java/com/google/mu/util/stream/BiStream.java b/core/src/main/java/com/google/mu/util/stream/BiStream.java index 57d8d6fb92..b62fb3e650 100644 --- a/core/src/main/java/com/google/mu/util/stream/BiStream.java +++ b/core/src/main/java/com/google/mu/util/stream/BiStream.java @@ -202,6 +202,7 @@ public abstract class BiStream { groupingBy(Map.Entry::getKey, Collectors.mapping(Map.Entry::getValue, valueCollector))); } + //https://stackoverflow.com/questions/39130122/java-8-nested-multi-level-group-by/39131049#39131049 private static Collector flatMapping( Function> mapper, Collector downstream) { From 106b1f6a3efcb69716069a4f080228cd5345a26e Mon Sep 17 00:00:00 2001 From: Ben Yu Date: Tue, 20 Aug 2019 21:52:19 -0700 Subject: [PATCH 9/9] merged PR --- .../com/google/mu/util/stream/BiStream.java | 32 +++++++++++-------- 1 file changed, 18 insertions(+), 14 deletions(-) diff --git a/core/src/main/java/com/google/mu/util/stream/BiStream.java b/core/src/main/java/com/google/mu/util/stream/BiStream.java index b62fb3e650..efd5408b57 100644 --- a/core/src/main/java/com/google/mu/util/stream/BiStream.java +++ b/core/src/main/java/com/google/mu/util/stream/BiStream.java @@ -21,6 +21,7 @@ import java.util.Spliterators.AbstractSpliterator; import java.util.function.*; import java.util.stream.*; +import java.util.stream.Collector.Characteristics; import static java.util.Comparator.comparing; import static java.util.Objects.requireNonNull; @@ -198,23 +199,10 @@ public abstract class BiStream { Function>> entrySource, Collector valueCollector) { return flatMapping( - (Function>>) requireNonNull(entrySource.andThen(Collection::stream)), + requireNonNull(entrySource), groupingBy(Map.Entry::getKey, Collectors.mapping(Map.Entry::getValue, valueCollector))); } - //https://stackoverflow.com/questions/39130122/java-8-nested-multi-level-group-by/39131049#39131049 - private static Collector flatMapping( - Function> mapper, - Collector downstream) { - - BiConsumer acc = downstream.accumulator(); - return Collector.of(downstream.supplier(), - (a, t) -> { try(Stream s=mapper.apply(t)) { - if(s!=null) s.forEachOrdered(u -> acc.accept(a, u)); - }}, - downstream.combiner(), downstream.finisher(), - downstream.characteristics().toArray(new Collector.Characteristics[0])); - } /** * Returns a {@code Collector} that will pair each input element with each element from {@code * right} into a new {@code BiStream}. For example: @@ -1091,5 +1079,21 @@ public void accept(T value) { } } + // TODO: switch to Java 9 Collectors.flatMapping() when we can. + private static Collector flatMapping( + Function> mapper, Collector collector) { + BiConsumer accumulator = collector.accumulator(); + return Collector.of( + collector.supplier(), + (a, input) -> { + for (E entry : mapper.apply(input)) { + accumulator.accept(a, entry); + } + }, + collector.combiner(), + collector.finisher(), + collector.characteristics().toArray(new Characteristics[0])); + } + private BiStream() {} }