Skip to content

Commit ca4440d

Browse files
alejandrogervasioKevinGilmore
alejandrogervasio
authored and
KevinGilmore
committed
Guide to Stream.reduce() (eugenp#6372)
* Initial Commit * Update StreamReduceUnitTest.java * Update StreamReduceUnitTest.java * Update StreamReduceUnitTest.java
1 parent 37f9a70 commit ca4440d

File tree

4 files changed

+265
-0
lines changed

4 files changed

+265
-0
lines changed

‎core-java-8/src/main/java/com/baeldung/streamreduce/application/Application.java‎

Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
package com.baeldung.streamreduce.application;
2+
3+
import com.baeldung.streamreduce.entities.User;
4+
import com.baeldung.streamreduce.utilities.NumberUtils;
5+
import java.util.ArrayList;
6+
import java.util.Arrays;
7+
import java.util.List;
8+
9+
public class Application {
10+
11+
public static void main(String[] args) {
12+
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
13+
int result1 = numbers.stream().reduce(0, (a, b) -> a + b);
14+
System.out.println(result1);
15+
16+
int result2 = numbers.stream().reduce(0, Integer::sum);
17+
System.out.println(result2);
18+
19+
List<String> letters = Arrays.asList("a", "b", "c", "d", "e");
20+
String result3 = letters.stream().reduce("", (a, b) -> a + b);
21+
System.out.println(result3);
22+
23+
String result4 = letters.stream().reduce("", String::concat);
24+
System.out.println(result4);
25+
26+
String result5 = letters.stream().reduce("", (a, b) -> a.toUpperCase() + b.toUpperCase());
27+
System.out.println(result5);
28+
29+
List<User> users = Arrays.asList(new User("John", 30), new User("Julie", 35));
30+
int result6 = users.stream().reduce(0, (partialAgeResult, user) -> partialAgeResult + user.getAge(), Integer::sum);
31+
System.out.println(result6);
32+
33+
String result7 = letters.parallelStream().reduce("", String::concat);
34+
System.out.println(result7);
35+
36+
int result8 = users.parallelStream().reduce(0, (partialAgeResult, user) -> partialAgeResult + user.getAge(), Integer::sum);
37+
System.out.println(result8);
38+
39+
List<User> userList = new ArrayList<>();
40+
for (int i = 0; i <= 1000000; i++) {
41+
userList.add(new User("John" + i, i));
42+
}
43+
44+
long t1 = System.currentTimeMillis();
45+
int result9 = userList.stream().reduce(0, (partialAgeResult, user) -> partialAgeResult + user.getAge(), Integer::sum);
46+
long t2 = System.currentTimeMillis();
47+
System.out.println(result9);
48+
System.out.println("Sequential stream time: " + (t2 - t1) + "ms");
49+
50+
long t3 = System.currentTimeMillis();
51+
int result10 = userList.parallelStream().reduce(0, (partialAgeResult, user) -> partialAgeResult + user.getAge(), Integer::sum);
52+
long t4 = System.currentTimeMillis();
53+
System.out.println(result10);
54+
System.out.println("Parallel stream time: " + (t4 - t3) + "ms");
55+
56+
int result11 = NumberUtils.divideListElements(numbers, 1);
57+
System.out.println(result11);
58+
59+
int result12 = NumberUtils.divideListElementsWithExtractedTryCatchBlock(numbers, 0);
60+
System.out.println(result12);
61+
}
62+
}

‎core-java-8/src/main/java/com/baeldung/streamreduce/entities/User.java‎

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
package com.baeldung.streamreduce.entities;
2+
3+
public class User {
4+
5+
private final String name;
6+
private final int age;
7+
8+
public User(String name, int age) {
9+
this.name = name;
10+
this.age = age;
11+
}
12+
13+
public String getName() {
14+
return name;
15+
}
16+
17+
public int getAge() {
18+
return age;
19+
}
20+
21+
@Override
22+
public String toString() {
23+
return "User{" + "name=" + name + ", age=" + age + '}';
24+
}
25+
}

‎core-java-8/src/main/java/com/baeldung/streamreduce/utilities/NumberUtils.java‎

Lines changed: 52 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,52 @@
1+
package com.baeldung.streamreduce.utilities;
2+
3+
import java.util.List;
4+
import java.util.function.BiFunction;
5+
import java.util.logging.Level;
6+
import java.util.logging.Logger;
7+
8+
public abstract class NumberUtils {
9+
10+
private static final Logger LOGGER = Logger.getLogger(NumberUtils.class.getName());
11+
12+
public static int divideListElements(List<Integer> values, Integer divider) {
13+
return values.stream()
14+
.reduce(0, (a, b) -> {
15+
try {
16+
return a / divider + b / divider;
17+
} catch (ArithmeticException e) {
18+
LOGGER.log(Level.INFO, "Arithmetic Exception: Division by Zero");
19+
}
20+
return 0;
21+
});
22+
}
23+
24+
public static int divideListElementsWithExtractedTryCatchBlock(List<Integer> values, int divider) {
25+
return values.stream().reduce(0, (a, b) -> divide(a, divider) + divide(b, divider));
26+
}
27+
28+
public static int divideListElementsWithApplyFunctionMethod(List<Integer> values, int divider) {
29+
BiFunction<Integer, Integer, Integer> division = (a, b) -> a / b;
30+
return values.stream().reduce(0, (a, b) -> applyFunction(division, a, divider) + applyFunction(division, b, divider));
31+
}
32+
33+
private static int divide(int value, int factor) {
34+
int result = 0;
35+
try {
36+
result = value / factor;
37+
} catch (ArithmeticException e) {
38+
LOGGER.log(Level.INFO, "Arithmetic Exception: Division by Zero");
39+
}
40+
return result;
41+
}
42+
43+
private static int applyFunction(BiFunction<Integer, Integer, Integer> function, int a, int b) {
44+
try {
45+
return function.apply(a, b);
46+
}
47+
catch(Exception e) {
48+
LOGGER.log(Level.INFO, "Exception occurred!");
49+
}
50+
return 0;
51+
}
52+
}

‎core-java-8/src/test/java/com/baeldung/streamreduce/tests/StreamReduceUnitTest.java‎

Lines changed: 126 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,126 @@
1+
package com.baeldung.streamreduce.tests;
2+
3+
import com.baeldung.streamreduce.entities.User;
4+
import com.baeldung.streamreduce.utilities.NumberUtils;
5+
import java.util.ArrayList;
6+
import java.util.Arrays;
7+
import java.util.List;
8+
import static org.assertj.core.api.Assertions.assertThat;
9+
import org.junit.Test;
10+
11+
public class StreamReduceUnitTest {
12+
13+
@Test
14+
public void givenIntegerList_whenReduceWithSumAccumulatorLambda_thenCorrect() {
15+
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
16+
17+
int result = numbers.stream().reduce(0, (a, b) -> a + b);
18+
19+
assertThat(result).isEqualTo(21);
20+
}
21+
22+
@Test
23+
public void givenIntegerList_whenReduceWithSumAccumulatorMethodReference_thenCorrect() {
24+
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
25+
26+
int result = numbers.stream().reduce(0, Integer::sum);
27+
28+
assertThat(result).isEqualTo(21);
29+
}
30+
31+
@Test
32+
public void givenStringList_whenReduceWithConcatenatorAccumulatorLambda_thenCorrect() {
33+
List<String> letters = Arrays.asList("a", "b", "c", "d", "e");
34+
35+
String result = letters.stream().reduce("", (a, b) -> a + b);
36+
37+
assertThat(result).isEqualTo("abcde");
38+
}
39+
40+
@Test
41+
public void givenStringList_whenReduceWithConcatenatorAccumulatorMethodReference_thenCorrect() {
42+
List<String> letters = Arrays.asList("a", "b", "c", "d", "e");
43+
44+
String result = letters.stream().reduce("", String::concat);
45+
46+
assertThat(result).isEqualTo("abcde");
47+
}
48+
49+
@Test
50+
public void givenStringList_whenReduceWithUppercaseConcatenatorAccumulator_thenCorrect() {
51+
List<String> letters = Arrays.asList("a", "b", "c", "d", "e");
52+
53+
String result = letters.stream().reduce("", (a, b) -> a.toUpperCase() + b.toUpperCase());
54+
55+
assertThat(result).isEqualTo("ABCDE");
56+
}
57+
58+
@Test
59+
public void givenUserList_whenReduceWithAgeAccumulatorAndSumCombiner_thenCorrect() {
60+
List<User> users = Arrays.asList(new User("John", 30), new User("Julie", 35));
61+
62+
int result = users.stream().reduce(0, (partialAgeResult, user) -> partialAgeResult + user.getAge(), Integer::sum);
63+
64+
assertThat(result).isEqualTo(65);
65+
}
66+
67+
@Test
68+
public void givenStringList_whenReduceWithParallelStream_thenCorrect() {
69+
List<String> letters = Arrays.asList("a", "b", "c", "d", "e");
70+
71+
String result = letters.parallelStream().reduce("", String::concat);
72+
73+
assertThat(result).isEqualTo("abcde");
74+
}
75+
76+
@Test
77+
public void givenNumberUtilsClass_whenCalledDivideListElements_thenCorrect() {
78+
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
79+
80+
assertThat(NumberUtils.divideListElements(numbers, 1)).isEqualTo(21);
81+
}
82+
83+
@Test
84+
public void givenNumberUtilsClass_whenCalledDivideListElementsWithExtractedTryCatchBlock_thenCorrect() {
85+
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
86+
87+
assertThat(NumberUtils.divideListElementsWithExtractedTryCatchBlock(numbers, 1)).isEqualTo(21);
88+
}
89+
90+
@Test
91+
public void givenNumberUtilsClass_whenCalledDivideListElementsWithExtractedTryCatchBlockAndListContainsZero_thenCorrect() {
92+
List<Integer> numbers = Arrays.asList(0, 1, 2, 3, 4, 5, 6);
93+
94+
assertThat(NumberUtils.divideListElementsWithExtractedTryCatchBlock(numbers, 1)).isEqualTo(21);
95+
}
96+
97+
@Test
98+
public void givenNumberUtilsClass_whenCalledDivideListElementsWithExtractedTryCatchBlockAndDividerIsZero_thenCorrect() {
99+
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
100+
101+
assertThat(NumberUtils.divideListElementsWithExtractedTryCatchBlock(numbers, 0)).isEqualTo(0);
102+
}
103+
104+
@Test
105+
public void givenStream_whneCalleddivideListElementsWithApplyFunctionMethod_thenCorrect() {
106+
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
107+
108+
assertThat(NumberUtils.divideListElementsWithApplyFunctionMethod(numbers, 1)).isEqualTo(21);
109+
}
110+
111+
@Test
112+
public void givenTwoStreams_whenCalledReduceOnParallelizedStream_thenFasterExecutionTime() {
113+
List<User> userList = new ArrayList<>();
114+
for (int i = 0; i <= 1000000; i++) {
115+
userList.add(new User("John" + i, i));
116+
}
117+
long currentTime1 = System.currentTimeMillis();
118+
userList.stream().reduce(0, (partialAgeResult, user) -> partialAgeResult + user.getAge(), Integer::sum);
119+
long sequentialExecutionTime = System.currentTimeMillis() -currentTime1;
120+
long currentTime2 = System.currentTimeMillis();
121+
userList.parallelStream().reduce(0, (partialAgeResult, user) -> partialAgeResult + user.getAge(), Integer::sum);
122+
long parallelizedExecutionTime = System.currentTimeMillis() - currentTime2;
123+
124+
assertThat(parallelizedExecutionTime).isLessThan(sequentialExecutionTime);
125+
}
126+
}

0 commit comments

Comments
 (0)