protonpack

by poetix

poetix /protonpack

Stream utilities for Java 8

414 Stars 54 Forks Last release: Not found MIT License 141 Commits 16 Releases

Available items

No Items, yet!

The developer of this repository has not created any items for sale yet. Need a bug fixed? Help with integration? A different license? Create a request here:

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.