JDK 24: added examples of Stream Gatherers

Author: wesleyegberto

java-24/README.md

@@ -183,4 +183,6 @@ To run each example use: `java --enable-preview --source 24 <FileName.java>`
 * Blogs:
     * [A Basic Introduction to the Classfile API](https://ifesunmola.com/a-basic-introduction-to-the-classfile-api/#creating-the-personrunner-class)
     * [Class File API: Not Your Everyday Java API](https://www.unlogged.io/post/class-file-api-not-your-everyday-java-api)
+* Presentations:
+    * [Stream Gatherers - Deep Dive with the Expert](https://www.youtube.com/watch?v=v_5SKpfkI2U)
 

java-24/StreamGatherersBuiltin.java

@@ -0,0 +1,72 @@
+import static java.util.stream.Collectors.toList;
+import java.util.stream.Stream;
+import java.util.stream.Gatherer;
+import java.util.stream.Gatherers;
+
+/*
+ * To run: `java StreamGatherersBuiltin.java`
+ */
+public class StreamGatherersBuiltin {
+	public static void main(String[] args) {
+		System.out.println("=== Fold ===");
+		fold();
+		System.out.println("=== Scan ===");
+		scan();
+		System.out.println("=== Window Fixed ===");
+		windowFixed();
+		System.out.println("=== Window Sliding ===");
+		windowSliding();
+		System.out.println("=== Map Concurrent ===");
+		mapConcurrent();
+	}
+
+	static void fold() {
+		var sum = generate(10)
+				.gather(
+					Gatherers.fold(() -> 0, (acc, elem) -> acc + elem)
+				)
+				.findFirst()
+				.get();
+		System.out.println("The sum of all elements: " + sum);
+	}
+
+	static void scan() {
+		var sums = generate(10)
+			.gather(
+				Gatherers.scan(() -> 0, (acc, elem) -> acc + elem)
+			)
+			.collect(toList());
+		System.out.println("The sum of each element with its previous: " + sums);
+	}
+
+	static void windowFixed() {
+		var pairs = generate(10)
+				.gather(
+					Gatherers.windowFixed(2)
+				)
+				.collect(toList());
+		System.out.println("Pair of elements: " + pairs);
+	}
+
+	static void windowSliding() {
+		var neighbors = generate(10)
+				.gather(
+					Gatherers.windowSliding(2)
+				)
+				.collect(toList());
+		System.out.println("Elements that are neighbor: " + neighbors);
+	}
+
+	static void mapConcurrent() {
+		// mapConcurrent uses VirtualThreads
+		// preserves the ordering of the stream
+		var first10thSquares = generate(50)
+				.gather(Gatherers.mapConcurrent(5, elem -> elem * elem))
+				.collect(toList());
+		System.out.println("First 50th squares: " + first10thSquares);
+	}
+
+	static Stream<Integer> generate(int size) {
+		return Stream.iterate(1, acc -> acc + 1).limit(size);
+	}
+}

java-24/StreamGatherersExamples.java

@@ -0,0 +1,81 @@
+import static java.util.stream.Collectors.toList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.stream.Stream;
+import java.util.stream.Gatherer;
+import java.util.stream.Gatherers;
+
+/*
+ * To run: `java StreamGatherersExamples.java`
+ */
+public class StreamGatherersExamples {
+	public static void main(String[] args) {
+		deduplicateStream();
+		filterIfHasAtLeastFiveEvenNumbers();
+	}
+
+	static void deduplicateStream() {
+		var uniques = Stream.of(1, 2, 5, 8, 1, 9, 3, 5, 4, 8, 7, 3)
+			.gather(deduplicate())
+			.collect(toList());
+		System.out.println("Unique elements: " + uniques);
+	}
+
+	static Gatherer<Integer, Set<Integer>, Integer> deduplicate() {
+		return Gatherer.ofSequential(
+			// initializer: start the state with a Set
+			() -> new TreeSet<>(),
+			// integrator: only add if doesn't exists in the set
+			Gatherer.Integrator.ofGreedy((state, element, downstream) -> {
+				if (state.contains(element)) {
+					// ask for the next element if the downstream is on
+					return !downstream.isRejecting();
+				}
+				state.add(element);
+				// pushes downstream and ask for more if the downstream is on
+				return downstream.push(element);
+			})
+		);
+	}
+
+	static void filterIfHasAtLeastFiveEvenNumbers() {
+		var list = Stream.generate(() -> (int) (Math.random() * 10) + 1)
+			.limit(10)
+			.gather(filterAtLeastFiveEvenNumbers())
+			.collect(toList());
+		if (list.isEmpty())
+			System.out.println("There were not enough even numbers");
+		else
+			System.out.println("Even numbers: " + list);
+	}
+
+	static Gatherer<Integer, List<Integer>, Integer> filterAtLeastFiveEvenNumbers() {
+		return Gatherer.of(
+			// initializer: start a new list
+			LinkedList::new,
+			// integrator: only add if it is an even number, also increments
+			(state, element, downstream) -> {
+				if (element % 2 == 0) {
+					state.add(element);
+				}
+				return !downstream.isRejecting();
+			},
+			// combiner: merge the parallel gathering
+			(leftState, rightState) -> {
+				leftState.addAll(rightState);
+				return leftState;
+			},
+			// finisher: only pushes if has at least five even numbers
+			(state, downstream) -> {
+				if (state.size() < 5) {
+					return;
+				}
+				state.forEach(i -> {
+					downstream.push(i);
+				});
+			}
+		);
+	}
+}