Stream Creation & Utilities

Stream.iterate creates infinite sequences, Stream.generate calls a supplier infinitely, IntStream.range/rangeClosed creates bounded integer ranges, and infinite streams must use limit or takeWhile.

Stream Gatherers (JEP 485, Java 24) add custom stateful intermediate operations to the Stream API, enabling windowing, batching, and running accumulation that map/filter/flatMap cannot express.

Stream.ofNullable returns a one-element or empty stream from a nullable value, and Stream.concat lazily merges two streams end-to-end.

Use Stream.concat for two streams and Stream.of(streams).flatMap(identity) for three or more to avoid deeply nested pipelines.

toArray() returns Object[] due to type erasure; toArray(String[]::new) passes a generator function that creates a correctly-typed array.

Spliterator characteristics are optimization hints that let the stream pipeline skip redundant operations like sorted() on an already-sorted source or distinct() on a Set.

Stream.iterate(seed, f) produces an infinite ordered stream where each element is f applied to the previous one, so you call limit(n) to take the first n values, such as twelve monthly due dates.

Stream.generate(supplier) produces an infinite stream by calling the supplier for each element with no dependence on the previous value, so limit(n) bounds it to exactly n values, such as n unique transaction references.

IntStream.rangeClosed(1, n) produces an inclusive int sequence you map to account numbers with mapToObj, while IntStream.range(0, list.size()) gives exclusive indices to pair each element with its position.

IntStream.range(1, 11) yields 1 to 10 because the end is exclusive, and filter(n -> n % 2 == 0) keeps the even ones, producing 2, 4, 6, 8, 10.

IntStream.rangeClosed(1, 100).sum() builds the inclusive sequence 1 to 100 and adds every value, giving 5050.

`Stream.of("A", "B", "C")` builds a small finite stream from the listed values, ready for any stream pipeline.

`Stream.generate(supplier).limit(10)` takes ten values from an otherwise infinite stream by bounding it with `limit`.

`iterate({0,1}, f -> {f[1], f[0]+f[1]}).map(f -> f[0]).limit(20)` yields twenty Fibonacci numbers by encoding two predecessors in a carried pair.

`Stream.iterate(1, n -> n * 2).limit(10)` yields the first ten powers of two: 1, 2, 4, 8, ..., 512.

Three-argument `iterate(seed, hasNext, next)` is a functional for-loop that self-terminates, so no `limit` is needed.

Use the source's own `stream()` (or `Arrays.stream` for arrays) so size and splitting characteristics are known, which is crucial for large and parallel work.

IntStream.rangeClosed(1, 100).filter(n -> n % 2 == 0).sum() generates the range, keeps even numbers, and totals them to 2550.