A small collection of Stream utilities for Java 8. Protonpack provides the following:
takeWhileandtakeUntilskipWhileandskipUntilzipandzipWithIndexunfoldMapStreamaggregateStreamable<T>uniquecollector
For full API documentation, see (http://poetix.github.io/protonpack).
Available from Maven Central:
<dependency>
<groupId>com.codepoetics</groupId>
<artifactId>protonpack</artifactId>
<version>1.16</version>
</dependency>Takes elements from the stream while the supplied condition is met. takeUntil does the same, but with the condition negated.
Stream<Integer> infiniteInts = Stream.iterate(0, i -> i + 1);
Stream<Integer> finiteInts = StreamUtils.takeWhile(infiniteInts, i -> i < 10);
assertThat(finiteInts.collect(Collectors.toList()),
hasSize(10));Skips elements from the stream while the supplied condition is met. skipUntil does the same, but with the condition negated.
Stream<Integer> ints = Stream.of(1,2,3,4,5,6,7,8,9,10);
Stream<Integer> skipped = StreamUtils.skipWhile(ints, i -> i < 4);
List<Integer> collected = skipped.collect(Collectors.toList());
assertThat(collected,
contains(4, 5, 6, 7, 8, 9, 10));Combines two streams using the supplied combiner function.
Stream<String> streamA = Stream.of("A", "B", "C");
Stream<String> streamB = Stream.of("Apple", "Banana", "Carrot", "Doughnut");
List<String> zipped = StreamUtils.zip(streamA,
streamB,
(a, b) -> a + " is for " + b)
.collect(Collectors.toList());
assertThat(zipped,
contains("A is for Apple", "B is for Banana", "C is for Carrot"));Generates a (potentially infinite) stream using a generator that can indicate the end of the stream at any time by returning Optional.empty().
Stream<Integer> unfolded = StreamUtils.unfold(1, i ->
(i < 10)
? Optional.of(i + 1)
: Optional.empty());
assertThat(unfolded.collect(Collectors.toList()),
contains(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));Transforms a source type into a stream
stream(Optional<T> optional):
Stream<Item> items = idStream.flatMap(id -> StreamUtils.stream(fetchItem(id));Streamable is to Stream as Iterable is to Iterator. Useful when you will want to stream repeatedly over some source.
A collector that returns the one and only item in a stream, if present, or throws an exception if multiple items are found.
assertThat(Stream.of(1, 2, 3).filter(i -> i > 3).collect(CollectorUtils.unique()),
equalTo(Optional.empty()));
assertThat(Stream.of(1, 2, 3).filter(i -> i > 2).collect(CollectorUtils.unique()),
equalTo(Optional.of(3)));
// Throws NonUniqueValueException
Stream.of(1, 2, 3).filter(i -> i > 1).collect(CollectorUtils.unique());A collector that converts a stream of CompletableFuture<T> into a CompletableFuture<List<T>>, which completes
exceptionally if (and as soon as) any of the futures in the list completes exceptionally.
Function<Integer, CompletableFuture<Integer>> processAsynchronously = i -> CompletableFuture.completedFuture(i * 2);
assertThat(
Stream.of(1, 2, 3).map(processAsynchronously)
.collect(CompletableFutures.toFutureList())
.get(),
contains(2, 4, 6));