Hemant Samriya (Backend-Lead Development)

The Stream concept is introduced in Java 8 and the main objective of this concept is to process the contents of the Collection with Functional Programming(Lambda Expression).

Q. How to create Stream Objects?
We can create a Stream object from the collection by using the stream() method of the Collection interface. stream() is the default method in all the Collections in the 1.8 version.

Q. How can we process Objects of Collection by using Stream?
Once we have the stream, by using it we can process the object of that collection. we use either filter() or map() method.

• filter() method, filter the content of the collection based on some boolean condition.
• map() method, create a new object, for each content present in the collection based on our requirement.

1. takeWhile():
Syntax: default Stream<T> takeWhile (Predicate<? super T> predicate);
it takes elements from the Steam as long as Predicate returns true, if Predicate returns false at that point onwards it won't process the rest stream objects. there is no guarantee that it will process each object of the Stream.
example:

1
2

List<Integer> listOfInteger = Arrays.ofList(2,4,3,9,5,8);
List<Integer> listOfTakeWhile = listOfInteger.stream().takeWhile(i->i%2==0).collect(Collectors.toList());

2. dropWhile():
Syntax: default Stream<T> dropWhile (Predicate<? super T> predicate);
it is opposite to takeWhile(), it drops the objects instead of taking them as long as Predicate returns true, if Predicate returns false then the rest of the Stream return.
example:

List<Integer> listOfInteger = Arrays.asList(2,4,3,9,5,8);
List<Integer> listOfDropWhile = listOfInteger.stream().dropWhile(i->i%2==0).collect(Collectors.toList());

3. Stream.itearte():
i. with 2 args, it takes an initial value and a function that provides the next value.
Syntax: static <T> Stream<T> iterate (T seed, UnaryOperator<T> f);
example:

i) Stream.iterate(1, x-> x+1).forEach(System.out::println);// infinite loop
ii) Stream.iterate(1, x-> x+1).limit(5).forEach(System.out::println);//limit the loop

ii. with 3 args,
Syntax: static <T> Stream<T> iterate(T seed, Predicate<T> hasNext, UnaryOperator<T> next);
The main issue with the 2 args iterate() method is there may be a situation where it can go in an infinite loop, to avoid this issue we limit the iteration with this method. This method takes an initial value, terminate Predicate and a function that provide the next value.
example:

Stream.iterate(1, x-> x < 5, x-> x + 1).forEach(System.out::println);

4. ofNullable():
Syntax: static <T> Stream<T> ofNullable (T t);
this method checks whether the given element is null or not, if it is not null, then this method returns the Stream of that element, in a null situation this method returns an empty stream. the main merit of this method is, we can avoid NullPointerException and do not need to implement the null check condition everywhere.
example:

List<String> listOfStrings = Arrays.asList("A", "B", null, "E", "G", null);
List<String> listOfNonNullStrings = listOfStrings.stream().flatMap(str -> Stream.ofNullable(str)).collect(Collectors.toList());

There are some factory methods for creating unmodifiable Collections. before it,
in brief,
    > List :
        It is an indexed collection of elements where duplicate elements are allowed and insertion order is preserved.
    > Set :
        It is an unordered collection of elements where duplicate elements are not allowed and do not follow insertion order.
    > Map :
        This collection contains Key-Value pair which is called Entry (inner interface inside Map), Keys must be unique and Values can be duplicates.

It is very common to use immutable collection objects in Programming requirements to improve Memory Utilization and Performance.

In Java 9, 
    1. static <E> List<E> of() //factory method of unmodifiable List 
    2. static <E> Set<E> of() //factory method of unmodifiable Set

Up to 10 elements are allowed and the matched methods (12 methods [Method overloading] -> 1 without param method, 10 param methods and 1 var-arg param method) will be executed for more than ten elements, the internal var-arg method will be invoked.

    3. static <E> Map<K,V> of() //factory method of unmodifiable Map

in the Map case, we need to pass the key-value pair instead of elements alone.
    ex: Map<String, String> map = Map.of("1", "Java", "2", "Spring");
    
    > we have another way in map to create unmodifiable map object:
        Map.Entry<String, String> e = Map.entry("1", "Java", "2", "Spring");
    The Entry object is immutable and cannot be modifiable, if we try to change the content then, will get UnsupportedOperationException. by using these Entry objects we can create an Unmodifiable Map object with Map.ofEntries() method.
    Map<String, String> m = Map.ofEntries(e);

Short way, 
    import static java.util.Map.entry;
    Map<String, String> map = Map.ofEntries(entry("1","Java"), entry("2", "Spring"));

In Map Collection we have to take care of that "Up to 10 elements, it is recommended to use of() methods and for more than 10 items we should use ofEntries() method".

There are some exceptions we can get within this feature:
    1. NullPointerException
    2. UnsupportedOperationException
    3. IllegalArgumentsException

1. NullPointerException with Unmodifiable Collection Objects:
    ex: List<String> lang = List.of("Java", "Python", "C", null);//NullPointerException
    /*while using these factory methods, if any element is null then we will get this exception.*/
    
2. UnsupportedOperationException with Unmodifiable Collection Objects:
    ex: 
        Set<String> lang = Set.of("Java", "Python", "C");
        lang.add("Ruby"); //UnsupportedOperationException
        lang.remove("Python"); //UnsupportedOperationException
        /*after creating Unmodifiable objects if we try to change the content(add/remove) then we will face this exception.*/
3. IllegalArgumentsException with Unmodifiable Collection Objects:
    ex-1: 
        Map<String, String> langMap = Map.of("Lang-1","Java", "Lang-2","Python", "Lang-3","C", "Lang-1","Ruby");//IllegalArgumentsException
        /*while using these factory methods, if we are try to add duplicate keys then we will get this exception.*/
    ex-2:
        Set<String> lang = Set.of("Java", "Python", "C", "Java");//IllegalArgumentsException
        /*While using these factory methods, if we are trying to add duplicate elements in the set, then we will get this exception.*/