Java 8 - Difference between Stream API map() and filter() methods

A quick and practical guide to differences between Stream API map() and filter() methods of Java 8. Stream map() vs filter(). Example programs on map() and stream() methods in Java 8.

Java 8 Stream - map() VS filter() 

1. Overview

In this tutorial, We'll be learning what are the differences between map() and filter methods in java 8 Stream API. Many developers have started using these methods in real-time applications but many of them not suer about these methods when and how to use. Let us start writing a simple program to understand the differences.

Both of these methods are present in Stream API and which is used to perform sequential and parallel operations. Apart from this point, these two methods are intermediate operations and return a Stream as a result.

Note: map() and filter() methods can be invoked on a single stream. There is no restriction to use the only operation at a time.

We will see first syntax for both methods and examples. At the last will talk about similarities and differences between them.

[post_ads]

2. Stream API map() method

This method just transforms the object from one form to another form. We need to pass a Function functional interface implementation using a lambda expression.

Read in-depth article on the Stream map() method.

2.1 Syntax:

<R> Stream<R> map(Function<? super T,? extends R> mapper)

Returns a stream consisting of the results of applying the given function to the elements of this stream.

2.2 Function Example

This function logic is executed for each object and returns a different type or same type as input.

Function<String, Integer> indexFinder = (input) -> input.indexOf("com");

int index = indexFinder.apply("javaprogramto.com");
System.out.println("index: " + index);

Output:

index: 14  

2.3 map() Example

Java program to collect the student names from Student's objects.

package com.java.w3schools.blog.java.program.to.java8.map;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Java program to collect student names from Student objects using stream map()
 * function.
 * 
 * @author JavaProgramTo.com
 *
 */
public class StreamMapExample7 {

 public static void main(String[] args) {

  // Creating string stream using Stream.of() method.
  Stream<Student> intValues = Stream.of(new Student(1, "Ganesh", 'B'), new Student(2, "Sachin", 'A'),
    new Student(3, "Bill", 'B'), new Student(4, "Vikram", 'C'));

  // list of Student objects
  List<String> emailList = intValues.map(user -> user.getName()).collect(Collectors.toList());

  // iterating final Student list
  emailList.forEach(output -> System.out.println(output));

 }

}

Output:

Ganesh
Sachin
Bill
Vikram

3. Stream filter() method

filter() method checks a condition and passes the object or value to the next step if the condition is true.

Read an in-depth article on the Stream API filter() method.

3.1 Syntax:

Stream<T> filter(Predicate<? super T> predicate)

This method takes Predicate functional interface and returns a new Stream with the valid objects. Valid objects if and only if predicate condition is true.

3.2 Predicate Example

filter() method takes this predicate-argument and this logic will be executed for each value in the stream. Predicate returns always a boolean type.

Predicate<Integer> ageValidation = a -> a > 18;

boolean output = ageValidation.test(10);
System.out.println(output);

Output:

false

3.3 filter() example

package com.java.w3schools.blog.java.program.to.java8;

import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 
 * Java program to find the valid ages.
 * 
 * @author JavaProgramTo.com
 *
 */

public class StreamFilterExample {

 public static void main(String[] args) {

  // creating a stream with different ages.
  Stream<Integer> ageStream = Stream.of(10, 20, 3, 40, 50, 6, 70, 80, 9, 0);

  // Custom predicate to check the age is above 18.
  Predicate<Integer> agePredicate = new Predicate<Integer>() {

   @Override
   public boolean test(Integer t) {

    if (t > 18) {
     return true;
    }

    return false;
   }
  };

  // filtering only valid ages using custom predicate and adding them into a list.
  List<Integer> validAgeList = ageStream.filter(agePredicate).collect(Collectors.toList());

  // printing
  validAgeList.forEach(value -> System.out.println(value));

 }

}

Output:

20
40
50
70
80

4. Stream map() VS filter()

The following are the differences and similarities of map() and filter() methods.

4.1 Stream map()

A) map() operation is part of Stream API.
B) map() is an Intermediate Operation.
C) map() method takes as an argument Function functional interface and Function implementation will return the same as input or different type.
D) map() returns a Stream<T>.
E) map() method returned Stream preserves the order of how they appear in the original list or Stream.
F) All values in the stream must be traversed through the logic of the Function function interface. (map() logic)
G) This will be returning a value which is mandatory. If not returning will result in a compile-time error.
H) map() method will always transform the current value or object into another type or same type. If we do not want to pass the value to the next step then we need to return a null value from the map() method.

4.2 Stream filter()

A) filter() operation is part of Stream API.
B) filter() is an Intermediate Operation.
C) filter() method takes as an argument Predicate functional interface and Predicate tells true or false about the predicate condition.
D) filter() returns a Stream<T>.
E) filter() method returned Stream preserves the order how they appear in the original list or Stream.
F) All values in the stream must be traversed through the logic of Predicate function interface. (filter() logic)
G) This will also be returning a value that is mandatory. If not returning will result in a compile-time error.
H) filter() method passes the values to the next step if the filter condition is true. Otherwise, the current object will be skipped from processing in the next step.

5. Conclusion

In this article, we have seen what are similarities and differences between map() and filter() methods of Stream API in Java 8. Example programs are shown on both methods.