In this article, we are going to walk through Stream API which is introduced as a part of Java8. Using Stream API, we can make our collection manipulation more declarative and thread safe in case of multi-threaded environment with very ease.

The advantage of using Stream API to manipulate collections is we only ask the Java framework what we want to do without taking control of iteration. Before going into more details, I would recommend you to go through Lambda expressions.

Now lets move to Stream API Basics. By the end of the article, we will be able to answer following questions:

1. What is streams?
2. How it can be created?
3. Stream operations?
4. Difference between stream and collections?

1. What is streams? 

Let's start our quest with first question, java helps us to process our data in more declarative way as we can do in SQL queries.

Java stream doesn't store data. It operates on the source data structure (ex: collection and array) and produce pipelined data that we can use and perform specific operations.

In addition to that java stream APIs also help us to use parallelism as these APIs supports many parallel operations to process the data.

Before going into more details of stream API, We will first go into one basic example of collection manipulation without Stream and with Stream. Program will print all the even number present in the collection.

//Without stream API
List<Integer> numbers = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
				
for(int i:numbers){
	if(i%2 ==0)
	System.out.println(i);
}

//With stream API
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
numbers.stream().filter(e -> e%2 ==0)
				.forEach(e -> System.out.println(e));

In the above example we have seen one example using external iterator while other using the stream API and internal iterator.

2. How it can be created? 

There are many ways to create stream API. Below are some of different ways to build streams from collections.

1) Using Stream.of(arrayOfElements)

Stream<Integer> stream = Stream.of( new Integer[]{1,2,3,4,5,6,7,8,9} );
stream.forEach(p -> System.out.println(p));

2) Using Stream.of(val1, val2, val3….)

Stream<Integer> stream = Stream.of(1,2,3,4,5,6,7,8,9);
stream.forEach(p -> System.out.println(p));

3) Using someList.stream()

Collection framework have introduced stream instance method using default method in interface. So you can get stream from any collection object via stream() or parallelStream() method.

List<Integer> list = new ArrayList<Integer>();

for(int i = 1; i< 10; i++){
 list.add(i);
}

Stream<Integer> stream = list.stream();
stream.forEach(p -> System.out.println(p));

4) Using String chars or String tokens

IntStream stream = "12345_abcdefg".chars();

stream.forEach(p -> System.out.println(p));

5) Using Stream.generate() or Stream.iterate() functions

Stream<Date> stream = Stream.generate(() -> { return new Date();});

stream.forEach(p -> System.out.println(p));

Streams can be defined as a sequence of elements from a source that supports aggregate operations on them.
The source here refers to a Collection or Arrays who provides data to a Stream. Stream keeps the order of the data as it is in the source.

java.util.Stream represents a stream on which one or more operations can be performed. Stream operations are either intermediate or terminal. While terminal operations return a result of a certain type, intermediate operations return the stream itself so you can chain multiple method calls in a row. Stream operations can either be executed sequential or parallel.

3. Stream operations:

There are many operations supported by stream API. Stream operations mainly divided into two section and they are combined to form a pipeline:

1. Intermediate Operations
2. Terminal Operations

1) Intermediate Operations: 

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

They are always lazy; executing an intermediate operation such as filter() does not actually perform any filtering, but instead creates a new stream that, when traversed, contains the elements of the initial stream that match the given predicate. Traversal of the pipeline source does not begin until the terminal operation of the pipeline is executed.

Some of the frequently used intermediate operations are: filter, map, sorted

numbers.stream().filter(e -> e%2 ==0)
				.forEach(e -> System.out.println(e));

numbers.parallelStream().filter(e -> e%2 ==0)
					    .mapToInt(e -> e *2)
						.sum()

numbers.stream().sorted().forEach(e -> System.out.println(e));

Terminal operations such as Stream.forEach or IntStream.sum return a result of a certain type instead of again a Stream. They may traverse the stream to produce a result or a side-effect.

After the terminal operation is performed, the stream pipeline is considered consumed, and can no longer be used; if you need to traverse the same data source again, you must return to the data source to get a new stream.

In almost all cases, terminal operations are eager, completing their traversal of the data source and processing of the pipeline before returning. Only the terminal operations iterator() and spliterator() are not eager. 

Some of the frequently used terminal operators are: forEach, collect, count, match, findFirst

numbers.stream().forEach(e -> System.out.println(e));

numbers.parallelStream().filter(e -> e%2 ==0)
			         	 .mapToInt(e -> e *2)
                         .collect(Collectors.toList());
System.out.print(numbers);

System.out.print(numbers.stream().anyMatch(e -> e ==2));

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10,1,2,3,1,1,1);
 
System.out.print(numbers.stream().filter(e -> e ==1).count());