Intermediate Operations: 

• Process the stream elements.
• Typically transforms a stream into another stream.
• Are lazy, i.e., not executed till a terminal operation is invoked.
• Does internal iteration of all source elements.
• Any number of operations can be chained in the processing pipeline.
• Operations are applied as per the defined order.
• Intermediate operations are mostly lambda functions.

Terminal Operations:

• Kick-starts the Stream pipeline.
• used to collect the processed Stream data.

Example 

int count = Stream.of(1, 2, 3, 4, 5)

.filter(i -> i <4) // Intermediate Operation filter

.count(); // Terminal Operation count

1.Function: To transform arguments in returnable value.

2.Predicate: To perform a test and return a Boolean value.

3.Consumer: Accept arguments but do not return any values.

4.Supplier: Do not accept any arguments but return a value. 

 A Stream can process the following data:

• A collection of an Array.
• An I/O channel or an input device.
• A reactive source (e.g., comments in social media or tweets/re-tweets) 
• A stream generator function or a static factory

 Method reference is a compact way of referring to a method of functional interface. It is used to refer to a method without invoking it. :: (double colon) is used for describing the method reference. The syntax is class::methodName

Source Code:-  

package main;

public class FindMaxValueinArray {
    public static void main(String[] args) {
       int[] arr={3,6,-1,-2,7,88,44,66,23,54};
       int max=arr[0];
       for(int i:arr){
           max=Math.max(max,i);
       }
        System.out.println("Max value is : "+max);
    }
}

Output: Max value is : 88

Removing Duplicate Values From List in JAVA8

Source Code 👇👇👇

package Learn;

import java.util.Arrays;
import java.util.HashSet;
import java.util.List;

public class Main {
public static void main(String[] args) {
List<Integer> list=Arrays.asList(1,2,3,2,4,5,3,6,6,7);
HashSet<Integer> set=new HashSet<Integer>(list);
set.forEach(System.out::println);

}
}