Introduction

Java 8 introduced the Stream API, which provides a functional approach

to processing sequences of elements. Streams support operations like
filtering, mapping, reducing, and collecting, making it easier to perform
complex data manipulations on collections in a concise, readable, and
efficient way. Streams can work with collections like List, Set, and even
arrays.

In this tutorial, we will cover 15 practical examples of the Java 8 Stream

API.

Table of Contents
1. Example 1: Create a Stream from a List
2. Example 2: Filter Elements in a Stream
3. Example 3: Map Elements in a Stream
4. Example 4: Stream forEach() to Print Elements
5. Example 5: Stream collect() to Convert to a List
6. Example 6: Sort Elements in a Stream
7. Example 7: Reduce a Stream to a Single Value
8. Example 8: Count Elements in a Stream
9. Example 9: Limit the Stream Size
10. Example 10: Skip Elements in a Stream
11. Example 11: FlatMap Example (Flattening Nested Lists)
12. Example 12: Find the First Element in a Stream
13. Example 13: Check if Any Match in a Stream
14. Example 14: Grouping by using Collectors
15. Example 15: Stream Parallel Processing

Example 1: Create a Stream from a List

The most common way to create a stream is by using a collection like
a List.

Code Example

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class CreateStreamExample {

public static void main(String[] args) {
List<String> names = Arrays.asList("Amit", "Deepa", "Rahul",
"Suresh");
 // Create a stream from the list
Stream<String> stream = names.stream();

// Print each element using forEach

stream.forEach(System.out::println);
}
}

Output

Amit
Deepa
Rahul
Suresh

Explanation

 We use names.stream() to create a stream from the list.

 The forEach() method prints each element of the stream.

Example 2: Filter Elements in a Stream

You can filter elements in a stream based on a condition using
the filter() method.

Code Example

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

public class FilterStreamExample {

public static void main(String[] args) {
List<String> names = Arrays.asList("Amit", "Deepa", "Rahul",
"Suresh");

// Filter names that start with 'A'

names.stream()
.filter(name -> name.startsWith("A"))
.forEach(System.out::println);
}
}

Output
Amit

Explanation

 We use the filter() method to keep only the names that start with
"A".

Example 3: Map Elements in a Stream

The map() function is used to transform each element in the stream.

Code Example

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

public class MapStreamExample {

public static void main(String[] args) {
List<String> names = Arrays.asList("Amit", "Deepa", "Rahul",
"Suresh");

// Convert all names to uppercase

names.stream()
.map(String::toUpperCase)
.forEach(System.out::println);
}
}

Output

AMIT
DEEPA
RAHUL
SURESH

Explanation

 The map() function transforms each element to uppercase

using String::toUpperCase.
Example 4: Stream forEach() to Print
Elements
The forEach() method is used to perform an action on each element of
the stream.

Code Example

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

public class StreamForEachExample {

public static void main(String[] args) {
List<String> cities = Arrays.asList("Mumbai", "Delhi",
"Bangalore");

// Print each city

cities.stream().forEach(System.out::println);
}
}

Output

Mumbai
Delhi
Bangalore

Explanation

 The forEach() method applies System.out::println to print each

element of the stream.

Example 5: Stream collect() to Convert to

a List
The collect() method collects the stream's elements into a collection
like a List.

Code Example

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class CollectStreamExample {

public static void main(String[] args) {
List<String> names = Arrays.asList("Amit", "Deepa", "Rahul",
"Suresh");

// Collect names that start with 'D' into a List

List<String> filteredNames = names.stream()
.filter(name ->
name.startsWith("D"))
.collect(Collectors.toList());

System.out.println(filteredNames);
}
}

Output

[Deepa]

Explanation

 The collect(Collectors.toList()) collects the filtered names

into a new list.

Example 6: Sort Elements in a Stream

The sorted() method sorts the elements of the stream.

Code Example

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

public class SortedStreamExample {

public static void main(String[] args) {
List<String> names = Arrays.asList("Suresh", "Amit", "Deepa",
"Rahul");

// Sort and print names

names.stream()
.sorted()
.forEach(System.out::println);
}
}
Output

Amit
Deepa
Rahul
Suresh

Explanation

 The sorted() method sorts the names in natural order (alphabetical

order).

Example 7: Reduce a Stream to a Single

Value
The reduce() method is used to reduce a stream to a single value.

Code Example

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

public class ReduceStreamExample {

public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// Sum of all numbers using reduce()

int sum = numbers.stream()
.reduce(0, (a, b) -> a + b);

System.out.println("Sum: " + sum);

}
}

Output

Sum: 15

Explanation

 The reduce() method adds all elements of the stream, starting with
0.
Example 8: Count Elements in a Stream
The count() method returns the number of elements in the stream.

Code Example

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

public class CountStreamExample {

public static void main(String[] args) {
List<String> cities = Arrays.asList("Mumbai", "Delhi",
"Bangalore");

// Count the number of cities

long count = cities.stream().count();

System.out.println("Total cities: " + count);

}
}

Output

Total cities: 3

Explanation

 The count() method returns the total number of elements in the

stream.

Example 9: Limit the Stream Size

The limit() method limits the number of elements in the stream.

Code Example

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

public class LimitStreamExample {

public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

// Limit the stream to 3 elements

numbers.stream()
 .limit(3)
.forEach(System.out::println);
}
}

Output

1
2
3

Explanation

 The limit() method limits the stream to the first 3 elements.

Example 10: Skip Elements in a Stream

The skip() method skips the first n elements in a stream.

Code Example

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

public class SkipStreamExample {

public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

// Skip the first 2 elements

numbers.stream()
.skip(2)
.forEach(System.out::println);
}
}

Output

3
4
5
6

Explanation
  The skip() method skips the first 2 elements and processes the
remaining ones.

Example 11: FlatMap Example (Flattening

Nested Lists)
The flatMap() method is used to flatten nested collections like lists of
lists.

Code Example

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

public class FlatMapStreamExample {

public static void main(String[] args) {
List<List<String>> nestedList = Arrays.asList(
Arrays.asList("Amit", "Rahul"),
Arrays.asList("Deepa", "Suresh")
);

// Flatten the nested list and print all names

nestedList.stream()
.flatMap(List::stream)

.forEach(System.out::println);
}
}

Output

Amit
Rahul
Deepa
Suresh

Explanation

 The flatMap() method is used to flatten the nested lists into a

single stream of names.
Example 12: Find the First Element in a
Stream
The findFirst() method returns the first element of the stream.

Code Example

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

public class FindFirstStreamExample {

public static void main(String[] args) {
List<String> names = Arrays.asList("Amit", "Deepa", "Rahul",
"Suresh");

// Find the first name in the list

String firstName = names.stream().findFirst().orElse("No name");

System.out.println("First name: " + firstName);

}
}

Output

First name: Amit

Explanation

 The findFirst() method returns the first element of the stream or

a default value if the stream is empty.

Example 13: Check if Any Match in a Stream

The anyMatch() method checks if any element in the stream matches a
condition.

Code Example

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

public class AnyMatchStreamExample {

public static void main(String[] args) {
 List<String> names = Arrays.asList("Amit", "Deepa", "Rahul",
"Suresh");

// Check if any name starts with 'D'

boolean anyMatch = names.stream()
.anyMatch(name -> name.startsWith("D"));

System.out.println("Any name starts with D? " + anyMatch);

}
}

Output

Any name starts with D? true

Explanation

 The anyMatch() method returns true if any element matches the

condition (starting with "D").

Example 14: Grouping by using Collectors

The Collectors.groupingBy() method is used to group elements in a
stream based on a classifier function.

Code Example

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class GroupByStreamExample {

public static void main(String[] args) {
List<String> names = Arrays.asList("Amit", "Deepa", "Rahul",
"Akhil");

// Group names by the first letter

Map<Character, List<String>> groupedByLetter = names.stream()
.collect(Collec
tors.groupingBy(name -> name.charAt(0)));

System.out.println(groupedByLetter);
}
}
Output

{A=[Amit, Akhil], D=[Deepa], R=[Rahul]}

Explanation

 The groupingBy() method groups the names by their first

character.

Example 15: Stream Parallel Processing

The parallelStream() method allows processing the stream in parallel,
enabling multi-threading.

Code Example

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

public class ParallelStreamExample {

public static void main(String[] args) {
List<String> names = Arrays.asList("Amit", "Deepa", "Rahul",
"Suresh");

// Process names in parallel

names.parallelStream().forEach(name -> System.out.println(name + "
- " + Thread.currentThread().getName()));
}
}

Output (Order might vary)

Amit - ForkJoinPool.commonPool-worker-1
Deepa - main
Rahul - ForkJoinPool.commonPool-worker-3
Suresh - ForkJoinPool.commonPool-worker-2

Explanation

 The parallelStream() method enables parallel processing of

elements, which can improve performance for large datasets.
Conclusion
The Java 8 Stream API provides powerful and flexible ways to work with
collections and data streams. These 15 examples cover common
operations like filtering, mapping, reducing, and collecting elements.
Streams simplify the code, making it more readable and concise, and they
allow developers to harness functional programming techniques in Java.