Streams API

🔍 What Is It?

Stream Pipeline = Source + Intermediate Operations + Terminal Operation

Sources:

• →collection.stream(), collection.parallelStream()
• →Arrays.stream(array)
• →Stream.of(elements), Stream.generate(), Stream.iterate()
• →Files.lines(path), IntStream.range(0, 100)

Intermediate Operations (lazy, return Stream):

• →filter(Predicate) — keep elements matching predicate
• →map(Function) — transform each element
• →flatMap(Function) — transform and flatten nested streams
• →distinct() — remove duplicates
• →sorted() / sorted(Comparator) — sort
• →limit(n) / skip(n) — take first n / skip first n
• →peek(Consumer) — debug/side-effect without consuming
• →mapToInt/Long/Double — convert to primitive stream

Terminal Operations (eager, trigger execution):

• →collect(Collector) — accumulate to collection/map/string
• →forEach(Consumer) — side effect for each element
• →count() — count elements
• →findFirst() / findAny() — find element (returns Optional)
• →anyMatch / allMatch / noneMatch(Predicate) — boolean tests
• →reduce(identity, BinaryOperator) — fold to single value
• →min / max(Comparator) — find min/max (returns Optional)
• →toList() — collect to unmodifiable List (Java 16+)

🎯 Why Do We Need It?

Compare imperative vs declarative:

// Imperative (Java 7)
List<String> result = new ArrayList<>();
for (Employee emp : employees) {
    if (emp.isActive() && emp.getSalary().compareTo(threshold) > 0) {
        result.add(emp.getName().toUpperCase());
    }
}
Collections.sort(result);

// Declarative (Java 8+ Streams)
List<String> result = employees.stream()
    .filter(Employee::isActive)
    .filter(emp -> emp.getSalary().compareTo(threshold) > 0)
    .map(Employee::getName)
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());

The stream version is shorter, reads like English, and is easier to modify.

🏗️ What Happens in Real Projects?

Streams are used in every modern Java service:

• →Filtering and transforming query results
• →Grouping and aggregating data
• →Converting between DTOs and entities
• →Validating collections
• →Building lookup maps from lists

⚙️ How It Works

Laziness:

Intermediate operations are lazy — they are not executed until a terminal operation is called. This enables short-circuiting: filter().findFirst() stops as soon as the first match is found, even if the source has millions of elements.

Internal Iteration:

Streams use internal iteration — you describe what to do, the stream decides how to do it. This enables parallel execution without changing the code.

Stream vs Collection:

• →Collections store data; Streams process data
• →Streams are single-use — once consumed, they cannot be reused
• →Streams do not modify the source collection

💻 Example

Streams in Enterprise Code — Real-world stream patterns from production Java applications.

List<Order> orders = orderRepository.findAll();

// Filter + map + collect
List<String> activeOrderIds = orders.stream()
    .filter(o -> o.getStatus() == OrderStatus.ACTIVE)
    .map(Order::getId)
    .map(Object::toString)
    .collect(Collectors.toList());

// Grouping by field
Map<OrderStatus, List<Order>> byStatus = orders.stream()
    .collect(Collectors.groupingBy(Order::getStatus));

// Counting by field
Map<String, Long> countByCustomer = orders.stream()
    .collect(Collectors.groupingBy(
        Order::getCustomerId,
        Collectors.counting()
    ));

// Sum / average
BigDecimal totalRevenue = orders.stream()
    .filter(o -> o.getStatus() == OrderStatus.COMPLETED)
    .map(Order::getTotalAmount)
    .reduce(BigDecimal.ZERO, BigDecimal::add);

OptionalDouble avgAmount = orders.stream()
    .mapToDouble(o -> o.getTotalAmount().doubleValue())
    .average();

// flatMap — flatten nested collections
List<LineItem> allItems = orders.stream()
    .flatMap(o -> o.getLineItems().stream())
    .collect(Collectors.toList());

// distinct + sorted
List<String> uniqueCustomers = orders.stream()
    .map(Order::getCustomerId)
    .distinct()
    .sorted()
    .collect(Collectors.toList());

// anyMatch / allMatch / noneMatch
boolean hasOverdueOrders = orders.stream()
    .anyMatch(o -> o.getDueDate().isBefore(LocalDate.now()));

boolean allValid = orders.stream()
    .allMatch(o -> o.getTotalAmount().compareTo(BigDecimal.ZERO) > 0);

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits