What is a Java Stream?
A Stream is a sequence of elements supporting functional-style operations like filtering, mapping, and reducing.
Streams do not modify the original data structure.
They operate lazily, meaning operations are executed only when a terminal operation is applied.
Can be sequential or parallel
Stream Pipeline Structure
A Java Stream Pipeline consists of:
Source - Where the stream comes from (e.g., a List, Set, or Array)
Intermediate Operations - Process and transform elements
Terminal Operation - Produces the final result, closing the stream.
Example of Stream PipelineList<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6); List<Integer> result = numbers.stream() // Step 1: Create Stream .filter(n -> n % 2 == 0) // Step 2: Intermediate Operation .map(n -> n * n) // Step 3: Intermediate Operation .collect(Collectors.toList()); // Step 4: Terminal Operation System.out.println(result);
Flow Diagram to Understand Filters
Understanding StreamsStream Sources
data structure from which the stream originates. This could be a collection, array, file, or range.List<String> list = Arrays.asList("Apple", "Banana", "Cherry"); Stream<String> stream1 = list.stream(); ---------------------------------------------------------------------- String[] array = {"Red", "Green", "Blue"}; Stream<String> stream2 = Arrays.stream(array); ---------------------------------------------------------------------- Stream<String> stream3 = Stream.of("One", "Two", "Three"); ----------------------------------------------------------------------
Intermediate Operation -
Intermediate operations transform a stream without consuming it.
They return another Stream, allowing further operations to be chained. Stream<Integer> filtered = numbers.stream().filter(n -> n > 5); ----------------------------------------------------------------------- Stream<Integer> squared = numbers.stream().map(n -> n * n); ----------------------------------------------------------------------- Stream<String> sorted = list.stream().sorted(); ----------------------------------------------------------------------- Stream<String> sortedDesc = list.stream().sorted(Comparator.reverseOrder()); ----------------------------------------------------------------------- Stream<Integer> uniqueNumbers = numbers.stream().distinct(); ----------------------------------------------------------------------- Stream<String> limited = list.stream().limit(2); ----------------------------------------------------------------------- Stream<String> skipped = list.stream().skip(2); ----------------------------------------------------------------------- List<List<Integer>> listOfLists = Arrays.asList( Arrays.asList(1, 2, 3), Arrays.asList(4, 5, 6) ); List<Integer> flattened = listOfLists.stream() .flatMap(List::stream) .collect(Collectors.toList()); // Output: [1, 2, 3, 4, 5, 6] ------------------------------------------------------------------------
Terminal Operation -
Terminal expressions (or terminal operations) consume the stream and produce a result or side effect. Unlike intermediate operations (which return a stream for further processing), terminal operations close the stream, meaning it cannot be used again.
✅ Consumes the stream – Once a terminal operation is applied, the stream cannot be reused.
✅ Returns a result – Can return a single value, a collection, or perform an action like printing.
✅ Forces execution – Since streams are lazy, terminal operations trigger actual processing.List<String> collected = list.stream().collect(Collectors.toList()); ---------------------------------------------------------------------------------- Set<String> collectedSet = list.stream().collect(Collectors.toSet()); ---------------------------------------------------------------------------------- Map<String, Integer> collectedMap = list.stream().collect(Collectors.toMap(s -> s, String::length)); ---------------------------------------------------------------------------------- list.stream().forEach(System.out::println); ---------------------------------------------------------------------------------- long count = list.stream().filter(s -> s.startsWith("A")).count(); ---------------------------------------------------------------------------------- Optional<String> first = list.stream().findFirst(); Optional<String> any = list.stream().findAny(); ---------------------------------------------------------------------------------- boolean anyMatch = list.stream().anyMatch(s -> s.contains("e")); boolean allMatch = list.stream().allMatch(s -> s.length() > 3); boolean noneMatch = list.stream().noneMatch(s -> s.isEmpty()); --------------------------------------------------------------------------------- Optional<Integer> sum = numbers.stream().reduce((a, b) -> a + b); ---------------------------------------------------------------------------------- int sum = numbers.stream().reduce(0, Integer::sum); ---------------------------------------------------------------------------------- Optional<Integer> min = numbers.stream().min(Integer::compare); Optional<Integer> max = numbers.stream().max(Integer::compare); ----------------------------------------------------------------------------------
Common Implementation
filter() for condition-based filtering.
map() to transform elements.
reduce() for aggregation (sum, max, min).
groupingBy() to classify data.
partitioningBy() for true/false categorization.
sorted() to order elements.
flatMap() to merge multiple collections.
List<String> uppercased = list.stream() .map(String::toUpperCase) .collect(Collectors.toList()); ---------------------------------------------------------------- List<Integer> evens = numbers.stream() .filter(n -> n % 2 == 0) .collect(Collectors.toList()); ----------------------------------------------------------------- // Use groupingBy() when you need multiple groups List<Employee> employees = Arrays.asList( new Employee("Alice", "HR"), new Employee("Bob", "IT"), new Employee("Charlie", "HR"), new Employee("David", "IT"), new Employee("Eve", "Finance") ); // Group employees by department Map<String, List<Employee>> groupedByDepartment = employees.stream() .collect(Collectors.groupingBy(emp -> emp.department)); System.out.println(groupedByDepartment); ------------------------------------------------------------------ // Use of partitioning to group based on condition List<Integer> numbers = Arrays.asList(10, 15, 20, 25, 30); // Partition numbers into even and odd Map<Boolean, List<Integer>> partitionedNumbers = numbers.stream() .collect(Collectors.partitioningBy(num -> num % 2 == 0)); System.out.println(partitionedNumbers); -------------------------------------------------------------------- List<Integer> numbers = Arrays.asList(10, 15, 20, 25, 30); int sum = numbers.stream() .filter(n -> n % 2 == 0) .reduce(0, Integer::sum); ---------------------------------------------------------------------- List<String> names = Arrays.asList("Alice", "Bob", "Charlie"); String result = names.stream() .collect(Collectors.joining(", ")); ----------------------------------------------------------------------------- //Use of flatmap to create a list from list of list List<List<String>> nestedList = Arrays.asList( Arrays.asList("a", "b"), Arrays.asList("c", "d"), Arrays.asList("e", "f") ); List<String> flatList = nestedList.stream() .flatMap(List::stream) .collect(Collectors.toList());Benefits of Using Streams:
Improves Readability – Eliminates verbose loops and enhances code clarity.
Encourages Functional Programming – Uses lambda expressions for concise processing logic.
Optimized Performance – Lazy evaluation and parallel processing reduce execution time for large datasets.
Official Documentation & References
Oracle Java Streams Documentation 🔗 https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html
Java Tutorials by Oracle 🔗 https://docs.oracle.com/javase/tutorial/collections/streams/index.html
Baeldung - Guide to Java Streams 🔗 https://www.baeldung.com/java-8-streams
GeeksforGeeks - Java Streams Guide 🔗 https://www.geeksforgeeks.org/stream-in-java/
