Stream api is a powerful abstraction for processing sequence of elements in a functional and declarative style . it allows developers to perform complex data manipulations such as filtering , mapping , sorting and reducing with minimal boilerplate code .

Stream represent a pipeline of operations that can be executed either sequentially or in parallel , improving both readability and performance .

Purpose of Stream Api

The main goals of the stream api are .

1.Simplify data processing:

Replace verbose loops with expressive operations

2.Enable Functional programing :

use lambda expressions and method references

3. Improve Performance:

Support parallel execution with parallel stream .

Pipeline in Java Stream

A stream pipeline consists of three parts .

• Source
• Intermediate(Non terminal) operation
• Terminal operation

1. Source : the data source (eg list , set , array).

2.Intermediate(Non terminal) Operation :

these operations transform the stream , they are lazy and return another stream . laziness in stream means intermediate operations are not executed immediately . they are evaluated when a terminal operation is invoked . this allow for optimization , like short circuiting and avoiding unnecessary computations .

• filter(Predicate<T>)
• map(Function<T,R>)
• flatMap(Function<T,stream<R>>)
• sorted()
• sorted(Comperator<T>)
• distinct()
• peek(Consumer<T>)
• limit(long n)
• skip(long n)

Example:

package com.test.rkdigital.school.stream;
import java.util.Arrays;
import java.util.List;
public class StreamTest {

	public static void main(String[] args) {
		List<String> names=Arrays.asList("Rakesh","Nirupam","Sathya");
		names.stream().filter(name->name.length()>3)
		.map(String::toUpperCase)
		.forEach(System.out::println);
	}
}

2.Terminal Method :

These method trigger the execution of the stream pipeline and produce a result or a side effect .once a terminal method is called the stream is consumed and can not be reused .

• collect(Collectors)
• forEach(Consumer<T>)
• reduce(Binaryoperator<T>)
• count()
• min(Comperator)
• max(Comperator)
• anyMatch()
• allMatch()
• findFirst()
• findAny()

Example:

import java.util.*;
import java.util.stream.*;
public class CollectExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Amit", "Ravi", "Anil", "Suresh", "Ajay");
        List<String> result = names.stream()
                                   .filter(n -> n.startsWith("A"))
                                   .collect(Collectors.toList());

        System.out.println(result);
    }
}

1.Filtering:-

if we want to filter element from the collection based on some Boolean condition, then we should go for filtering . we can configure filter by using filter() method of stream interface .

class User {
    String name;
    boolean active;

    User(String name, boolean active) {
        this.name = name;
        this.active = active;
    }
}

public class FilterExample {

    public static void main(String[] args) {

        // Step 1: Create users list (simulating DB data)
        List<User> users = Arrays.asList(
                new User("Amit", true),
                new User("Ravi", false),
                new User("Neha", true),
                new User("Suresh", false)
        );

        // Step 2: Filter only active users
        List<User> activeUsers = users.stream()
                                      .filter(u -> u.active)
                                      .collect(Collectors.toList());

        // Step 3: Display result
        System.out.println("Active Users:");
        activeUsers.forEach(u -> System.out.println(u.name));

2.Mapping:

if we want to create a separate new object for every object present in the collection based on the some function then we should go for mapping mechanism can implement mapping by using map() method of stream interface .

Example :

class User {
    int id;
    String name;
    String email;

    User(int id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }
}

class UserDTO {
    int id;
    String name;

    UserDTO(int id, String name) {
        this.id = id;
        this.name = name;
    }
}
public class UserTestExample
{ 
 public static void main(String[] args) {

    List<User> users = Arrays.asList(
            new User(1, "Amit", "amit@gmail.com"),
            new User(2, "Neha", "neha@gmail.com"),
            new User(3, "Ravi", "ravi@gmail.com")
    );

    List<UserDTO> userDTOs =
            users.stream()
                 .map(u -> new UserDTO(u.id, u.name))
                 .collect(Collectors.toList());

    userDTOs.forEach(u -> System.out.println(u.id + " " + u.name));
 }
}