Java stream reduce

Java/java-stream-reduce/ExampleAccumulator.java

@@ -0,0 +1,9 @@
+import java.util.Arrays;
+import java.util.List;
+public class ExampleAccumulator {
+   public static void main(String[] args) {
+       List<Integer> givenNumbers = Arrays.asList(2, 4, 6, 8, 10);
+       int average = givenNumbers.stream().reduce((total, currentValue) -> total + currentValue).orElse(0) / givenNumbers.size();
+       System.out.print("Average : " + average);
+   }
+}

Java/java-stream-reduce/ExampleDiffAccumulatorCombiner.java

@@ -0,0 +1,8 @@
+import java.util.List;
+public class ExampleDiffAccumulatorCombiner {
+   public static void main(String[] args) {
+       List<String> numbers = Arrays.asList("one", "two", "three", "four", "five");
+       String result = numbers.stream().reduce("=>", (first, second) -> first + "$" + second, (first, second) -> first + "%" + second);
+       System.out.println(result);
+   }
+}

Java/java-stream-reduce/ExampleIdentityAccumulator.java

@@ -0,0 +1,9 @@
+import java.util.Arrays;
+import java.util.List;
+public class ExampleIdentityAccumulator {
+   public static void main(String[] args) {
+       List<Integer> givenNumbers = Arrays.asList(2, 4, 6, 8, 10);
+       int result = givenNumbers.stream().reduce(5, Integer::sum);
+       System.out.println(result);
+   }
+}

Java/java-stream-reduce/ExampleIdentityAccumulatorCombiner.java

@@ -0,0 +1,9 @@
+import java.util.Arrays;
+import java.util.List;
+public class ExampleIdentityAccumulatorCombiner {
+   public static void main(String[] args) {
+       List<String> numbers = Arrays.asList("one", "two", "three", "four", "five");
+       String result = numbers.parallelStream().reduce(" ", (first, second) -> first + second, String::concat);
+       System.out.println(result);
+   }
+}

Java/java-stream-reduce/ExpenseTracker.java

@@ -0,0 +1,29 @@
+import java.util.Arrays;
+import java.util.List;
+class Expense {
+   String category;
+   private double expense;
+   Expense(String _category, double _expense) {
+       this.category = _category;
+       this.expense = _expense;
+   }
+   double getExpense() {
+       return expense;
+   }
+   String getCategory() {
+       return category;
+   }
+}
+
+public class ExpenseTracker {
+   public static void main(String[] args) {
+       List<Expense> expenseList = Arrays.asList(new Expense("fuel", 200), new Expense("grocery", 1000), new Expense("rent", 500), new Expense("outdoor", 560.5));
+       double totalExpense = expenseList.stream().reduce(0.0, (result, current) -> result + current.getExpense(), Double::sum);
+       Expense highestExpense = expenseList.stream().reduce((result, current) -> result.getExpense() > current.getExpense() ? result : current).orElse(null);
+       double lowestExpenseAmount = expenseList.stream().map(Expense::getExpense).reduce(Double.MAX_VALUE, (result, current) -> result < current ? result : current);
+
+       System.out.println("Total expense : " + totalExpense);
+       System.out.println("Highest expense category : " + highestExpense.getCategory() + " expense : " + highestExpense.getExpense());
+       System.out.println("Lowest expense : " + lowestExpenseAmount);
+   }
+}

Java/java-stream-reduce/ParallelExample.java

@@ -0,0 +1,24 @@
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class ParallelExample {
+   public static void main(String[] args) {
+       Random random = new Random();
+       final List<Integer> LARGE_LIST = new ArrayList<>(100000000);
+
+       for (int i = 0; i < 100000000; i++)
+           LARGE_LIST.add(random.nextInt(10000));
+
+       Instant startTime = Instant.now();
+       int largestNumber = LARGE_LIST.stream().reduce(0, (result, current) -> result > current ? result : current);
+       long totalTime = Duration.between(startTime,Instant.now()).toMillis();
+
+       Instant parallelStartTime = Instant.now();
+       int largestNumberParallel = LARGE_LIST.parallelStream().reduce(0, (result, current) -> result > current ? result : current, Integer::max);
+       long totalTimeParallel = Duration.between(parallelStartTime,Instant.now()).toMillis();
+       System.out.println("Largest number sequential : " + largestNumber + " time : " + totalTime);
+       System.out.println("Largest number parallel : " + largestNumberParallel + " time : " + totalTimeParallel);
+   }
+}