Two Types of Streams Offered by Java

In Java, the streams are majorly utilized for providing and offering several programming paradigms that are used for data processing and in an expensive and concise manner.

Java contains two major stream types and they are Intermediate Streams and Terminal Streams.

Let's understand about both Intermediate Stream and Terminal Stream in detail in the following paragraphs.

Intermediate Streams

Intermediate stream operations can be defined as operations that are utilized for transforming one stream into another stream. The operations of intermediate stream are often chained together for the creation of a transformation pipeline. Also, the operations of intermediate are lazy which means that they do not complete execution until and unless an operation of terminal is called. This evaluation in lazy manner results in higher efficient processing when data is being dealt in large datasets.

Let's understand about Intermediate streams in Java with the help of a Java example program.

Example 1:

Filename: IntermediateStreamsExample.java

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class IntermediateStreamsExample {
    public static void main(String[] args) {
        // Creating a list of Person objects
        List<Person> people = Arrays.asList(
                new Person("Alice", 28),
                new Person("Bob", 35),
                new Person("Charlie", 22),
                new Person("Diana", 30),
                new Person("Eva", 25));
        // Using intermediate stream operations
        // 1. Filter people aged 30 or older
        List<Person> filteredList = people.stream()
                .filter(person -> person.getAge() >= 30)
                .collect(Collectors.toList());
        System.out.println("People aged 30 or older: " + filteredList);
        // 2. Map names to uppercase
        List<String> upperCaseNames = people.stream()
                .map(Person::getName)
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        System.out.println("Names in uppercase: " + upperCaseNames);
        // 3. Sorting people by age in descending order
        List<Person> sortedList = people.stream()
                .sorted((p1, p2) -> Integer.compare(p2.getAge(), p1.getAge()))
                .collect(Collectors.toList());
        System.out.println("People sorted by age (descending): " + sortedList);
        // 4. Extract distinct ages
        List<Integer> distinctAges = people.stream()
                .map(Person::getAge)
                .distinct()
                .collect(Collectors.toList());
        System.out.println("Distinct ages: " + distinctAges);
    }
}

Output:

People aged 30 or older: [Person{name='Bob', age=35}, Person{name='Diana', age=30}]
Names in uppercase: [ALICE, BOB, CHARLIE, DIANA, EVA]
People sorted by age (descending): [Person{name='Bob', age=35}, Person{name='Diana', age=30}, Person{name='Alice', age=28}, Person{name='Eva', age=25}, Person{name='Charlie', age=22}]
Distinct ages: [28, 35, 22, 30, 25]

Terminal Streams in Java

In Java, the operations of Terminal streams can be defined as operations that are utilized in producing results or side effects. When a single operation of terminal is activated or invoked, the stream gets consumed, and no more operations will be allowed or permitted to be applied to it. The terminal operations are also utilized in triggering the evaluation of the whole pipeline of the stream.

Let's understand about Intermediate streams in Java with the help of a Java example program.

Filename: TerminalStreamsExample.java

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class TerminalStreamsExample {
    public static void main(String[] args) {
        // Creating a list of Person objects
        List<Person> people = Arrays.asList(
                new Person("Alice", 28),
                new Person("Bob", 35),
                new Person("Charlie", 22),
                new Person("Diana", 30),
                new Person("Eva", 25));
        // Using terminal stream operations
        // 1. forEach(): Print each person's details
        System.out.println("Printing each person's details:");
        people.stream()
                .forEach(System.out::println);
        // 2. collect(): Transform the stream into a List of names
        List<String> namesList = people.stream()
                .map(Person::getName)
                .collect(java.util.stream.Collectors.toList());
        System.out.println("\nList of names: " + namesList);
        // 3. reduce(): Calculate the sum of ages
        Optional<Integer> sumAges = people.stream()
                .map(Person::getAge)
                .reduce(Integer::sum);
        System.out.println("\nSum of ages: " + sumAges.orElse(0));
        // 4. count(): Count the number of people
        long count = people.stream().count();
        System.out.println("\nNumber of people: " + count);
        // 5. anyMatch(): Check if anyone is older than 35
        boolean anyMatch = people.stream()
                .anyMatch(person -> person.getAge() > 35);
        System.out.println("\nAnyone older than 35? " + anyMatch);
        // 6. allMatch(): Check if all are younger than 40
        boolean allMatch = people.stream()
                .allMatch(person -> person.getAge() < 40);
        System.out.println("All younger than 40? " + allMatch);
        // 7. noneMatch(): Check if none are older than 40
        boolean noneMatch = people.stream()
                .noneMatch(person -> person.getAge() > 40);
        System.out.println("None older than 40? " + noneMatch);
    }
}

Output:

Printing each person's details:
Person{name='Alice', age=28}
Person{name='Bob', age=35}
Person{name='Charlie', age=22}
Person{name='Diana', age=30}
Person{name='Eva', age=25}
List of names: [Alice, Bob, Charlie, Diana, Eva]
Sum of ages: 140
Number of people: 5
Anyone older than 35? false
All younger than 40? true
None older than 40? true

This was all the required information and explanation about two types of streams offered by Java.

Next TopicUses of Collections in Java

← prev next →