Table of Contents

1. Introduction to Stream API
2. Stream Creation
3. Intermediate Operations
4. Terminal Operations
5. Collectors
6. Parallel Streams
7. Advanced Stream Operations
8. Best Practices

Introduction to Stream API

The Stream API, introduced in Java 8, provides a functional approach to process sequences of elements. It enables declarative processing of collections and supports parallel execution.

Key Characteristics

• Not a data structure - doesn't store elements
• Functional in nature - doesn't modify source data
• Lazy evaluation - operations are performed only when needed
• Parallelizable - can process elements in parallel

Stream vs Collection

import java.util.*; import java.util.stream.*; public class StreamVsCollection { public static void main(String[] args) { List<String> names = Arrays.asList("John", "Jane", "Jack", "Doe"); // Traditional approach (imperative) System.out.println("=== Traditional Approach ==="); List<String> filteredNames = new ArrayList<>(); for (String name : names) { if (name.startsWith("J")) { filteredNames.add(name.toUpperCase()); } } System.out.println(filteredNames); // Stream approach (declarative) System.out.println("\n=== Stream Approach ==="); List<String> streamResult = names.stream() .filter(name -> name.startsWith("J")) .map(String::toUpperCase) .collect(Collectors.toList()); System.out.println(streamResult); } }

Stream Creation

Different Ways to Create Streams

import java.util.*; import java.util.stream.*; import java.nio.file.*; import java.io.IOException; public class StreamCreation { public static void main(String[] args) { System.out.println("=== Different Ways to Create Streams ==="); // 1. From Collection List<String> list = Arrays.asList("A", "B", "C"); Stream<String> listStream = list.stream(); System.out.println("From List: " + listStream.count() + " elements"); // 2. From Array String[] array = {"X", "Y", "Z"}; Stream<String> arrayStream = Arrays.stream(array); System.out.println("From Array: " + arrayStream.count() + " elements"); // 3. Using Stream.of() Stream<String> directStream = Stream.of("Apple", "Banana", "Cherry"); System.out.println("Direct stream: " + directStream.count() + " elements"); // 4. Using Stream.builder() Stream.Builder<String> builder = Stream.builder(); builder.add("First"); builder.add("Second"); builder.add("Third"); Stream<String> builtStream = builder.build(); System.out.println("Built stream: " + builtStream.count() + " elements"); // 5. Using Stream.generate() Stream<String> generatedStream = Stream.generate(() -> "Hello") .limit(3); System.out.println("Generated stream: " + generatedStream.count() + " elements"); // 6. Using Stream.iterate() Stream<Integer> iteratedStream = Stream.iterate(1, n -> n * 2) .limit(5); System.out.println("Iterated stream: " + iteratedStream.collect(Collectors.toList())); // 7. From File try { Stream<String> fileStream = Files.lines(Paths.get("example.txt")); System.out.println("File stream created"); fileStream.close(); } catch (IOException e) { System.out.println("File not found - this is expected in demo"); } // 8. Primitive Streams IntStream intStream = IntStream.range(1, 6); LongStream longStream = LongStream.rangeClosed(1, 5); DoubleStream doubleStream = DoubleStream.of(1.1, 2.2, 3.3); System.out.println("IntStream: " + intStream.sum()); System.out.println("DoubleStream: " + doubleStream.sum()); } }

Empty and Concatenated Streams

import java.util.stream.*; public class SpecialStreams { public static void main(String[] args) { // Empty stream Stream<String> emptyStream = Stream.empty(); System.out.println("Empty stream count: " + emptyStream.count()); // Concatenating streams Stream<String> stream1 = Stream.of("A", "B", "C"); Stream<String> stream2 = Stream.of("X", "Y", "Z"); Stream<String> concatenated = Stream.concat(stream1, stream2); System.out.println("Concatenated stream: " + concatenated.collect(Collectors.toList())); // Stream from Optional Optional<String> optional = Optional.of("Hello"); Stream<String> optionalStream = optional.stream(); System.out.println("Optional stream: " + optionalStream.collect(Collectors.toList())); Optional<String> emptyOptional = Optional.empty(); Stream<String> emptyOptionalStream = emptyOptional.stream(); System.out.println("Empty optional stream count: " + emptyOptionalStream.count()); } }

Intermediate Operations

Filtering Operations

import java.util.*; import java.util.stream.*; public class FilteringOperations { public static void main(String[] args) { List<String> names = Arrays.asList("John", "Jane", "Jack", "Doe", "Sarah", "Mike"); List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); System.out.println("Original names: " + names); System.out.println("Original numbers: " + numbers); // filter() - elements matching predicate List<String> jNames = names.stream() .filter(name -> name.startsWith("J")) .collect(Collectors.toList()); System.out.println("\nNames starting with 'J': " + jNames); // distinct() - remove duplicates List<String> withDuplicates = Arrays.asList("A", "B", "A", "C", "B", "D"); List<String> distinct = withDuplicates.stream() .distinct() .collect(Collectors.toList()); System.out.println("Distinct elements: " + distinct); // limit() - first n elements List<String> firstThree = names.stream() .limit(3) .collect(Collectors.toList()); System.out.println("First 3 names: " + firstThree); // skip() - skip first n elements List<String> skipFirstTwo = names.stream() .skip(2) .collect(Collectors.toList()); System.out.println("Skip first 2: " + skipFirstTwo); // takeWhile() - take elements while predicate is true (Java 9+) List<Integer> takeWhile = numbers.stream() .takeWhile(n -> n < 5) // Take while number is less than 5 .collect(Collectors.toList()); System.out.println("Take while < 5: " + takeWhile); // dropWhile() - drop elements while predicate is true (Java 9+) List<Integer> dropWhile = numbers.stream() .dropWhile(n -> n < 5) // Drop while number is less than 5 .collect(Collectors.toList()); System.out.println("Drop while < 5: " + dropWhile); } }

Mapping Operations

import java.util.*; import java.util.stream.*; class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } @Override public String toString() { return name + "(" + age + ")"; } } public class MappingOperations { public static void main(String[] args) { List<Person> people = Arrays.asList( new Person("John", 25), new Person("Jane", 30), new Person("Jack", 35), new Person("Doe", 28) ); List<String> names = Arrays.asList("apple", "banana", "cherry"); List<List<String>> nestedLists = Arrays.asList( Arrays.asList("A", "B"), Arrays.asList("C", "D", "E"), Arrays.asList("F") ); System.out.println("Original people: " + people); // map() - transform each element List<String> personNames = people.stream() .map(Person::getName) .collect(Collectors.toList()); System.out.println("\nPerson names: " + personNames); List<Integer> nameLengths = names.stream() .map(String::length) .collect(Collectors.toList()); System.out.println("Name lengths: " + nameLengths); // flatMap() - flatten nested structures List<String> flattened = nestedLists.stream() .flatMap(List::stream) .collect(Collectors.toList()); System.out.println("Flattened list: " + flattened); // mapToInt(), mapToLong(), mapToDouble() - primitive specialization IntStream ages = people.stream() .mapToInt(Person::getAge); System.out.println("Ages: " + ages.sum()); // peek() - perform action without modifying (debugging) List<String> processedNames = names.stream() .peek(name -> System.out.println("Processing: " + name)) .map(String::toUpperCase) .peek(name -> System.out.println("Converted to: " + name)) .collect(Collectors.toList()); System.out.println("Final result: " + processedNames); } }

Sorting Operations

import java.util.*; import java.util.stream.*; public class SortingOperations { public static void main(String[] args) { List<String> names = Arrays.asList("John", "Jane", "Jack", "Alice", "Bob"); List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 9, 3); List<Person> people = Arrays.asList( new Person("John", 25), new Person("Jane", 30), new Person("Jack", 22), new Person("Alice", 30) ); // Natural order sorting List<String> sortedNames = names.stream() .sorted() .collect(Collectors.toList()); System.out.println("Sorted names: " + sortedNames); // Reverse order sorting List<String> reverseSorted = names.stream() .sorted(Comparator.reverseOrder()) .collect(Collectors.toList()); System.out.println("Reverse sorted: " + reverseSorted); // Custom comparator List<String> lengthSorted = names.stream() .sorted(Comparator.comparing(String::length)) .collect(Collectors.toList()); System.out.println("Sorted by length: " + lengthSorted); // Multiple criteria sorting List<Person> sortedPeople = people.stream() .sorted(Comparator.comparing(Person::getAge) .thenComparing(Person::getName)) .collect(Collectors.toList()); System.out.println("People sorted by age then name: " + sortedPeople); // Complex sorting List<Person> complexSorted = people.stream() .sorted(Comparator.comparing(Person::getAge).reversed() .thenComparing(Person::getName)) .collect(Collectors.toList()); System.out.println("People sorted by age desc then name: " + complexSorted); } }

Terminal Operations

Short-circuiting Terminal Operations

import java.util.*; import java.util.stream.*; public class ShortCircuitingOperations { public static void main(String[] args) { List<String> names = Arrays.asList("John", "Jane", "Jack", "Doe", "Sarah"); List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); System.out.println("Original: " + names); // anyMatch() - true if any element matches predicate boolean hasJ = names.stream() .anyMatch(name -> name.startsWith("J")); System.out.println("\nAny name starts with 'J': " + hasJ); // allMatch() - true if all elements match predicate boolean allHaveJ = names.stream() .allMatch(name -> name.contains("J")); System.out.println("All names contain 'J': " + allHaveJ); // noneMatch() - true if no elements match predicate boolean noneHaveZ = names.stream() .noneMatch(name -> name.contains("Z")); System.out.println("No names contain 'Z': " + noneHaveZ); // findFirst() - first element in stream Optional<String> first = names.stream() .filter(name -> name.startsWith("J")) .findFirst(); System.out.println("First name starting with 'J': " + first.orElse("None")); // findAny() - any element (useful in parallel streams) Optional<String> any = names.stream() .filter(name -> name.length() > 3) .findAny(); System.out.println("Any name with length > 3: " + any.orElse("None")); // Demonstrating short-circuiting behavior Optional<Integer> firstEven = numbers.stream() .filter(n -> { System.out.println("Checking: " + n); return n % 2 == 0; }) .findFirst(); System.out.println("First even (short-circuiting): " + firstEven.get()); } }

Reduction Operations

import java.util.*; import java.util.stream.*; public class ReductionOperations { public static void main(String[] args) { List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); List<String> words = Arrays.asList("Hello", "World", "Stream", "API"); System.out.println("Numbers: " + numbers); System.out.println("Words: " + words); // count() - number of elements long count = numbers.stream().count(); System.out.println("\nCount: " + count); // min() and max() Optional<Integer> min = numbers.stream().min(Integer::compare); Optional<Integer> max = numbers.stream().max(Integer::compare); System.out.println("Min: " + min.orElse(-1)); System.out.println("Max: " + max.orElse(-1)); // reduce() - custom reduction Optional<Integer> sum = numbers.stream() .reduce(Integer::sum); System.out.println("Sum: " + sum.orElse(0)); Integer product = numbers.stream() .reduce(1, (a, b) -> a * b); System.out.println("Product: " + product); // Complex reduction String concatenated = words.stream() .reduce("", (a, b) -> a + " " + b); System.out.println("Concatenated: " + concatenated.trim()); // Statistical operations IntSummaryStatistics stats = numbers.stream() .mapToInt(Integer::intValue) .summaryStatistics(); System.out.println("\nStatistics:"); System.out.println(" Count: " + stats.getCount()); System.out.println(" Sum: " + stats.getSum()); System.out.println(" Min: " + stats.getMin()); System.out.println(" Max: " + stats.getMax()); System.out.println(" Average: " + stats.getAverage()); // forEach() - perform action on each element System.out.println("\nPrinting elements:"); numbers.stream() .forEach(n -> System.out.print(n + " ")); System.out.println(); // forEachOrdered() - maintain order in parallel streams System.out.println("Printing in order:"); numbers.parallelStream() .forEachOrdered(n -> System.out.print(n + " ")); System.out.println(); // toArray() - convert to array Integer[] numberArray = numbers.stream().toArray(Integer[]::new); System.out.println("Array: " + Arrays.toString(numberArray)); } }

Collectors

Built-in Collectors

import java.util.*; import java.util.stream.*; import static java.util.stream.Collectors.*; public class BuiltInCollectors { public static void main(String[] args) { List<Person> people = Arrays.asList( new Person("John", 25), new Person("Jane", 30), new Person("Jack", 35), new Person("Alice", 25), new Person("Bob", 30) ); List<String> names = Arrays.asList("John", "Jane", "Jack", "Alice", "Bob"); System.out.println("People: " + people); // toList() List<String> nameList = people.stream() .map(Person::getName) .collect(toList()); System.out.println("\nNames list: " + nameList); // toSet() Set<Integer> ageSet = people.stream() .map(Person::getAge) .collect(toSet()); System.out.println("Age set: " + ageSet); // toCollection() - specific collection type LinkedList<String> linkedNames = people.stream() .map(Person::getName) .collect(toCollection(LinkedList::new)); System.out.println("Linked list: " + linkedNames); // toMap() Map<String, Integer> nameToAge = people.stream() .collect(toMap(Person::getName, Person::getAge)); System.out.println("Name to age map: " + nameToAge); // groupingBy() Map<Integer, List<Person>> peopleByAge = people.stream() .collect(groupingBy(Person::getAge)); System.out.println("Grouped by age: " + peopleByAge); // partitioningBy() Map<Boolean, List<Person>> partitioned = people.stream() .collect(partitioningBy(p -> p.getAge() > 28)); System.out.println("Partitioned by age > 28: " + partitioned); // joining() String joinedNames = names.stream() .collect(joining(", ", "[", "]")); System.out.println("Joined names: " + joinedNames); // counting() Long count = people.stream() .collect(counting()); System.out.println("Count: " + count); // summingInt(), averagingInt(), summarizingInt() Integer totalAge = people.stream() .collect(summingInt(Person::getAge)); System.out.println("Total age: " + totalAge); Double averageAge = people.stream() .collect(averagingInt(Person::getAge)); System.out.println("Average age: " + averageAge); IntSummaryStatistics ageStats = people.stream() .collect(summarizingInt(Person::getAge)); System.out.println("Age statistics: " + ageStats); // maxBy(), minBy() Optional<Person> oldest = people.stream() .collect(maxBy(Comparator.comparing(Person::getAge))); System.out.println("Oldest: " + oldest.orElse(null)); // mapping() - map before collecting Set<String> upperCaseNames = people.stream() .collect(mapping(Person::getName, toSet())) .stream() .map(String::toUpperCase) .collect(toSet()); System.out.println("Upper case names: " + upperCaseNames); // collectingAndThen() - perform final transformation String unmodifiableNames = people.stream() .map(Person::getName) .collect(collectingAndThen(toList(), list -> Collections.unmodifiableList(list).toString())); System.out.println("Unmodifiable list string: " + unmodifiableNames); } }

Custom Collectors

import java.util.*; import java.util.function.*; import java.util.stream.*; class CustomCollectors { // Custom collector to join strings with prefix and suffix public static Collector<String, ?, String> joiningWithFormat( String delimiter, String prefix, String suffix) { return Collector.of( () -> new StringJoiner(delimiter, prefix, suffix), StringJoiner::add, StringJoiner::merge, StringJoiner::toString ); } // Custom collector to calculate average of integers public static Collector<Integer, ?, Double> averagingInt() { return Collector.of( () -> new long[2], // [sum, count] (acc, value) -> { acc[0] += value; acc[1]++; }, (acc1, acc2) -> { acc1[0] += acc2[0]; acc1[1] += acc2[1]; return acc1; }, acc -> acc[1] == 0 ? 0.0 : (double) acc[0] / acc[1] ); } // Custom collector to find most frequent element public static <T> Collector<T, ?, Optional<T>> mostFrequent() { return Collector.of( HashMap<T, Integer>::new, (map, element) -> map.merge(element, 1, Integer::sum), (map1, map2) -> { map2.forEach((key, value) -> map1.merge(key, value, Integer::sum)); return map1; }, map -> map.entrySet().stream() .max(Map.Entry.comparingByValue()) .map(Map.Entry::getKey) ); } } public class CustomCollectorsDemo { public static void main(String[] args) { List<String> names = Arrays.asList("John", "Jane", "John", "Alice", "Bob", "Alice", "Alice"); List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); // Using custom joining collector String formatted = names.stream() .collect(CustomCollectors.joiningWithFormat(" | ", ">>> ", " <<<")); System.out.println("Formatted join: " + formatted); // Using custom average collector Double average = numbers.stream() .collect(CustomCollectors.averagingInt()); System.out.println("Custom average: " + average); // Using most frequent collector Optional<String> mostFrequent = names.stream() .collect(CustomCollectors.mostFrequent()); System.out.println("Most frequent: " + mostFrequent.orElse("None")); // Complex custom collector: group by and transform Collector<Person, ?, Map<Integer, String>> ageToNames = Collector.of( HashMap::new, (map, person) -> map.merge(person.getAge(), person.getName(), (oldVal, newVal) -> oldVal + ", " + newVal), (map1, map2) -> { map2.forEach((age, name) -> map1.merge(age, name, (oldVal, newVal) -> oldVal + ", " + newVal)); return map1; } ); List<Person> people = Arrays.asList( new Person("John", 25), new Person("Jane", 30), new Person("Jack", 25), new Person("Alice", 30) ); Map<Integer, String> ageToNameMap = people.stream() .collect(ageToNames); System.out.println("Age to names: " + ageToNameMap); } }

Parallel Streams

Parallel Stream Operations

import java.util.*; import java.util.stream.*; import java.util.concurrent.*; public class ParallelStreams { public static void main(String[] args) { List<Integer> numbers = IntStream.range(1, 101) .boxed() .collect(Collectors.toList()); System.out.println("=== Sequential vs Parallel Streams ==="); // Sequential processing long sequentialStart = System.currentTimeMillis(); List<Integer> sequentialSquares = numbers.stream() .map(n -> { try { Thread.sleep(10); } catch (InterruptedException e) {} // Simulate work return n * n; }) .collect(Collectors.toList()); long sequentialTime = System.currentTimeMillis() - sequentialStart; // Parallel processing long parallelStart = System.currentTimeMillis(); List<Integer> parallelSquares = numbers.parallelStream() .map(n -> { try { Thread.sleep(10); } catch (InterruptedException e) {} // Simulate work return n * n; }) .collect(Collectors.toList()); long parallelTime = System.currentTimeMillis() - parallelStart; System.out.println("Sequential time: " + sequentialTime + "ms"); System.out.println("Parallel time: " + parallelTime + "ms"); System.out.println("Speedup: " + (double) sequentialTime / parallelTime + "x"); // Ordering in parallel streams System.out.println("\n=== Ordering Considerations ==="); List<Integer> unordered = numbers.parallelStream() .map(n -> n * 2) .collect(Collectors.toList()); System.out.println("Parallel result size: " + unordered.size()); // forEach vs forEachOrdered System.out.println("Parallel forEach (unordered):"); numbers.parallelStream() .limit(5) .forEach(n -> System.out.print(n + " ")); System.out.println(); System.out.println("Parallel forEachOrdered:"); numbers.parallelStream() .limit(5) .forEachOrdered(n -> System.out.print(n + " ")); System.out.println(); // When to use parallel streams demonstrateParallelUseCases(); } public static void demonstrateParallelUseCases() { System.out.println("\n=== Appropriate Use Cases for Parallel Streams ==="); // Good: CPU-intensive operations long sum = LongStream.range(1, 10_000_000) .parallel() .filter(n -> n % 2 == 0) .sum(); System.out.println("Sum of even numbers: " + sum); // Good: Independent operations List<String> words = Arrays.asList("apple", "banana", "cherry", "date", "elderberry"); Map<Integer, Long> lengthCount = words.parallelStream() .collect(Collectors.groupingByConcurrent( String::length, Collectors.counting() )); System.out.println("Word length counts: " + lengthCount); // Bad: Stateful operations (can cause issues) List<Integer> problematic = Collections.synchronizedList(new ArrayList<>()); IntStream.range(1, 1000) .parallel() .filter(n -> n % 2 == 0) .forEach(problematic::add); // Stateful - can cause contention System.out.println("Problematic result size: " + problematic.size()); } }

Parallel Stream Considerations

import java.util.*; import java.util.concurrent.*; import java.util.stream.*; public class ParallelStreamConsiderations { public static void demonstrateConsiderations() { System.out.println("=== Parallel Stream Considerations ==="); // 1. Common ForkJoinPool usage System.out.println("\n1. Common ForkJoinPool:"); long commonPoolParallelism = ForkJoinPool.commonPool().getParallelism(); System.out.println("Common pool parallelism: " + commonPoolParallelism); // 2. Custom ForkJoinPool System.out.println("\n2. Custom ForkJoinPool:"); ForkJoinPool customPool = new ForkJoinPool(4); try { customPool.submit(() -> { IntStream.range(1, 100) .parallel() .forEach(n -> System.out.println(Thread.currentThread().getName())); }).get(); } catch (Exception e) { e.printStackTrace(); } // 3. Ordering issues System.out.println("\n3. Ordering in parallel streams:"); List<Integer> numbers = IntStream.range(1, 11).boxed().collect(Collectors.toList()); System.out.println("Sequential order:"); numbers.stream() .map(n -> n * 2) .forEach(n -> System.out.print(n + " ")); System.out.println(); System.out.println("Parallel order (may vary):"); numbers.parallelStream() .map(n -> n * 2) .forEach(n -> System.out.print(n + " ")); System.out.println(); // 4. Stateful operations problem System.out.println("\n4. Stateful operations issue:"); List<Integer> statefulResult = new ArrayList<>(); IntStream.range(1, 1000) .parallel() .filter(n -> n % 2 == 0) .forEach(statefulResult::add); // Unsafe! System.out.println("Stateful result size (may be incorrect): " + statefulResult.size()); // 5. Safe alternative List<Integer> safeResult = IntStream.range(1, 1000) .parallel() .filter(n -> n % 2 == 0) .boxed() .collect(Collectors.toList()); // Safe collection System.out.println("Safe result size: " + safeResult.size()); // 6. When NOT to use parallel streams System.out.println("\n6. When parallel streams may hurt performance:"); // Small datasets long smallSeqTime = measureTime(() -> IntStream.range(1, 1000).sum()); long smallParTime = measureTime(() -> IntStream.range(1, 1000).parallel().sum()); System.out.println("Small dataset - Sequential: " + smallSeqTime + "ns"); System.out.println("Small dataset - Parallel: " + smallParTime + "ns"); System.out.println("Parallel overhead evident for small datasets"); } private static long measureTime(Runnable operation) { long start = System.nanoTime(); operation.run(); return System.nanoTime() - start; } public static void main(String[] args) { demonstrateConsiderations(); } }

Advanced Stream Operations

Advanced Stream Patterns

import java.util.*; import java.util.stream.*; import java.util.function.*; public class AdvancedStreamPatterns { public static void demonstratePatterns() { System.out.println("=== Advanced Stream Patterns ==="); List<Person> people = Arrays.asList( new Person("John", 25), new Person("Jane", 30), new Person("Jack", 35), new Person("Alice", 25), new Person("Bob", 30), new Person("Charlie", 40) ); // Pattern 1: Chaining Optional with Stream System.out.println("\n1. Optional with Stream:"); Optional<String> firstLongName = people.stream() .map(Person::getName) .filter(name -> name.length() > 4) .findFirst(); firstLongName.ifPresent(name -> System.out.println("First long name: " + name)); // Pattern 2: Stream of Optionals System.out.println("\n2. Stream of Optionals:"); List<Optional<String>> optionalNames = Arrays.asList( Optional.of("John"), Optional.empty(), Optional.of("Jane"), Optional.empty(), Optional.of("Alice") ); List<String> presentNames = optionalNames.stream() .flatMap(Optional::stream) .collect(Collectors.toList()); System.out.println("Present names: " + presentNames); // Pattern 3: Infinite streams with limit System.out.println("\n3. Infinite streams:"); List<Double> randomNumbers = Stream.generate(Math::random) .limit(5) .collect(Collectors.toList()); System.out.println("Random numbers: " + randomNumbers); // Pattern 4: Stream.iterate for sequences System.out.println("\n4. Stream.iterate for sequences:"); List<Integer> fibonacci = Stream.iterate(new int[]{0, 1}, fib -> new int[]{fib[1], fib[0] + fib[1]}) .limit(10) .map(fib -> fib[0]) .collect(Collectors.toList()); System.out.println("Fibonacci: " + fibonacci); // Pattern 5: Complex grouping System.out.println("\n5. Complex grouping:"); Map<String, List<Person>> groupedByAgeRange = people.stream() .collect(Collectors.groupingBy( person -> { int age = person.getAge(); if (age < 30) return "Young"; else if (age < 40) return "Middle"; else return "Senior"; } )); System.out.println("Grouped by age range: " + groupedByAgeRange); // Pattern 6: Teeing collector (Java 12+) System.out.println("\n6. Teeing collector (conceptual):"); // Collectors.teeing() allows two collectors to work simultaneously // Pattern 7: Custom reduction with complex logic System.out.println("\n7. Custom complex reduction:"); String analysis = people.stream() .collect(Collectors.teeing( Collectors.averagingInt(Person::getAge), Collectors.mapping(Person::getName, Collectors.joining(", ")), (avgAge, names) -> String.format("Average age: %.1f, Names: %s", avgAge, names) )); System.out.println("Analysis: " + analysis); } // Pattern: Stream pipeline with exception handling public static List<Integer> parseNumbersSafely(List<String> numberStrings) { return numberStrings.stream() .flatMap(str -> { try { return Stream.of(Integer.parseInt(str)); } catch (NumberFormatException e) { System.err.println("Invalid number: " + str); return Stream.empty(); } }) .collect(Collectors.toList()); } // Pattern: Lazy evaluation demonstration public static void demonstrateLazyEvaluation() { System.out.println("\n=== Lazy Evaluation ==="); List<String> names = Arrays.asList("John", "Jane", "Jack", "Doe"); System.out.println("Without terminal operation (nothing happens):"); Stream<String> intermediate = names.stream() .filter(name -> { System.out.println("Filtering: " + name); return name.startsWith("J"); }) .map(name -> { System.out.println("Mapping: " + name); return name.toUpperCase(); }); System.out.println("Intermediate operations defined but not executed"); System.out.println("\nWith terminal operation (execution happens):"); List<String> result = intermediate.collect(Collectors.toList()); System.out.println("Result: " + result); } public static void main(String[] args) { demonstratePatterns(); demonstrateLazyEvaluation(); // Test safe number parsing List<String> mixedInput = Arrays.asList("1", "2", "abc", "4", "5xyz"); List<Integer> parsedNumbers = parseNumbersSafely(mixedInput); System.out.println("\nSafe parsing result: " + parsedNumbers); } }

Real-World Stream Examples

import java.util.*; import java.util.stream.*; import java.time.*; import java.time.temporal.ChronoUnit; class Transaction { private String id; private double amount; private LocalDateTime timestamp; private String type; // "DEBIT" or "CREDIT" public Transaction(String id, double amount, LocalDateTime timestamp, String type) { this.id = id; this.amount = amount; this.timestamp = timestamp; this.type = type; } // Getters public String getId() { return id; } public double getAmount() { return amount; } public LocalDateTime getTimestamp() { return timestamp; } public String getType() { return type; } @Override public String toString() { return String.format("Transaction{id='%s', amount=%.2f, type='%s'}", id, amount, type); } } public class RealWorldStreamExamples { public static void financialAnalysis() { System.out.println("=== Financial Transaction Analysis ==="); List<Transaction> transactions = Arrays.asList( new Transaction("T1", 100.0, LocalDateTime.now().minusDays(1), "CREDIT"), new Transaction("T2", 50.0, LocalDateTime.now().minusHours(6), "DEBIT"), new Transaction("T3", 200.0, LocalDateTime.now().minusHours(2), "CREDIT"), new Transaction("T4", 75.0, LocalDateTime.now().minusMinutes(30), "DEBIT"), new Transaction("T5", 150.0, LocalDateTime.now().minusMinutes(10), "CREDIT") ); // Total credit amount double totalCredit = transactions.stream() .filter(t -> "CREDIT".equals(t.getType())) .mapToDouble(Transaction::getAmount) .sum(); System.out.println("Total credit: $" + totalCredit); // Total debit amount double totalDebit = transactions.stream() .filter(t -> "DEBIT".equals(t.getType())) .mapToDouble(Transaction::getAmount) .sum(); System.out.println("Total debit: $" + totalDebit); // Net balance double netBalance = totalCredit - totalDebit; System.out.println("Net balance: $" + netBalance); // Recent transactions (last 3 hours) List<Transaction> recent = transactions.stream() .filter(t -> t.getTimestamp().isAfter(LocalDateTime.now().minusHours(3))) .collect(Collectors.toList()); System.out.println("Recent transactions: " + recent); // Transaction statistics DoubleSummaryStatistics stats = transactions.stream() .mapToDouble(Transaction::getAmount) .summaryStatistics(); System.out.println("Transaction stats: " + stats); } public static void employeeManagement() { System.out.println("\n=== Employee Management System ==="); class Employee { String name; String department; double salary; int experience; Employee(String name, String department, double salary, int experience) { this.name = name; this.department = department; this.salary = salary; this.experience = experience; } // Getters String getName() { return name; } String getDepartment() { return department; } double getSalary() { return salary; } int getExperience() { return experience; } } List<Employee> employees = Arrays.asList( new Employee("John", "Engineering", 75000, 3), new Employee("Jane", "Engineering", 85000, 5), new Employee("Bob", "Marketing", 60000, 2), new Employee("Alice", "Marketing", 65000, 4), new Employee("Charlie", "HR", 55000, 1), new Employee("Diana", "HR", 60000, 3) ); // Department-wise average salary Map<String, Double> avgSalaryByDept = employees.stream() .collect(Collectors.groupingBy( Employee::getDepartment, Collectors.averagingDouble(Employee::getSalary) )); System.out.println("Average salary by department: " + avgSalaryByDept); // Top 2 earners in each department Map<String, List<Employee>> topEarnersByDept = employees.stream() .collect(Collectors.groupingBy( Employee::getDepartment, Collectors.collectingAndThen( Collectors.toList(), list -> list.stream() .sorted(Comparator.comparing(Employee::getSalary).reversed()) .limit(2) .collect(Collectors.toList()) ) )); System.out.println("Top earners by department: " + topEarnersByDept); // Employees eligible for promotion (experience > 3 years) List<Employee> promotionEligible = employees.stream() .filter(e -> e.getExperience() > 3) .sorted(Comparator.comparing(Employee::getExperience).reversed()) .collect(Collectors.toList()); System.out.println("Promotion eligible: " + promotionEligible.stream().map(Employee::getName).collect(Collectors.toList())); // Salary budget by department Map<String, Double> budgetByDept = employees.stream() .collect(Collectors.groupingBy( Employee::getDepartment, Collectors.summingDouble(Employee::getSalary) )); System.out.println("Budget by department: " + budgetByDept); } public static void dataProcessingPipeline() { System.out.println("\n=== Data Processing Pipeline ==="); List<String> rawData = Arrays.asList( "user1,25,engineer", "user2,30,manager", "user3,22,intern", "user4,35,engineer", "user5,28,designer", "INVALID_DATA", "user6,40,manager" ); // Complete data processing pipeline Map<String, DoubleSummaryStatistics> roleStats = rawData.stream() .filter(line -> line.contains(",")) // Filter valid lines .map(line -> line.split(",")) // Split into parts .filter(parts -> parts.length == 3) // Ensure correct format .map(parts -> new Object() { // Create anonymous objects String username = parts[0]; int age = Integer.parseInt(parts[1]); String role = parts[2]; }) .filter(user -> user.age >= 18 && user.age <= 65) // Validate age .collect(Collectors.groupingBy( user -> user.role, Collectors.summarizingDouble(user -> user.age) )); System.out.println("Role statistics:"); roleStats.forEach((role, stats) -> System.out.printf(" %s: count=%d, avg=%.1f, min=%d, max=%d%n", role, stats.getCount(), stats.getAverage(), (int)stats.getMin(), (int)stats.getMax())); } public static void main(String[] args) { financialAnalysis(); employeeManagement(); dataProcessingPipeline(); } }

Best Practices

Stream API Best Practices

import java.util.*; import java.util.stream.*; import java.util.function.*; public class StreamBestPractices { public static void demonstrateBestPractices() { System.out.println("=== Stream API Best Practices ==="); List<Person> people = Arrays.asList( new Person("John", 25), new Person("Jane", 30), new Person("Jack", 35), new Person("Alice", 25), new Person("Bob", 30) ); // 1. Prefer method references System.out.println("\n1. Method References:"); List<String> namesWithRef = people.stream() .map(Person::getName) // Good: method reference .collect(Collectors.toList()); List<String> namesWithLambda = people.stream() .map(person -> person.getName()) // Avoid: unnecessary lambda .collect(Collectors.toList()); System.out.println("Names: " + namesWithRef); // 2. Avoid stateful lambda expressions System.out.println("\n2. Stateless Operations:"); // Bad: stateful operation AtomicInteger counter = new AtomicInteger(); List<String> badResult = people.stream() .map(p -> p.getName() + counter.getAndIncrement()) // Stateful! .collect(Collectors.toList()); System.out.println("Stateful result: " + badResult); // Good: stateless operation List<String> goodResult = IntStream.range(0, people.size()) .mapToObj(i -> people.get(i).getName() + i) .collect(Collectors.toList()); System.out.println("Stateless result: " + goodResult); // 3. Use primitive streams for better performance System.out.println("\n3. Primitive Streams:"); int totalAge = people.stream() .mapToInt(Person::getAge) // Better performance .sum(); System.out.println("Total age: " + totalAge); // 4. Avoid nested streams when possible System.out.println("\n4. Avoid Nested Streams:"); List<List<String>> nestedData = Arrays.asList( Arrays.asList("A", "B"), Arrays.asList("C", "D"), Arrays.asList("E", "F") ); // Good: use flatMap List<String> flattened = nestedData.stream() .flatMap(List::stream) .collect(Collectors.toList()); System.out.println("Flattened: " + flattened); // 5. Use collectors for mutable reduction System.out.println("\n5. Proper Collection:"); // Good: use collector Set<String> nameSet = people.stream() .map(Person::getName) .collect(Collectors.toCollection(TreeSet::new)); // Bad: manual collection Set<String> manualSet = new TreeSet<>(); people.stream() .map(Person::getName) .forEach(manualSet::add); // Avoid: manual collection } public static void performanceConsiderations() { System.out.println("\n=== Performance Considerations ==="); // 1. Use parallel streams appropriately List<Integer> largeList = IntStream.range(1, 1_000_000) .boxed() .collect(Collectors.toList()); long start = System.currentTimeMillis(); long sequentialSum = largeList.stream() .mapToInt(Integer::intValue) .sum(); long sequentialTime = System.currentTimeMillis() - start; start = System.currentTimeMillis(); long parallelSum = largeList.parallelStream() .mapToInt(Integer::intValue) .sum(); long parallelTime = System.currentTimeMillis() - start; System.out.println("Sequential sum: " + sequentialSum + " in " + sequentialTime + "ms"); System.out.println("Parallel sum: " + parallelSum + " in " + parallelTime + "ms"); // 2. Avoid unnecessary boxing System.out.println("\n2. Avoid Boxing:"); long primitiveTime = measureTime(() -> IntStream.range(1, 1_000_000).sum()); long boxedTime = measureTime(() -> IntStream.range(1, 1_000_000).boxed() .mapToInt(Integer::intValue).sum()); System.out.println("Primitive stream time: " + primitiveTime + "ns"); System.out.println("Boxed stream time: " + boxedTime + "ns"); } public static void readabilityTips() { System.out.println("\n=== Readability Tips ==="); List<Person> people = Arrays.asList( new Person("John", 25), new Person("Jane", 30), new Person("Jack", 35) ); // Good: break complex streams into steps Predicate<Person> isAdult = p -> p.getAge() >= 18; Function<Person, String> getName = Person::getName; List<String> adultNames = people.stream() .filter(isAdult) .map(getName) .collect(Collectors.toList()); System.out.println("Adult names: " + adultNames); // Use meaningful variable names List<String> namesStartingWithJ = people.stream() .filter(person -> person.getName().startsWith("J")) .map(Person::getName) .sorted() .collect(Collectors.toList()); System.out.println("Names starting with J: " + namesStartingWithJ); } private static long measureTime(Runnable operation) { long start = System.nanoTime(); operation.run(); return System.nanoTime() - start; } public static void commonPitfalls() { System.out.println("\n=== Common Pitfalls ==="); // 1. Reusing streams Stream<String> stream = Stream.of("A", "B", "C"); long count = stream.count(); // stream.forEach(System.out::println); // IllegalStateException! // 2. Infinite streams without limit // Stream.generate(() -> "data").forEach(System.out::println); // Infinite! // 3. Modifying source collection List<String> source = new ArrayList<>(Arrays.asList("A", "B", "C")); List<String> result = source.stream() .peek(item -> { if ("B".equals(item)) { source.add("D"); // Concurrent modification risk! } }) .collect(Collectors.toList()); System.out.println("Modified source size: " + source.size()); } public static void main(String[] args) { demonstrateBestPractices(); performanceConsiderations(); readabilityTips(); commonPitfalls(); } }

Summary

Key Stream API Concepts:

1. Stream Creation: From collections, arrays, generators
2. Intermediate Operations: filter, map, sorted, distinct (lazy)
3. Terminal Operations: collect, forEach, reduce (eager)
4. Collectors: toList, toSet, groupingBy, partitioningBy
5. Parallel Streams: For CPU-intensive operations on large datasets

Best Practices:

• Use method references where possible
• Prefer primitive streams for better performance
• Use parallel streams judiciously
• Avoid stateful operations in streams
• Keep streams readable and maintainable

The Stream API provides a powerful, declarative way to process data in Java, enabling more readable, maintainable, and often more performant code compared to traditional imperative approaches.