Close

Java 8 Streams - Collectors.filtering() Examples

Java 8 Streams Java Java API 

PreviousNext

Class:

java.util.stream.Collectors

java.lang.Objectjava.lang.Objectjava.util.stream.Collectorsjava.util.stream.CollectorsLogicBig

Method:

public static <T,A,R> Collector<T,?,R> filtering(Predicate<? super T> predicate,
                                                 Collector<? super T,A,R> downstream)

Adapts a Collector to one accepting elements of the same type T by applying the predicate to each input element and only accumulating if the predicate returns true.

This method was added in Java 9.


Examples


package com.logicbig.example.collectors;

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

public class FilteringExample {

    public static void main(String... args) {
        List<Integer> list = IntStream.of(2, 4, 6, 8, 10, 12)
                                      .boxed()
                                      .collect(Collectors.filtering(i -> i % 4 == 0,
                                              Collectors.toList()));
        System.out.println(list);

    }
}

Output

[4, 8, 12]
Original Post




This example is taken from Collectors#filtering API doc:

package com.logicbig.example.collectors;

import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;

public class FilteringExample2 {

    public static void main(String... args) {

        Map<Department, Set<Employee>> wellPaidEmployeesByDepartment
                = getEmployees().stream().collect(
                Collectors.groupingBy((Employee employee) -> employee.dept, Collectors
                        .filtering(e -> e.salary >= 2000,
                                Collectors.toSet())));
        wellPaidEmployeesByDepartment.forEach((k, v) -> System.out.printf("%8s: %s%n", k.name, v));
    }

    private static List<Employee> getEmployees() {
        return List.of(
                new Employee("Sara", new Department("Admin"), 3000),
                new Employee("Joe", new Department("IT"), 1000),
                new Employee("Mike", new Department("Account"), 2000),
                new Employee("Tony", new Department("Account"), 1500),
                new Employee("Linda", new Department("IT"), 5000)
        );
    }

    private static class Employee {
        private String name;
        private Department dept;
        private int salary;

        public Employee(String name, Department dept, int salary) {
            this.name = name;
            this.dept = dept;
            this.salary = salary;
        }

        @Override
        public String toString() {
            return "Employee{" +
                    "name='" + name + '\'' +
                    ", dept=" + dept +
                    ", salary=" + salary +
                    '}';
        }
    }

    private static class Department {
        private String name;

        public Department(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "Department{" +
                    "name='" + name + '\'' +
                    '}';
        }

        @Override
        public boolean equals(Object o) {
            Department that = (Department) o;
            return Objects.equals(name, that.name);
        }

        @Override
        public int hashCode() {
            return Objects.hash(name);
        }
    }
}

Output

 Account: [Employee{name='Mike', dept=Department{name='Account'}, salary=2000}]
      IT: [Employee{name='Linda', dept=Department{name='IT'}, salary=5000}]
   Admin: [Employee{name='Sara', dept=Department{name='Admin'}, salary=3000}]
Original Post

See Also