Stream Operations

https://howtodoinjava.com/java8/java-streams-by-examples/

1. Intermediate operations

Intermediate operations return the stream itself so you can chain multiple method calls in a row.

1.1 Stream.filter()

var names=Stream.of("b","a","c");
names.filter(i->i=="a").forEach(System.out::println);

import java.util.function.Predicate;
public class Demo {
    public static void main(String[] args) {

        var stream=Stream.of("a","b","c");
        Predicate<String> p=new Predicate<String>()
        {
            public boolean test(String s)
            {
                return s=="a";
            }
        };
        stream.filter(p).forEach(System.out::println);
    }
}

 

1.2 Stream.map()

var names=Stream.of("b","a","c");
names.map(String::toUpperCase).forEach(System.out::println);

1.3 Stream.sorted()

var names=Stream.of("b","a","c");
names.sorted().forEach(System.out::println);

var stream = Stream.of("c","b","a");
        stream.sorted((a,b)->a.compareTo(b)).forEach(System.out::println);

1.4 Stream.flatMap()

import java.util.*;
import java.util.stream.*;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
public class Demo {
    public static void main(String[] args) {

        List<Integer> list1 = Arrays.asList(1,2,3);
        List<Integer> list2 = Arrays.asList(4,5,6);
        List<Integer> list3 = Arrays.asList(7,8,9);
          
        List<List<Integer>> listOfLists = Arrays.asList(list1, list2, list3);
         
        List<Integer> listOfAllIntegers = listOfLists.stream()
                                    .flatMap(x -> x.stream())
                                    .collect(Collectors.toList());
  
        System.out.println(listOfAllIntegers);
    }
}

1.5 Stream.distinct()

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
 
public class Demo 
{
    public static void main(String[] args) 
    {
        Person lokesh = new Person(1, "Lokesh", "Gupta");
        Person brian = new Person(2, "Brian", "Clooney");
        Person alex = new Person(3, "Alex", "Kolen");
         
        //Add some random persons
        Collection<Person> list = Arrays.asList(lokesh,brian,alex,lokesh,brian,lokesh);
 
        // Get distinct objects by key
        List<Person> distinctElements = list.stream()
                                            .filter(distinctByKey(p -> p.getId()) )
                                            .collect( Collectors.toList() );
 
        // Let's verify distinct elements
        System.out.println( distinctElements );
    }
 
        //Utility function
    public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) 
    {
        Map<Object, Boolean> map = new ConcurrentHashMap<>();
        return t -> map.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }
}
 
//Model class
class Person 
{
    public Person(Integer id, String fname, String lname) {
        super();
        this.id = id;
        this.fname = fname;
        this.lname = lname;
    }
 
    private Integer id;
    private String fname;
    private String lname;
 
    //Getters and Setters
    public Integer getId() {return this.id;};
    @Override
    public String toString() {
        return "Person [id=" + id + ", fname=" + fname + ", lname=" + lname + "]";
    }
}

 

2. Terminal operations

2.1 Stream.forEach()

2.2 Stream.collect()

2.3 Stream.match()

2.4 Stream.count()

2.5 Stream.reduce()