feat: added more stream gatherer examples

Author: claudioaltamura

src/main/java/de/claudioaltamura/java23/streamgatherer/DistinctByGatherer.java

@@ -0,0 +1,34 @@
+package de.claudioaltamura.java23.streamgatherer;
+
+import java.util.Set;
+import java.util.HashSet;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Gatherer;
+
+public class DistinctByGatherer<T, P> implements Gatherer<T, Set<P>, T> {
+
+    private final Function<T, P> selector;
+
+    public DistinctByGatherer(Function<T, P> selector) {
+        this.selector = selector;
+    }
+
+    @Override
+    public Supplier<Set<P>> initializer() {
+        return HashSet::new;
+    }
+
+    @Override
+    public Integrator<Set<P>, T, T> integrator() {
+        return Integrator.ofGreedy((state, item, downstream) -> {
+            P extracted = selector.apply(item);
+            if (!state.contains(extracted)) {
+                state.add(extracted);
+                downstream.push(item);
+            }
+
+            return true;
+        });
+    }
+}

src/main/java/de/claudioaltamura/java23/streamgatherer/FindFirstGatherer.java

@@ -0,0 +1,24 @@
+package de.claudioaltamura.java23.streamgatherer;
+
+import java.util.function.Predicate;
+import java.util.stream.Gatherer;
+
+public class FindFirstGatherer<T> implements Gatherer<T, T, T> {
+    private final Predicate<T> predicate;
+
+    public FindFirstGatherer(Predicate<T> predicate) {
+        this.predicate = predicate;
+    }
+
+    @Override
+    public Integrator<T, T, T> integrator() {
+        return Integrator.ofGreedy((_, item, downstream) -> {
+            if (predicate.test(item)) {
+                downstream.push(item);
+                return false;
+            } else {
+                return true;
+            }
+        });
+    }
+}

src/main/java/de/claudioaltamura/java23/streamgatherer/GathererFactory.java

@@ -0,0 +1,27 @@
+package de.claudioaltamura.java23.streamgatherer;
+
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+public class GathererFactory {
+
+    private GathererFactory() {
+    }
+
+    public static <T, P> DistinctByGatherer<T, P> distinctBy(Function<T, P> extractor) {
+        return new DistinctByGatherer<>(extractor);
+    }
+
+    public static <T, P> ReduceByGatherer<T, P> reduceBy(Function<T, P> extractor, BiFunction<T, T, T> reducer) {
+        return new ReduceByGatherer<>(extractor, reducer);
+    }
+
+    public static <T, B extends Comparable<B>> MaxByGatherer<T, B> maxBy(Function<T, B> extractor) {
+        return new MaxByGatherer<>(extractor);
+    }
+
+    public static <T> FindFirstGatherer<T> findFirst(Predicate<T> predicate) {
+        return new FindFirstGatherer<>(predicate);
+    }
+}

src/main/java/de/claudioaltamura/java23/streamgatherer/MaxByGatherer.java

@@ -0,0 +1,71 @@
+package de.claudioaltamura.java23.streamgatherer;
+
+import java.util.function.BiConsumer;
+import java.util.function.BinaryOperator;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Gatherer;
+
+class MaxByGatherer<T, B extends Comparable<B>> implements Gatherer<T, State<T>, T> {
+    private final Function<T, B> extractor;
+
+    MaxByGatherer(Function<T, B> extractor) {
+        this.extractor = extractor;
+    }
+
+    @Override
+    public Supplier<State<T>> initializer() {
+        return State::new;
+    }
+
+    @Override
+    public Integrator<State<T>, T, T> integrator() {
+        return Integrator.ofGreedy((state, item, _) -> {
+            if (state.maxElement == null) {
+                state.maxElement = item;
+                return true;
+            }
+
+            B currentItemValue = extractor.apply(item);
+            B maxItemValue = extractor.apply(state.maxElement);
+
+            if (currentItemValue.compareTo(maxItemValue) > 0) {
+                state.maxElement = item;
+            }
+
+            return true;
+        });
+    }
+
+    @Override
+    public BinaryOperator<State<T>> combiner() {
+
+        return (first, second) -> {
+            if (first.maxElement == null && second.maxElement == null) {
+                return null;
+            } else if (first.maxElement == null) {
+                return second;
+            } else if (second.maxElement == null) {
+                return first;
+            }
+
+            B firstMaxValue = extractor.apply(first.maxElement);
+            B secondMaxValue = extractor.apply(second.maxElement);
+
+            if (firstMaxValue.compareTo(secondMaxValue) > 0) {
+                return first;
+            } else {
+                return second;
+            }
+        };
+    }
+
+    @Override
+    public BiConsumer<State<T>, Downstream<? super T>> finisher() {
+        return (state, downstream) -> downstream.push(state.maxElement);
+    }
+}
+
+class State<T> {
+    T maxElement;
+}

src/main/java/de/claudioaltamura/java23/streamgatherer/Money.java

@@ -0,0 +1,14 @@
+package de.claudioaltamura.java23.streamgatherer;
+
+import java.math.BigDecimal;
+import java.util.Currency;
+
+public record Money(BigDecimal amount, Currency currency) {
+    public Money add(Money money) {
+        return new Money(money.amount.add(this.amount), currency);
+    }
+
+    public Money multiply(BigDecimal multiplier) {
+        return new Money(amount.multiply(multiplier), currency);
+    }
+}

src/main/java/de/claudioaltamura/java23/streamgatherer/ReduceByGatherer.java

@@ -0,0 +1,37 @@
+package de.claudioaltamura.java23.streamgatherer;
+
+import java.util.Map;
+import java.util.HashMap;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Gatherer;
+
+public class ReduceByGatherer<T, P> implements Gatherer<T, Map<P, T>, T> {
+    private final Function<T, P> selector;
+    private final BiFunction<T, T, T> operation;
+
+    public ReduceByGatherer(Function<T, P> extractor, BiFunction<T, T, T> reducer) {
+        this.selector = extractor;
+        this.operation = reducer;
+    }
+
+    @Override
+    public Supplier<Map<P, T>> initializer() {
+        return HashMap::new;
+    }
+
+    @Override
+    public Integrator<Map<P, T>, T, T> integrator() {
+        return Integrator.ofGreedy((state, item, _) -> {
+            state.merge(selector.apply(item), item, operation);
+            return true;
+        });
+    }
+
+    @Override
+    public BiConsumer<Map<P, T>, Downstream<? super T>> finisher() {
+        return (state, downstream) -> state.values().forEach(downstream::push);
+    }
+}

src/test/java/de/claudioaltamura/java23/streamgatherer/DistinctByGathererTest.java

@@ -0,0 +1,21 @@
+package de.claudioaltamura.java23.streamgatherer;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class DistinctByGathererTest {
+
+    @Test
+    void testDistinctBy() {
+        var result = List.of("a", "b", "c", "a", "b", "c")
+                .stream()
+                .gather(GathererFactory.distinctBy(String::toUpperCase))
+                .collect(Collectors.toList());
+        assertEquals(List.of("a", "b", "c"), result);
+    }
+
+}

src/test/java/de/claudioaltamura/java23/streamgatherer/FindFirstGathererTest.java

@@ -0,0 +1,21 @@
+package de.claudioaltamura.java23.streamgatherer;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class FindFirstGathererTest {
+
+    @Test
+    void testFindFirst() {
+        var result = List.of("a", "c", "d", "a", "b", "c")
+                .stream()
+                .gather(GathererFactory.findFirst(e-> e.equals("b")))
+                .collect(Collectors.toList());
+        assertEquals(List.of("b"), result);
+    }
+
+}

src/test/java/de/claudioaltamura/java23/streamgatherer/MaxByGathererTest.java

@@ -0,0 +1,29 @@
+package de.claudioaltamura.java23.streamgatherer;
+
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+import java.util.Currency;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class MaxByGathererTest {
+
+    private static final Currency EUR = Currency.getInstance("EUR");
+    private static final Currency USD = Currency.getInstance("USD");
+
+    @Test
+    void testMaxGatherer() {
+        var result = List.of(
+                    new Money(BigDecimal.valueOf(12), EUR),
+                        new Money(BigDecimal.valueOf(10), USD)
+                )
+                .stream()
+                .parallel()
+                .gather(GathererFactory.maxBy(Money::amount))
+                .collect(Collectors.toList());
+        assertEquals(List.of(new Money(BigDecimal.valueOf(12), EUR)), result);
+    }
+}

src/test/java/de/claudioaltamura/java23/streamgatherer/ReduceByGathererTest.java

@@ -0,0 +1,21 @@
+package de.claudioaltamura.java23.streamgatherer;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ReduceByGathererTest {
+
+    @Test
+    void testReduceBy() {
+        var result = List.of("a", "b", "C", "A", "b", "C")
+                .stream()
+                .gather(GathererFactory.reduceBy(String::toLowerCase, String::concat))
+                .collect(Collectors.toList());
+        assertEquals(List.of("aA", "bb", "CC"), result);
+    }
+
+}