# Stream in Java (with examples)

Streams have been introduced in Java 8, and like [lambda expression](https://techwithmaddy.com/java-8-lambda-expression), they represent an attempt to bring functional programming to Java.

## **What is a stream?**

A Stream is an interface part of the `java.util.stream package`. It is a series of objects with several methods that can be executed sequentially to obtain a certain result.

Don’t confuse Streams with Java I/O streams. It is a different topic!

The traits of a stream are:

* **A sequence of elements**: a stream is executed on demand. It doesn’t store any data nor modify the provided data source.
    
* **Data source**: the type of input that a stream can operate on. It takes Collections, Arrays, or Input/Output resources.
    
* **Pipelining**: a stream is a chain of intermediate operations that end with a terminal operation (an operation that cannot be linked to another operation).
    
* **Aggregate operations**: a stream supports many methods that can be linked together (this is discussed after).
    
* **Automatic iterations**: stream operations perform all the iterations in the background.
    

Let’s take a look at the below example:

```java
import java.util.Arrays;
import java.util.List;

public class StreamAPI {

    public static void main(String[] args) {

        List<String> animals = Arrays.asList("dog", "cat", "cow", "Fox", "froG", "fiSh");

        animals
                .stream()
                .filter(a -> a.startsWith("f"))
                .map(String::toLowerCase)
                .sorted()
                .forEach(System.out::println);

    }
}
```

The output is:

```plaintext
fish
frog
```

In the code above:

1. You create a List of Strings called `animals`. This list of animals has a dog, a cat, a cow, a Fox, a froG, and a fiSh. Some letters have been written into capitals on purpose to better showcase what you’re trying to achieve.
    
2. You perform a sequence of operations. First, we use the `filter()` method to say that we only want those animals that start with the letter “f”.
    
3. You use the `map()` to turn those animals into lowercase.
    
4. You use the `sorted()` method to put them in their natural order.
    
5. In the end, we print them.
    

In short, this whole operation says “Please Java, give me a stream of those animals that start with f, lowercase and in alphabetical order”. The uppercase letters in frog and fish get converted into lowercase letters.

## Intermediate and terminal operations

In the following code snippet above:

```java
import java.util.Arrays;
import java.util.List;

public class StreamAPI {

    public static void main(String[] args) {

        List<String> animals = Arrays.asList("dog", "cat", "cow", "Fox", "froG", "fiSh");

        animals
                .stream()
                .filter(a -> a.startsWith("f"))
                .map(String::toLowerCase)
                .sorted()
                .forEach(System.out::println);

    }
}
```

There are intermediate and terminal operations.

## Intermediate operation

Intermediate operations can be connected and return a stream as a result.

Intermediate operations are lazily loaded, meaning they are stored in the memory and only get executed when the terminal operation is called at the end of the pipeline.

Examples of intermediate operations are:

* `Filter`: the filter method `retrieves` only certain elements based on given criteria. We used this method to fetch only those animals that start with the letter “f”.
    
* `Map`: the map method is used to change the elements of a stream by applying a function. Before, we used the `toLowerCase()` method reference to convert the elements into lowercase letters, and indeed, you got frog and fish in lowercase.
    
* `Sorted`: the sorted method sorts the elements in their natural order. Indeed, the program above printed fish first and frog after.
    
* `Limit`: it simply returns a stream that contains the top N elements.
    

## Terminal operations

Terminal operations cannot be chained together, and they return non-stream values.

They are responsible for producing the end result.

Examples of terminal operations are:

* `ForEach`: this method is used to iterate through each element. You used the `forEach()` to print all the filtered, converted, and sorted animals.
    
* `ToArray`: returns an array containing items of a stream.
    
* `Collect`: used to gather the result of processing.
    
* `Count`: it returns the number of elements in a stream.
    

## Key Takeaways

After reading this article, you'll learn about streams, intermediate and terminal operations.

Continue reading the [Java section](https://techwithmaddy.com/series/java-programming) on this blog to learn more!

Until next time! 😁