Split or move java-streams module

core-java-modules/core-java-streams-2/src/main/java/com/baeldung/reduce/application/Application.java

@@ -0,0 +1,39 @@
+package com.baeldung.reduce.application;
+
+import com.baeldung.reduce.entities.User;
+import com.baeldung.reduce.utilities.NumberUtils;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Application {
+
+    public static void main(String[] args) {
+        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
+        int result1 = numbers.stream().reduce(0, (subtotal, element) -> subtotal + element);
+        System.out.println(result1);
+        
+        int result2 = numbers.stream().reduce(0, Integer::sum);
+        System.out.println(result2);
+
+        List<String> letters = Arrays.asList("a", "b", "c", "d", "e");
+        String result3 = letters.stream().reduce("", (partialString, element) -> partialString + element);
+        System.out.println(result3);
+        
+        String result4 = letters.stream().reduce("", String::concat);
+        System.out.println(result4);
+
+        String result5 = letters.stream().reduce("", (partialString, element) -> partialString.toUpperCase() + element.toUpperCase());
+        System.out.println(result5);
+        
+        List<User> users = Arrays.asList(new User("John", 30), new User("Julie", 35));
+        int result6 = users.stream().reduce(0, (partialAgeResult, user) -> partialAgeResult + user.getAge(), Integer::sum);
+        System.out.println(result6);
+        
+        String result7 = letters.parallelStream().reduce("", String::concat);
+        System.out.println(result7);
+        
+        int result8 = users.parallelStream().reduce(0, (partialAgeResult, user) -> partialAgeResult + user.getAge(), Integer::sum);
+        System.out.println(result8);
+    }    
+}

core-java-modules/core-java-streams-2/src/main/java/com/baeldung/reduce/benchmarks/JMHStreamReduceBenchMark.java

@@ -0,0 +1,52 @@
+package com.baeldung.reduce.benchmarks;
+
+import com.baeldung.reduce.entities.User;
+import java.util.ArrayList;
+import java.util.List;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.RunnerException;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+@State(Scope.Thread)
+@BenchmarkMode(Mode.AverageTime)
+public class JMHStreamReduceBenchMark {
+    
+    private final List<User> userList = createUsers();
+
+    public static void main(String[] args) throws RunnerException {
+        
+        Options options = new OptionsBuilder()
+                .include(JMHStreamReduceBenchMark.class.getSimpleName()).threads(1)
+                .forks(1).shouldFailOnError(true).shouldDoGC(true)
+                .jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+    
+    private List<User> createUsers() {
+        List<User> users = new ArrayList<>();
+        for (int i = 0; i <= 1000000; i++) {
+            users.add(new User("John" + i, i));
+        }
+        return users;
+    }
+
+    @Benchmark
+    public Integer executeReduceOnParallelizedStream() {
+        return this.userList
+                .parallelStream()
+                .reduce(0, (partialAgeResult, user) -> partialAgeResult + user.getAge(), Integer::sum);
+    }
+
+    @Benchmark
+    public Integer executeReduceOnSequentialStream() {
+        return this.userList
+                .stream()
+                .reduce(0, (partialAgeResult, user) -> partialAgeResult + user.getAge(), Integer::sum);
+    }
+}

core-java-modules/core-java-streams-2/src/main/java/com/baeldung/reduce/entities/User.java

@@ -0,0 +1,25 @@
+package com.baeldung.reduce.entities;
+
+public class User {
+
+    private final String name;
+    private final int age;
+
+    public User(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getAge() {
+        return age;
+    }
+    
+    @Override
+    public String toString() {
+        return "User{" + "name=" + name + ", age=" + age + '}';
+    }
+}

core-java-modules/core-java-streams-2/src/main/java/com/baeldung/reduce/utilities/NumberUtils.java

@@ -0,0 +1,52 @@
+package com.baeldung.reduce.utilities;
+
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public abstract class NumberUtils {
+
+    private static final Logger LOGGER = Logger.getLogger(NumberUtils.class.getName());
+
+    public static int divideListElements(List<Integer> values, Integer divider) {
+        return values.stream()
+                .reduce(0, (a, b) -> {
+                    try {
+                        return a / divider + b / divider;
+                    } catch (ArithmeticException e) {
+                        LOGGER.log(Level.INFO, "Arithmetic Exception: Division by Zero");
+                    }
+                    return 0;
+                });
+    }
+    
+    public static int divideListElementsWithExtractedTryCatchBlock(List<Integer> values, int divider) {
+        return values.stream().reduce(0, (a, b) -> divide(a, divider) + divide(b, divider));
+    }
+    
+    public static int divideListElementsWithApplyFunctionMethod(List<Integer> values, int divider) {
+        BiFunction<Integer, Integer, Integer> division = (a, b) -> a / b;
+        return values.stream().reduce(0, (a, b) -> applyFunction(division, a, divider) + applyFunction(division, b, divider));
+    }
+    
+    private static int divide(int value, int factor) {
+        int result = 0;
+        try {
+            result = value / factor;
+        } catch (ArithmeticException e) {
+            LOGGER.log(Level.INFO, "Arithmetic Exception: Division by Zero");
+        }
+        return result;
+    }
+    
+    private static int applyFunction(BiFunction<Integer, Integer, Integer> function, int a, int b) {
+        try {
+            return function.apply(a, b);
+        }
+        catch(Exception e) {
+            LOGGER.log(Level.INFO, "Exception thrown!");
+        }
+        return 0;
+    }
+}

core-java-modules/core-java-streams-2/src/main/java/com/baeldung/streams/MyImmutableListCollector.java

@@ -0,0 +1,22 @@
+package com.baeldung.streams;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Supplier;
+import java.util.stream.Collector;
+
+public class MyImmutableListCollector {
+
+    public static <T, A extends List<T>> Collector<T, A, List<T>> toImmutableList(Supplier<A> supplier) {
+        return Collector.of(supplier, List::add, (left, right) -> {
+            left.addAll(right);
+            return left;
+        }, Collections::unmodifiableList);
+    }
+
+    public static <T> Collector<T, List<T>, List<T>> toImmutableList() {
+        return toImmutableList(ArrayList::new);
+    }
+
+}

core-java-modules/core-java-streams-2/src/main/resources/logback.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>