Java 8 Stream Examples

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (176K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

---

< Previous Next >

Java 8 Tutorial

---

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(Collectors.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.

---

< Previous Next >

Java 8 Tutorial

---