Course contentsShow
← Java
Lesson 1530 of 2,87033. Streams API: Terminal OperationsFree lesson

Performance Characteristics of count, min, and max

Understand the O(n) complexity of these operations and when to use counting collectors versus count() method.

Performance Characteristics of count, min, and max

You'll learn: How these terminal operations perform under the hood and when to choose specialized collectors over the simple methods.

Understanding O(n) Complexity

All three terminal operations—count(), min(), and max()—must examine every element in the stream to produce their result. This means they have O(n) linear time complexity, where n is the number of elements.

Think of it like counting people leaving a stadium: there's no shortcut. You must watch each person pass through the exit gate. Similarly, these operations cannot skip elements or take shortcuts—they must visit each one.

long count = stream.count();        // Visits every element
Optional<String> shortest = stream.min(comparator); // Visits every element
Optional<String> longest = stream.max(comparator);  // Visits every element

When to Use count() vs Counting Collectors

For simple counting, count() is the preferred choice: it's concise, readable, and optimized for performance.

However, when you need to count while collecting other data, use Collectors.counting() with groupingBy() or other advanced collectors:

// Simple counting - use count()
long total = stream.count();

// Counting within groups - use Collectors.counting()
Map<String, Long> countsByCategory = stream
    .collect(Collectors.groupingBy(Item::getCategory, Collectors.counting()));

Memory and Short-Circuiting

Unlike limit() or findFirst(), these operations cannot short-circuit—they need the complete dataset. They use minimal memory (constant space for count, single element storage for min/max), making them efficient even on large streams.

Key Takeaway: count(), min(), and max() are O(n) operations that must process every element; use the simple methods for standalone operations and counting collectors when aggregating within groups.