org.davidmoten.kool

Interface Stream<T>

All Superinterfaces:

Iterable<T>, StreamIterable<T>

All Known Implementing Classes:

Buffer, BufferWithFactoryPredicateAndStep, BufferWithPredicate, Cache, Concat, Defer, Dematerialize, Distinct, DistinctUntilChanged, DoOnComplete, DoOnDispose, DoOnEmpty, DoOnError, DoOnNext, DoOnStart, EmptyStream, Filter, FlatMap, FlatMapGenerator, FromArray, FromArrayDouble, FromArrayFloat, FromArrayInt, FromBufferedReader, FromChars, FromInputStream, FromReader, Generate, IgnoreDisposalError, Map, Materialize, MaybeFlatMap, MaybeToStream, MergeInterleaved, PowerSet, PrependOne, Range, RangeLong, Repeat, RepeatElement, RepeatLast, RetryWhen, Reverse, SingleFlatMap, SingleToStream, Skip, SkipUntil, Sorted, Split, StreamImpl, SwitchOnEmpty, SwitchOnError, Take, TakeLast, TakeWithPredicate, Transform, Using, Zip

public interface Stream<T>
extends StreamIterable<T>

Field Summary

Fields

Modifier and Type	Field and Description
static Consumer<Closeable>	CLOSEABLE_CLOSER
static int	DEFAULT_BUFFER_SIZE
static int	DEFAULT_BYTE_BUFFER_SIZE

Method Summary

Modifier and Type	Method and Description
default Single<Boolean>	all(Predicate<? super T> predicate)
default Single<Boolean>	any(Predicate<? super T> predicate)
default Stream<List<T>>	buffer(int size)
default Stream<List<T>>	buffer(int size, int step)
default Stream<List<T>>	bufferUntil(BiPredicate<? super List<T>,? super T> condition, boolean emitRemainder)
default Stream<List<T>>	bufferUntil(BiPredicate<? super List<T>,? super T> condition, boolean emitRemainder, Function<? super List<T>,Integer> step, int maxReplay)
default Stream<List<T>>	bufferUntil(BiPredicate<? super List<T>,? super T> condition, boolean emitRemainder, int step, int maxReplay)
default <S> Stream<S>	bufferUntil(Callable<? extends S> factory, BiFunction<? super S,? super T,? extends S> accumulator, BiPredicate<? super S,? super T> condition, boolean emitRemainder, Function<? super S,Integer> step, int maxReplay)
default Stream<List<T>>	bufferWhile(BiPredicate<? super List<T>,? super T> condition, boolean emitRemainder)
default Stream<List<T>>	bufferWhile(BiPredicate<? super List<T>,? super T> condition, boolean emitRemainder, Function<? super List<T>,Integer> step, int maxReplay)
default Stream<List<T>>	bufferWhile(BiPredicate<? super List<T>,? super T> condition, boolean emitRemainder, int step, int maxReplay)
default <S> Stream<S>	bufferWhile(Callable<? extends S> factory, BiFunction<? super S,? super T,? extends S> accumulator, BiPredicate<? super S,? super T> condition, boolean emitRemainder, Function<? super S,Integer> step, int maxReplay)
static Stream<ByteBuffer>	byteBuffers(Callable<? extends InputStream> provider)
static Stream<ByteBuffer>	byteBuffers(Callable<? extends InputStream> provider, int bufferSize)
static Stream<ByteBuffer>	byteBuffers(InputStream in)
static Stream<ByteBuffer>	byteBuffers(InputStream in, int bufferSize)
static Stream<byte[]>	bytes(Callable<? extends InputStream> provider)
static Stream<byte[]>	bytes(Callable<? extends InputStream> provider, int bufferSize)
static Stream<byte[]>	bytes(InputStream in)
static Stream<byte[]>	bytes(InputStream in, int bufferSize)
default Stream<T>	cache()
default <R> Stream<R>	cast(Class<R> cls)
static Stream<Integer>	chars(CharSequence s)
static Stream<Integer>	chars(CharSequence s, int fromIndex, int toIndex)
default <R> Single<R>	collect(Callable<? extends R> factory, BiConsumer<? super R,? super T> collector)
default <A,R> Single<R>	collect(Collector<T,A,R> collector)
default <R> Single<R>	collect(Collector<T,R> collector)
default <R> Stream<R>	compose(Function<? super Stream<T>,? extends Stream<? extends R>> transformer)
default <R> Maybe<R>	composeMaybe(Function<? super Stream<T>,? extends Maybe<? extends R>> transformer)
default <R> Single<R>	composeSingle(Function<? super Stream<T>,? extends Single<? extends R>> transformer)
default Stream<T>	concatWith(StreamIterable<? extends T> values)
default Single<Boolean>	contains(T value)
default Single<Long>	count()
static <T> Stream<T>	create(Iterable<? extends T> source)
static <T> Stream<T>	defer(Callable<? extends Stream<? extends T>> provider)
default Stream<T>	delayStart(long duration, TimeUnit unit)
default <R> Stream<R>	dematerialize(Function<? super T,Notification<? extends R>> function)
default Stream<T>	distinct()
default <K> Stream<T>	distinct(Function<? super T,K> keySelector)
default Stream<T>	distinctUntilChanged()
default <K> Stream<T>	distinctUntilChanged(Function<? super T,K> keySelector)
default Stream<T>	doAfterDispose(Action action)
default Stream<T>	doBeforeDispose(Action action)
default Stream<T>	doOnComplete(Action action)
default Stream<T>	doOnDispose(Action action)
default Stream<T>	doOnEmpty(Action action)
default Stream<T>	doOnError(Consumer<? super Throwable> consumer)
default Stream<T>	doOnNext(Consumer<? super T> consumer)
default Stream<T>	doOnStart(Action action)
default Stream<T>	doWithIndex(BiConsumer<? super Long,? super T> consumer)
static <T> Stream<T>	empty()
static <T> Stream<T>	error(Callable<? extends Throwable> callable)
static <T> Stream<T>	error(Throwable e)
default Stream<T>	every(long n, BiConsumer<Long,T> action)
default Single<Boolean>	exists(Predicate<? super T> function)
default Stream<T>	filter(Predicate<? super T> function)
default Maybe<T>	findFirst(Predicate<? super T> predicate)
default Maybe<T>	first()
default <R> Stream<R>	flatMap(BiConsumer<? super T,? super Consumer<R>> generator) Using a consumer to report items to downstream is more performant (fewer allocations) because a Stream object doesn't have to be created for each upstream element.
default <R> Stream<R>	flatMap(BiConsumer<? super T,? super Consumer<R>> generator, Consumer<? super Consumer<R>> onFinish)
default <R> Stream<R>	flatMap(Function<? super T,? extends StreamIterable<? extends R>> function)
default <R> Stream<R>	flatMapJavaStream(Function<? super T,? extends Stream<? extends R>> function)
default void	forEach()
default void	forEach2(Consumer<? super T> consumer)
static Stream<String>	from(InputStream in)
static Stream<String>	from(InputStream in, Charset charset)
static Stream<String>	from(InputStream in, Charset charset, int bufferSize)
static <T> Stream<T>	from(Iterable<? extends T> iterable)
static Stream<String>	from(Reader reader)
static Stream<String>	from(Reader reader, int bufferSize)
static <T> Stream<T>	from(Stream<? extends T> stream)
static Stream<Double>	fromArray(double[] array)
static Stream<Double>	fromArray(double[] array, int fromIndex, int toIndex)
static Stream<Float>	fromArray(float[] array)
static Stream<Float>	fromArray(float[] array, int fromIndex, int toIndex)
static Stream<Integer>	fromArray(int[] array)
static Stream<Integer>	fromArray(int[] array, int fromIndex, int toIndex)
static <T> Stream<T>	fromArray(T[] array)
static <T> Stream<T>	fromArray(T[] array, int fromIndex, int toIndex)
static <T,R> Stream<T>	generate(Callable<R> factory, BiConsumer<R,Emitter<T>> consumer)
static <T> Stream<T>	generate(Consumer<Emitter<T>> consumer)
default Maybe<T>	get(int index)
default void	go()
default <M extends Map<K,D>,K,V,D extends Collection<V>> Single<M>	groupBy(Callable<M> mapFactory, Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector, Callable<D> collectionFactory)
default <M extends Map<K,List<T>>,K> Single<M>	groupByList(Callable<M> mapFactory, Function<? super T,? extends K> keySelector)
default <M extends Map<K,List<V>>,K,V> Single<M>	groupByList(Callable<M> mapFactory, Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector)
default <K> Single<Map<K,List<T>>>	groupByList(Function<? super T,? extends K> keySelector)
default <M extends Map<K,Set<T>>,K> Single<M>	groupBySet(Callable<M> mapFactory, Function<? super T,? extends K> keySelector)
default <M extends Map<K,Set<V>>,K,V> Single<M>	groupBySet(Callable<M> mapFactory, Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector)
default <K> Single<Map<K,Set<T>>>	groupBySet(Function<? super T,? extends K> keySelector)
default Single<Boolean>	hasElements()
default Stream<T>	ignoreDisposalError()
default Stream<T>	ignoreDisposalError(Consumer<? super Throwable> action)
static InputStream	inputStream(Stream<? extends byte[]> stream)
static Stream<Integer>	interval(long duration, TimeUnit unit) Emits the integers 0, 1, 2, ....
default Single<Boolean>	isEmpty()
default Single<String>	join(String delimiter)
default Maybe<T>	last()
static Stream<String>	lines(BufferedReader reader)
static Stream<String>	lines(Callable<? extends BufferedReader> readerFactory)
static Stream<String>	lines(Callable<? extends InputStream> inFactory, Charset charset)
static Stream<String>	lines(File file)
static Stream<String>	lines(File file, Charset charset)
static Stream<String>	linesFromResource(Class<?> cls, String resource, Charset charset)
static Stream<String>	linesFromResource(String resource)
static Stream<String>	linesFromResource(String resource, Charset charset)
default <R> Stream<R>	map(Function<? super T,? extends R> function)
default Stream<Indexed<T>>	mapWithIndex()
default Stream<Indexed<T>>	mapWithIndex(int startIndex)
default Stream<Notification<T>>	materialize()
default Maybe<T>	max(Comparator<? super T> comparator)
default Maybe<T>	maybe()
static <T> Stream<T>	merge(Stream<? extends T>... streams) Returns an interleaved merge of the streams (one item emitted from each stream in round-robin style).
default Stream<T>	mergeWith(Stream<? extends T> stream)
default Maybe<T>	min(Comparator<? super T> comparator)
static <T> Stream<T>	of(T t)
static <T> Stream<T>	of(T t1, T t2)
static <T> Stream<T>	of(T t1, T t2, T t3)
static <T> Stream<T>	of(T t1, T t2, T t3, T t4)
static <T> Stream<T>	of(T t1, T t2, T t3, T t4, T t5)
static <T> Stream<T>	of(T t1, T t2, T t3, T t4, T t5, T t6)
static <T> Stream<T>	of(T t1, T t2, T t3, T t4, T t5, T t6, T t7)
static <T> Stream<T>	of(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8)
static Stream<Integer>	ordinals()
static Stream<Long>	ordinalsLong()
static <T> Stream<List<Integer>>	permutations(int size)
static Stream<Set<Integer>>	powerSet(int n)
default Stream<T>	prepend(StreamIterable<? extends T> values)
default Stream<T>	prepend(T value)
default Stream<T>	prepend(T[] values)
default Stream<T>	println()
default Stream<T>	printStackTrace()
static Stream<Integer>	range(int start, int length)
static Stream<Long>	rangeLong(long start, long length)
default Maybe<T>	reduce(BiFunction<? super T,? super T,? extends T> reducer)
default <R> Single<R>	reduce(R initialValue, BiFunction<? super R,? super T,? extends R> reducer)
default <R> Single<R>	reduceWithFactory(Callable<? extends R> initialValueFactory, BiFunction<? super R,? super T,? extends R> reducer)
default Stream<T>	repeat()
default Stream<T>	repeat(long count)
static <T> Stream<T>	repeatElement(T t)
static <T> Stream<T>	repeatElement(T t, long count)
default Stream<T>	repeatLast()
default Stream<T>	repeatLast(long count)
default RetryWhenBuilder<T>	retryWhen()
default Stream<T>	retryWhen(Function<? super Throwable,? extends Single<?>> function)
default Stream<T>	reverse()
default <R> Stream<R>	scan(R initialValue, BiFunction<? super R,? super T,? extends R> accumulator)
default Single<T>	single()
default Stream<T>	skip(int size)
default Stream<T>	skipUntil(Predicate<? super T> predicate)
default Stream<T>	skipWhile(Predicate<? super T> predicate)
default Stream<T>	sorted()
default Stream<T>	sorted(Comparator<? super T> comparator)
default Stream<String>	split(String delimiter)
default void	start()
default <R extends Number> Single<Statistics>	statistics(Function<? super T,? extends R> mapper)
static <T extends Number> Single<Statistics>	statistics(Stream<T> stream)
static Stream<String>	strings(Stream<? extends byte[]> stream)
static Stream<String>	strings(Stream<? extends byte[]> stream, Charset charset)
static Stream<String>	strings(Stream<? extends byte[]> stream, Charset charset, int bufferSize)
default <R> Single<Double>	sumDouble(Function<? super T,Double> mapper)
default <R> Single<Integer>	sumInt(Function<? super T,Integer> mapper)
default <R> Single<Long>	sumLong(Function<? super T,Long> mapper)
default Stream<T>	switchOnEmpty(Callable<? extends Stream<T>> factory)
default Stream<T>	switchOnError(Function<? super Throwable,? extends Stream<? extends T>> function)
default Stream<T>	take(long n)
default Stream<T>	takeLast(long n)
default Stream<T>	takeUntil(Predicate<? super T> predicate)
default Stream<T>	takeWhile(Predicate<? super T> predicate)
default Tester<T>	test()
default <R> R	to(Function<? super Stream<T>,R> mapper)
default Single<List<T>>	toList()
default Single<List<T>>	toList(int sizeHint)
default <K,V> Single<Map<K,V>>	toMap(Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)
default Single<Set<T>>	toSet()
default Single<Set<T>>	toSet(int sizeHint)
default Stream<T>	toStreamJava()
default <R> Stream<R>	transform(Function<? super Stream<T>,? extends Stream<? extends R>> transformer)
default <R> Maybe<R>	transformMaybe(Function<? super Stream<T>,? extends Maybe<? extends R>> transformer)
default <R> Single<R>	transformSingle(Function<? super Stream<T>,? extends Single<? extends R>> transformer)
static <R extends Closeable,T> Stream<T>	using(Callable<? extends R> resourceFactory, Function<? super R,? extends Stream<? extends T>> streamFactory)
static <R,T> Stream<T>	using(Callable<? extends R> resourceFactory, Function<? super R,? extends Stream<? extends T>> streamFactory, Consumer<? super R> closer)
default <R,S> Stream<S>	zipWith(Stream<? extends R> stream, BiFunction<T,R,S> combiner)

Methods inherited from interface org.davidmoten.kool.StreamIterable

iterator, iteratorNullChecked

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Field Detail

DEFAULT_BUFFER_SIZE

static final int DEFAULT_BUFFER_SIZE

See Also:

Constant Field Values

DEFAULT_BYTE_BUFFER_SIZE

static final int DEFAULT_BYTE_BUFFER_SIZE

See Also:

Constant Field Values

CLOSEABLE_CLOSER

static final Consumer<Closeable> CLOSEABLE_CLOSER

Method Detail

create

static <T> Stream<T> create(Iterable<? extends T> source)

of

static <T> Stream<T> of(T t)

of

static <T> Stream<T> of(T t1,
                        T t2)

of

static <T> Stream<T> of(T t1,
                        T t2,
                        T t3)

of

static <T> Stream<T> of(T t1,
                        T t2,
                        T t3,
                        T t4)

of

static <T> Stream<T> of(T t1,
                        T t2,
                        T t3,
                        T t4,
                        T t5)

of

static <T> Stream<T> of(T t1,
                        T t2,
                        T t3,
                        T t4,
                        T t5,
                        T t6)

of

static <T> Stream<T> of(T t1,
                        T t2,
                        T t3,
                        T t4,
                        T t5,
                        T t6,
                        T t7)

of

static <T> Stream<T> of(T t1,
                        T t2,
                        T t3,
                        T t4,
                        T t5,
                        T t6,
                        T t7,
                        T t8)

error

static <T> Stream<T> error(Throwable e)

chars

static Stream<Integer> chars(CharSequence s)

chars

static Stream<Integer> chars(CharSequence s,
                             int fromIndex,
                             int toIndex)

generate

static <T> Stream<T> generate(Consumer<Emitter<T>> consumer)

generate

static <T,R> Stream<T> generate(Callable<R> factory,
                                BiConsumer<R,Emitter<T>> consumer)

error

static <T> Stream<T> error(Callable<? extends Throwable> callable)

from

static <T> Stream<T> from(Iterable<? extends T> iterable)

from

static Stream<String> from(Reader reader)

from

static Stream<String> from(Reader reader,
                           int bufferSize)

from

static Stream<String> from(InputStream in,
                           Charset charset,
                           int bufferSize)

from

static Stream<String> from(InputStream in,
                           Charset charset)

from

static Stream<String> from(InputStream in)

from

static <T> Stream<T> from(Stream<? extends T> stream)

fromArray

static <T> Stream<T> fromArray(T[] array,
                               int fromIndex,
                               int toIndex)

fromArray

static <T> Stream<T> fromArray(T[] array)

fromArray

static Stream<Integer> fromArray(int[] array,
                                 int fromIndex,
                                 int toIndex)

fromArray

static Stream<Integer> fromArray(int[] array)

fromArray

static Stream<Double> fromArray(double[] array,
                                int fromIndex,
                                int toIndex)

fromArray

static Stream<Double> fromArray(double[] array)

fromArray

static Stream<Float> fromArray(float[] array,
                               int fromIndex,
                               int toIndex)

fromArray

static Stream<Float> fromArray(float[] array)

lines

static Stream<String> lines(BufferedReader reader)

lines

static Stream<String> lines(Callable<? extends BufferedReader> readerFactory)

lines

static Stream<String> lines(Callable<? extends InputStream> inFactory,
                            Charset charset)

lines

static Stream<String> lines(File file,
                            Charset charset)

lines

static Stream<String> lines(File file)

linesFromResource

static Stream<String> linesFromResource(String resource,
                                        Charset charset)

linesFromResource

static Stream<String> linesFromResource(Class<?> cls,
                                        String resource,
                                        Charset charset)

linesFromResource

static Stream<String> linesFromResource(String resource)

byteBuffers

static Stream<ByteBuffer> byteBuffers(Callable<? extends InputStream> provider,
                                      int bufferSize)

byteBuffers

static Stream<ByteBuffer> byteBuffers(Callable<? extends InputStream> provider)

byteBuffers

static Stream<ByteBuffer> byteBuffers(InputStream in)

byteBuffers

static Stream<ByteBuffer> byteBuffers(InputStream in,
                                      int bufferSize)

bytes

static Stream<byte[]> bytes(Callable<? extends InputStream> provider,
                            int bufferSize)

bytes

static Stream<byte[]> bytes(Callable<? extends InputStream> provider)

bytes

static Stream<byte[]> bytes(InputStream in,
                            int bufferSize)

bytes

static Stream<byte[]> bytes(InputStream in)

range

static Stream<Integer> range(int start,
                             int length)

rangeLong

static Stream<Long> rangeLong(long start,
                              long length)

ordinalsLong

static Stream<Long> ordinalsLong()

ordinals

static Stream<Integer> ordinals()

defer

static <T> Stream<T> defer(Callable<? extends Stream<? extends T>> provider)

empty

static <T> Stream<T> empty()

using

static <R,T> Stream<T> using(Callable<? extends R> resourceFactory,
                             Function<? super R,? extends Stream<? extends T>> streamFactory,
                             Consumer<? super R> closer)

using

static <R extends Closeable,T> Stream<T> using(Callable<? extends R> resourceFactory,
                                               Function<? super R,? extends Stream<? extends T>> streamFactory)

repeatElement

static <T> Stream<T> repeatElement(T t)

repeatElement

static <T> Stream<T> repeatElement(T t,
                                   long count)

merge

@SafeVarargs
static <T> Stream<T> merge(Stream<? extends T>... streams)

Returns an interleaved merge of the streams (one item emitted from each stream in round-robin style).

Type Parameters:

T - result stream type

Parameters:

streams - to be merged

Returns:

merges streams (interleaved)

interval

static Stream<Integer> interval(long duration,
                                TimeUnit unit)

Emits the integers 0, 1, 2, .... The first element is emitted immediately (0) and then the current thread is blocked with Thread.sleep for the given duration between further emissions. If you don't want the stream to start with 0 immediately then call interval(...).skip(1).

Parameters:

duration - sleep duration

unit - unit of sleep duration

Returns:

stream with interval wait between emissions

inputStream

static InputStream inputStream(Stream<? extends byte[]> stream)

strings

static Stream<String> strings(Stream<? extends byte[]> stream,
                              Charset charset,
                              int bufferSize)

strings

static Stream<String> strings(Stream<? extends byte[]> stream,
                              Charset charset)

strings

static Stream<String> strings(Stream<? extends byte[]> stream)

isEmpty

default Single<Boolean> isEmpty()

hasElements

default Single<Boolean> hasElements()

sorted

default Stream<T> sorted(Comparator<? super T> comparator)

sorted

default Stream<T> sorted()

map

default <R> Stream<R> map(Function<? super T,? extends R> function)

reduce

default Maybe<T> reduce(BiFunction<? super T,? super T,? extends T> reducer)

reduce

default <R> Single<R> reduce(R initialValue,
                             BiFunction<? super R,? super T,? extends R> reducer)

reduceWithFactory

default <R> Single<R> reduceWithFactory(Callable<? extends R> initialValueFactory,
                                        BiFunction<? super R,? super T,? extends R> reducer)

sumInt

default <R> Single<Integer> sumInt(Function<? super T,Integer> mapper)

sumLong

default <R> Single<Long> sumLong(Function<? super T,Long> mapper)

sumDouble

default <R> Single<Double> sumDouble(Function<? super T,Double> mapper)

collect

default <R> Single<R> collect(Callable<? extends R> factory,
                              BiConsumer<? super R,? super T> collector)

collect

default <R> Single<R> collect(Collector<T,R> collector)

collect

default <A,R> Single<R> collect(Collector<T,A,R> collector)

groupBy

default <M extends Map<K,D>,K,V,D extends Collection<V>> Single<M> groupBy(Callable<M> mapFactory,
                                                                           Function<? super T,? extends K> keySelector,
                                                                           Function<? super T,? extends V> valueSelector,
                                                                           Callable<D> collectionFactory)

groupByList

default <M extends Map<K,List<V>>,K,V> Single<M> groupByList(Callable<M> mapFactory,
                                                             Function<? super T,? extends K> keySelector,
                                                             Function<? super T,? extends V> valueSelector)

groupBySet

default <M extends Map<K,Set<V>>,K,V> Single<M> groupBySet(Callable<M> mapFactory,
                                                           Function<? super T,? extends K> keySelector,
                                                           Function<? super T,? extends V> valueSelector)

groupByList

default <M extends Map<K,List<T>>,K> Single<M> groupByList(Callable<M> mapFactory,
                                                           Function<? super T,? extends K> keySelector)

groupBySet

default <M extends Map<K,Set<T>>,K> Single<M> groupBySet(Callable<M> mapFactory,
                                                         Function<? super T,? extends K> keySelector)

groupByList

default <K> Single<Map<K,List<T>>> groupByList(Function<? super T,? extends K> keySelector)

groupBySet

default <K> Single<Map<K,Set<T>>> groupBySet(Function<? super T,? extends K> keySelector)

single

default Single<T> single()

toList

default Single<List<T>> toList()

toSet

default Single<Set<T>> toSet()

toSet

default Single<Set<T>> toSet(int sizeHint)

toList

default Single<List<T>> toList(int sizeHint)

filter

default Stream<T> filter(Predicate<? super T> function)

exists

default Single<Boolean> exists(Predicate<? super T> function)

forEach

default void forEach()

go

default void go()

start

default void start()

forEach2

default void forEach2(Consumer<? super T> consumer)

println

default Stream<T> println()

count

default Single<Long> count()

prepend

default Stream<T> prepend(T value)

prepend

default Stream<T> prepend(T[] values)

prepend

default Stream<T> prepend(StreamIterable<? extends T> values)

concatWith

default Stream<T> concatWith(StreamIterable<? extends T> values)

flatMap

default <R> Stream<R> flatMap(Function<? super T,? extends StreamIterable<? extends R>> function)

flatMap

default <R> Stream<R> flatMap(BiConsumer<? super T,? super Consumer<R>> generator,
                              Consumer<? super Consumer<R>> onFinish)

flatMap

default <R> Stream<R> flatMap(BiConsumer<? super T,? super Consumer<R>> generator)

Using a consumer to report items to downstream is more performant (fewer allocations) because a Stream object doesn't have to be created for each upstream element.

Type Parameters:

R - type of return stream

Parameters:

generator - generator of downstream items

Returns:

new stream

flatMapJavaStream

default <R> Stream<R> flatMapJavaStream(Function<? super T,? extends Stream<? extends R>> function)

findFirst

default Maybe<T> findFirst(Predicate<? super T> predicate)

first

default Maybe<T> first()

doOnNext

default Stream<T> doOnNext(Consumer<? super T> consumer)

doWithIndex

default Stream<T> doWithIndex(BiConsumer<? super Long,? super T> consumer)

doOnError

default Stream<T> doOnError(Consumer<? super Throwable> consumer)

doOnComplete

default Stream<T> doOnComplete(Action action)

doOnDispose

default Stream<T> doOnDispose(Action action)

doBeforeDispose

default Stream<T> doBeforeDispose(Action action)

doAfterDispose

default Stream<T> doAfterDispose(Action action)

doOnEmpty

default Stream<T> doOnEmpty(Action action)

last

default Maybe<T> last()

get

default Maybe<T> get(int index)

take

default Stream<T> take(long n)

takeLast

default Stream<T> takeLast(long n)

transform

default <R> Stream<R> transform(Function<? super Stream<T>,? extends Stream<? extends R>> transformer)

transformSingle

default <R> Single<R> transformSingle(Function<? super Stream<T>,? extends Single<? extends R>> transformer)

transformMaybe

default <R> Maybe<R> transformMaybe(Function<? super Stream<T>,? extends Maybe<? extends R>> transformer)

compose

default <R> Stream<R> compose(Function<? super Stream<T>,? extends Stream<? extends R>> transformer)

composeSingle

default <R> Single<R> composeSingle(Function<? super Stream<T>,? extends Single<? extends R>> transformer)

composeMaybe

default <R> Maybe<R> composeMaybe(Function<? super Stream<T>,? extends Maybe<? extends R>> transformer)

switchOnError

default Stream<T> switchOnError(Function<? super Throwable,? extends Stream<? extends T>> function)

switchOnEmpty

default Stream<T> switchOnEmpty(Callable<? extends Stream<T>> factory)

zipWith

default <R,S> Stream<S> zipWith(Stream<? extends R> stream,
                                BiFunction<T,R,S> combiner)

toStreamJava

default Stream<T> toStreamJava()

toMap

default <K,V> Single<Map<K,V>> toMap(Function<? super T,? extends K> keyFunction,
                                     Function<? super T,? extends V> valueFunction)

join

default Single<String> join(String delimiter)

split

default Stream<String> split(String delimiter)

test

default Tester<T> test()

buffer

default Stream<List<T>> buffer(int size)

buffer

default Stream<List<T>> buffer(int size,
                               int step)

skip

default Stream<T> skip(int size)

skipUntil

default Stream<T> skipUntil(Predicate<? super T> predicate)

skipWhile

default Stream<T> skipWhile(Predicate<? super T> predicate)

repeat

default Stream<T> repeat(long count)

repeat

default Stream<T> repeat()

takeUntil

default Stream<T> takeUntil(Predicate<? super T> predicate)

takeWhile

default Stream<T> takeWhile(Predicate<? super T> predicate)

bufferUntil

default Stream<List<T>> bufferUntil(BiPredicate<? super List<T>,? super T> condition,
                                    boolean emitRemainder)

bufferWhile

default Stream<List<T>> bufferWhile(BiPredicate<? super List<T>,? super T> condition,
                                    boolean emitRemainder)

bufferUntil

default Stream<List<T>> bufferUntil(BiPredicate<? super List<T>,? super T> condition,
                                    boolean emitRemainder,
                                    int step,
                                    int maxReplay)

bufferWhile

default Stream<List<T>> bufferWhile(BiPredicate<? super List<T>,? super T> condition,
                                    boolean emitRemainder,
                                    int step,
                                    int maxReplay)

bufferUntil

default Stream<List<T>> bufferUntil(BiPredicate<? super List<T>,? super T> condition,
                                    boolean emitRemainder,
                                    Function<? super List<T>,Integer> step,
                                    int maxReplay)

bufferWhile

default Stream<List<T>> bufferWhile(BiPredicate<? super List<T>,? super T> condition,
                                    boolean emitRemainder,
                                    Function<? super List<T>,Integer> step,
                                    int maxReplay)

bufferUntil

default <S> Stream<S> bufferUntil(Callable<? extends S> factory,
                                  BiFunction<? super S,? super T,? extends S> accumulator,
                                  BiPredicate<? super S,? super T> condition,
                                  boolean emitRemainder,
                                  Function<? super S,Integer> step,
                                  int maxReplay)

bufferWhile

default <S> Stream<S> bufferWhile(Callable<? extends S> factory,
                                  BiFunction<? super S,? super T,? extends S> accumulator,
                                  BiPredicate<? super S,? super T> condition,
                                  boolean emitRemainder,
                                  Function<? super S,Integer> step,
                                  int maxReplay)

mapWithIndex

default Stream<Indexed<T>> mapWithIndex(int startIndex)

mapWithIndex

default Stream<Indexed<T>> mapWithIndex()

cache

default Stream<T> cache()

every

default Stream<T> every(long n,
                        BiConsumer<Long,T> action)

ignoreDisposalError

default Stream<T> ignoreDisposalError(Consumer<? super Throwable> action)

ignoreDisposalError

default Stream<T> ignoreDisposalError()

max

default Maybe<T> max(Comparator<? super T> comparator)

min

default Maybe<T> min(Comparator<? super T> comparator)

all

default Single<Boolean> all(Predicate<? super T> predicate)

any

default Single<Boolean> any(Predicate<? super T> predicate)

cast

default <R> Stream<R> cast(Class<R> cls)

contains

default Single<Boolean> contains(T value)

distinctUntilChanged

default Stream<T> distinctUntilChanged()

distinct

default <K> Stream<T> distinct(Function<? super T,K> keySelector)

distinct

default Stream<T> distinct()

distinctUntilChanged

default <K> Stream<T> distinctUntilChanged(Function<? super T,K> keySelector)

maybe

default Maybe<T> maybe()

to

default <R> R to(Function<? super Stream<T>,R> mapper)

printStackTrace

default Stream<T> printStackTrace()

materialize

default Stream<Notification<T>> materialize()

dematerialize

default <R> Stream<R> dematerialize(Function<? super T,Notification<? extends R>> function)

reverse

default Stream<T> reverse()

doOnStart

default Stream<T> doOnStart(Action action)

delayStart

default Stream<T> delayStart(long duration,
                             TimeUnit unit)

mergeWith

default Stream<T> mergeWith(Stream<? extends T> stream)

retryWhen

default Stream<T> retryWhen(Function<? super Throwable,? extends Single<?>> function)

retryWhen

default RetryWhenBuilder<T> retryWhen()

repeatLast

default Stream<T> repeatLast(long count)

scan

default <R> Stream<R> scan(R initialValue,
                           BiFunction<? super R,? super T,? extends R> accumulator)

statistics

default <R extends Number> Single<Statistics> statistics(Function<? super T,? extends R> mapper)

repeatLast

default Stream<T> repeatLast()

powerSet

static Stream<Set<Integer>> powerSet(int n)

permutations

static <T> Stream<List<Integer>> permutations(int size)

statistics

static <T extends Number> Single<Statistics> statistics(Stream<T> stream)