Spliterator characteristics/flags: ORDERED, SIZED, SORTED, DISTINCT and pipeline optimization

• SIZED – exact element count is known; the pipeline can pre-allocate result containers and shortcut count().
• ORDERED – elements have a meaningful encounter order that must be preserved.
• SORTED – elements are already sorted; sorted() becomes a no-op.
• DISTINCT – all elements are unique; distinct() becomes a no-op.
• NONNULL – no element is null.
• IMMUTABLE – the source will not be modified during traversal.
• CONCURRENT – the source supports safe concurrent modification.

What are Spliterator characteristics?

A Spliterator is the engine under every stream. It traverses elements (tryAdvance) and splits them for parallelism (trySplit). Its CHARACTERISTICS are bit flags that describe the source's properties.

How do characteristics enable optimization?

| Characteristic | Optimization |
|---|---|
| SIZED | Pre-allocate result arrays/lists. count() returns size without traversal. |
| ORDERED | Pipeline preserves encounter order. Absence allows unordered parallel. |
| SORTED | sorted() becomes a no-op if the comparator matches. |
| DISTINCT | distinct() becomes a no-op. |
| NONNULL | Null checks can be skipped. |
| IMMUTABLE | No ConcurrentModificationException risk. |

Which collections have which characteristics?

import java.util.*;
import java.util.stream.Stream;

// ArrayList: ORDERED, SIZED → great for parallel (splits in O(1))
List<String> list = new ArrayList<>(List.of("SAV", "CUR", "FD"));
list.stream().spliterator().characteristics();
// ORDERED | SIZED | SUBSIZED

// HashSet: DISTINCT, SIZED → not ORDERED
Set<String> set = new HashSet<>(Set.of("SAV", "CUR", "FD"));
// DISTINCT | SIZED

// TreeSet: DISTINCT, SORTED, ORDERED, SIZED
TreeSet<String> treeSet = new TreeSet<>(Set.of("SAV", "CUR", "FD"));
// DISTINCT | SORTED | ORDERED | SIZED
// treeSet.stream().sorted() → no-op (already SORTED)

How does SIZED affect count()?

// ArrayList is SIZED: count() returns list.size() without processing elements
long count = list.stream()
    .peek(s -> System.out.println("peek: " + s))  // may NEVER execute!
    .count();
// peek may be skipped because count uses the SIZED characteristic

How does SORTED affect sorted()?

// TreeSet is already SORTED: sorted() is a no-op
List<String> result = treeSet.stream()
    .sorted()  // no-op: source is already SORTED
    .toList();
// No sorting work done. Result is [CUR, FD, SAV] (natural order from TreeSet).

How does DISTINCT affect distinct()?

// HashSet is DISTINCT: distinct() is a no-op
List<String> result = set.stream()
    .distinct()  // no-op: source is already DISTINCT
    .toList();
// No deduplication work done.

How do characteristics affect parallel performance?

- **ArrayList** – SIZED + splits in O(1) via array index → excellent for parallel.
- **LinkedList** – not efficiently splittable → poor for parallel.
- **HashSet** – SIZED + bucket-based splitting → decent for parallel.
- **Streams without SIZED** – cannot pre-allocate → more GC pressure.

What should a senior engineer know?

• Characteristics are propagated through the pipeline. filter() removes SIZED because the result count is unknown. sorted() adds SORTED.
• Understanding characteristics explains why treeSet.stream().sorted() is instant while arrayList.stream().sorted() buffers all elements.
• Custom Spliterators should report accurate characteristics for optimal pipeline behavior.
• The unordered() intermediate operation removes ORDERED, allowing the pipeline to skip order-preservation in parallel.

What are common interview follow-up questions?

• How does filter affect SIZED? (Removes it. The pipeline cannot know how many elements pass the filter.)
• Can you add characteristics to a stream? (sorted() adds SORTED. distinct() adds DISTINCT. unordered() removes ORDERED.)
• Why does count() sometimes skip peek? (If the source is SIZED and no operations change the count, count() reads the size directly.)