Need help with protonpack?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

poetix
419 Stars 54 Forks MIT License 141 Commits 2 Opened issues

Description

Stream utilities for Java 8

Services available

!
?

Need anything else?

Contributors list

protonpack

Maven Central Build Status

A small collection of

Stream
utilities for Java 8. Protonpack provides the following:
  • takeWhile
    and
    takeUntil
  • skipWhile
    and
    skipUntil
  • zip
    and
    zipWithIndex
  • unfold
  • MapStream
  • aggregate
  • Streamable
  • unique
    collector

For full API documentation, see (http://poetix.github.io/protonpack).

Available from Maven Central:

    com.codepoetics
    protonpack
    1.16

takeWhile

Takes elements from the stream while the supplied condition is met.

takeUntil
does the same, but with the condition negated.
Stream infiniteInts = Stream.iterate(0, i -> i + 1);
Stream finiteInts = StreamUtils.takeWhile(infiniteInts, i -> i < 10);

assertThat(finiteInts.collect(Collectors.toList()), hasSize(10));

skipWhile

Skips elements from the stream while the supplied condition is met.

skipUntil
does the same, but with the condition negated.
Stream ints = Stream.of(1,2,3,4,5,6,7,8,9,10);
Stream skipped = StreamUtils.skipWhile(ints, i -> i < 4);

List collected = skipped.collect(Collectors.toList());

assertThat(collected, contains(4, 5, 6, 7, 8, 9, 10));

zip

Combines two streams using the supplied combiner function.

Stream streamA = Stream.of("A", "B", "C");
Stream streamB  = Stream.of("Apple", "Banana", "Carrot", "Doughnut");

List 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"));

unfold

Generates a (potentially infinite) stream using a generator that can indicate the end of the stream at any time by returning Optional.empty().

Stream 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));

stream

Transforms a source type into a stream

stream(Optional optional):
java
Stream items = idStream.flatMap(id -> StreamUtils.stream(fetchItem(id));

Streamable

Streamable is to Stream as Iterable is to Iterator. Useful when you will want to stream repeatedly over some source.

unique

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());

toFutureList

A collector that converts a stream of

CompletableFuture
into a
CompletableFuture>
, which completes exceptionally if (and as soon as) any of the futures in the list completes exceptionally.
Function> processAsynchronously = i -> CompletableFuture.completedFuture(i * 2);
assertThat(
        Stream.of(1, 2, 3).map(processAsynchronously)
                .collect(CompletableFutures.toFutureList())
                .get(),
        contains(2, 4, 6));

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.