Java Stream API – Filters

Namachila 17 hours ago

0 0 4 minutes read

In this article, we will learn Java Stream Filter API. We will cover,

1. How stream filter API works.

2. Filter by Object Properties.

3. Filter by Index.

4. Filter by custom Object properties.

Stream Filter API

Filter API takes a Predicate. The predicate is a Functional Interface. It takes an argument of any type and returns Boolean. The element will be considered for the next API in the pipeline if the function returns true. Otherwise, the element is filtered out.

Java

// Java code for Stream filter
// (Predicate predicate) to get a stream
// consisting of the elements of this
// stream that match the given predicate.
  
import java.io.*;
import java.util.stream.Stream;
  
class StreamFilterExample {
    public static void main(String[] args)
    {
        // create a stream of strings
        Stream<String> myStream
            = Stream.of("Like", "and", "Share",
                        "https://www.zambiatek.com/");
  
        // only string starting with "http://" will be
        // considered for next API(forEach)
        myStream.filter(x -> x.startsWith("https://"))
            .forEach(System.out::println);
    }
}

Output

https://www.zambiatek.com/

Filter by Object Properties

Filter by Object properties uses java operators. The below example explains how to filter by properties of an object.

Java

// Java program to demonstrate 
// filter by Object properties
  
import java.io.*;
import java.util.stream.Stream;
  
class FilterByObjectProperties {
  
    public static void filterByEvenElements()
    {
        // create integer array
        Integer[] myArray
            = new Integer[] { 1, 4, 5, 7, 9, 10 };
  
        // create a stream and filter by
        // even numbers predicate
        Stream.of(myArray)
            .filter(x -> x % 2 == 0)
            .forEach(System.out::println);
    }
  
    public static void filterByStartsWith()
    {
        // create String array
        String[] myArray
            = new String[] { "stream",   "is",  "a",
                             "sequence", "of",  "elements",
                             "like",     "list" };
  
        // create a stream and filter by
        // starting string predicate
        Stream<String> myStream = Stream.of(myArray);
        myStream.filter(x -> x.startsWith("s"))
            .forEach(System.out::println);
    }
  
    public static void filterByStartsWithVowelsRegex()
    {
        // create string array
        String[] myArray
            = "I am 24 years old and I want to be in Tier I company"
                  .split(" ");
  
        // create a stream on myArray
        Stream<String> myStream = Stream.of(myArray);
  
        // filter by matching vowels regular expression
        myStream.filter(x -> x.matches("(a|e|i|o|u)\\w*"))
            .forEach(System.out::println);
    }
  
    public static void main(String[] args)
    {
        // filters a stream by even elements
        filterByEvenElements();
        System.out.println("======");
  
        // filters a stream by starting string
        filterByStartsWith();
        System.out.println("======");
  
        // filters a stream by starting vowel
        filterByStartsWithVowelsRegex();
    }
}

Output

4
10
======
stream
sequence
======
am
old
and
in

Filter by Object Indices

Filtering by indexes can be done in two ways.

1. Atomic Integers

We need to use AtomicInteger because predicates expect final variables as parameters. As long as filter function(Predicate) returns boolean we can use any expression. Here, getAndIncrement() method of AtomicInteger increments the current value by 1 and returns final int value.

Java

// Java program to demonstrate 
// filter by Object Indices
// using AtomicInteger
  
import java.io.*;
import java.util.stream.Stream;
import java.util.concurrent.atomic.AtomicInteger;
  
class FilterByObjectIndex {
  
    public static void filterByIndexUsingAtomic()
    {
        // create a string array
        String[] myArray
            = new String[] { "stream",   "is",  "a",
                             "sequence", "of",  "elements",
                             "like",     "list" };
  
        // create a stream on myArray
        Stream<String> myStream = Stream.of(myArray);
  
        // create an AtomicInteger
        AtomicInteger i = new AtomicInteger(0);
  
        // increment the i value by 1 everytime
        // if it is even, print the current element
        myStream.filter(x -> i.getAndIncrement() % 2 == 0)
            .forEach(System.out::println);
    }
  
    public static void main(String[] args)
    {
        // filter by Object index
        filterByIndexUsingAtomic();
    }
}

Output

stream
a
of
like

2. Intstream Approach

We can use Intstream and map the array elements based on the index. Here first we create an Intstream of a range of numbers. Check if a number is even, then overwrite/map the integer with the array element.

Java

// Java program to demonstrate 
// filter by Object properties
// using IntSteam Approach
  
import java.io.*;
import java.util.stream.IntStream;
class FilterByObjectIndexUsingIntStream {
  
    public static void filterByIndexUsingStream()
    {
        // create an array of Strings
        String[] myArray
            = new String[] { "stream",   "is",  "a",
                             "sequence", "of",  "elements",
                             "like",     "list" };
  
        // create instream on range of integers
        // filter by even integer and map
        // the integer to the Object of myArray
        IntStream.rangeClosed(0, myArray.length - 1)
            .filter(x -> x % 2 == 0)
            .mapToObj(x -> myArray[x])
            .forEach(System.out::println);
    }
  
    public static void main(String[] args)
    {
        filterByIndexUsingStream();
    }
}

Output

stream
a
of
like

Filter by Custom Properties

We can use any Java Object property for filtering. Here we are filtering by age.

Java

// Java program to demonstrate 
// filter by Custom Properties
  
import java.io.*;
import java.util.List;
import java.util.Arrays;
import java.util.stream.Stream;
class CustomFiltering {
  
    // Employee class
    class Employee {
  
        // attributes of an Employee
        String name;
        int age;
  
        // constructor
        Employee(String name, int age)
        {
            this.name = name;
            this.age = age;
        }
  
        // Override toString to print
        // provided content when an Object
        // is printed
        @Override public String toString()
        {
            return "Employee [name=" + name + "]";
        }
    }
  
    public static void filterByAge()
    {
        // create list of Employees
        List<Employee> myList = Arrays.asList(
            new GFG().new Employee("Ram", 25),
            new GFG().new Employee("Kumar", 40),
            new GFG().new Employee("Rakesh", 35));
  
        // create a stream on the list
        // filter by age of an employee
        myList.stream()
            .filter(x -> x.age >= 35)
            .forEach(System.out::println);
    }
  
    public static void main(String[] args)
    {
        filterByAge();
    }
}

Output

Employee [name=Kumar]
Employee [name=Rakesh]

We can also create a custom function for filtering. The function must take a parameter and return a boolean value.

Java

// Java program to demonstrate
// Custom filter
  
import java.io.*;
import java.util.stream.Stream;
class CustomFilterExample {
  
    public static void filterByCustomProperties()
    {
        // create a string array
        String[] myArray
            = new String[] { "madam", "please", "refer",
                             "link",  "on",     "racecar" };
  
        // filter using a custom method
        Stream.of(myArray)
            .filter(x -> palindrome(x))
            .forEach(System.out::println);
    }
  
      // checks if palindrome or not
    public static boolean palindrome(String s)
    {
        if (s.length() <= 1)
            return true;
        else
            return (s.charAt(0) == s.charAt(s.length() - 1))
                && palindrome(
                       s.substring(1, s.length() - 1));
    }
  
    public static void main(String[] args)
    {
        filterByCustomProperties();
    }
}