The map(), filter(), and reduce() methods are key operations used in Java Stream API which is used for processing collection objects in a functional programming manner.
Java Streams provide many powerful methods to perform common operations like map, filter, reduce, etc. These operations can transform and manipulate data in many ways.
- map: The
map() function is used to transform one type of Stream to another. It applies a function to each element of the Stream and then returns the function’s output as a new Stream. The number of input and output elements is the same, but the type or value of the elements may change.
Here’s an example:
package org.kodejava.basic;
import java.util.Arrays;
import java.util.List;
public class MapToUpperCase {
public static void main(String[] args) {
List<String> myList = Arrays.asList("a1", "a2", "b1", "c2", "c1");
myList.stream()
.map(String::toUpperCase)
.sorted()
.forEach(System.out::println);
}
}
Output:
A1
A2
B1
C1
C2
Another example to use map() to convert a list of Strings to a list of their lengths:
package org.kodejava.basic;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class MapStringToLength {
public static void main(String[] args) {
List<String> words = Arrays.asList("Java", "Stream", "API");
List<Integer> lengths = words
.stream()
.map(String::length)
.collect(Collectors.toList());
System.out.println("Lengths = " + lengths);
}
}
Output:
Lengths = [4, 6, 3]
- filter: The
filter() function is used to filter out elements from a Stream based upon a Predicate. It is an intermediate operation and returns a new stream which consists of elements of the current stream which satisfies the predicate condition.
Here’s an example:
package org.kodejava.basic;
import java.util.Arrays;
import java.util.List;
public class FilterStartWith {
public static void main(String[] args) {
List<String> myList = Arrays.asList("a1", "a2", "b1", "c2", "c1");
myList.stream()
.filter(s -> s.startsWith("c"))
.map(String::toUpperCase)
.sorted()
.forEach(System.out::println);
}
}
Output:
C1
C2
Another example:
package org.kodejava.basic;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class FilterEvenNumber {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evens = numbers
.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());
System.out.println("Even numbers = " + evens);
}
}
Output:
Even numbers = [2, 4, 6]
- reduce: The
reduce() function takes two parameters: an initial value, and a BinaryOperator function. It reduces the elements of a Stream to a single value using the BinaryOperator, by repeated application.
Here’s an example:
package org.kodejava.basic;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
public class ReduceSum {
public static void main(String[] args) {
List<Integer> myList = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> sum = myList
.stream()
.reduce((a, b) -> a + b);
sum.ifPresent(System.out::println);
}
}
Output:
15
In the above example, the reduce method will sum all the integers in the stream and then ifPresent is simply used to print the sum if the Optional is not empty.
All these operations can be chained together to build complex data processing pipelines. Furthermore, they are “lazy”, meaning they don’t perform any computations until a terminal operation (like collect()) is invoked on the stream.
