org.infinispan

Interface IntCacheStream

All Superinterfaces:

AutoCloseable, BaseStream<Integer,IntStream>, IntStream

public interface IntCacheStream
extends IntStream

A IntStream that has additional methods to allow for Serializable instances. Please see CacheStream for additional details about various methods.

Since:

8.3

Author:

wburns

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.stream.IntStream

IntStream.Builder

Method Summary

Modifier and Type	Method and Description
default boolean	allMatch(SerializableIntPredicate predicate) Same as IntStream.allMatch(IntPredicate) except that the IntPredicate must also implement Serializable
default boolean	anyMatch(SerializableIntPredicate predicate) Same as IntStream.anyMatch(IntPredicate) except that the IntPredicate must also implement Serializable
DoubleCacheStream	asDoubleStream()
LongCacheStream	asLongStream()
CacheStream<Integer>	boxed()
default <R> R	collect(SerializableSupplier<R> supplier, SerializableObjIntConsumer<R> accumulator, SerializableBiConsumer<R,R> combiner) Same as IntStream.collect(Supplier, ObjIntConsumer, BiConsumer) except that the arguments must also implement Serializable
IntCacheStream	distinct()
IntCacheStream	filter(IntPredicate predicate)
default IntCacheStream	filter(SerializableIntPredicate predicate) Same as filter(IntPredicate) except that the IntPredicate must also implement Serializable
IntCacheStream	flatMap(IntFunction<? extends IntStream> mapper)
default IntCacheStream	flatMap(SerializableIntFunction<? extends IntStream> mapper) Same as flatMap(IntFunction) except that the IntFunction must also implement Serializable
<K,V> void	forEach(ObjIntConsumer<Cache<K,V>> action) Same as IntStream.forEach(IntConsumer) except that it takes an ObjIntConsumer that provides access to the underlying Cache that is backing this stream.
default void	forEach(SerializableIntConsumer action) Same as IntStream.forEach(IntConsumer) except that the IntConsumer must also implement Serializable
default <K,V> void	forEach(SerializableObjIntConsumer<Cache<K,V>> action) Same as forEach(ObjIntConsumer) except that the BiConsumer must also implement Serializable
IntCacheStream	limit(long maxSize)
IntCacheStream	map(IntUnaryOperator mapper)
default IntCacheStream	map(SerializableIntUnaryOperator mapper) Same as map(IntUnaryOperator) except that the IntUnaryOperator must also implement Serializable
DoubleCacheStream	mapToDouble(IntToDoubleFunction mapper)
default DoubleCacheStream	mapToDouble(SerializableIntToDoubleFunction mapper) Same as mapToDouble(IntToDoubleFunction) except that the IntToIntFunction must also implement Serializable
LongCacheStream	mapToLong(IntToLongFunction mapper)
default LongCacheStream	mapToLong(SerializableIntToLongFunction mapper) Same as mapToLong(IntToLongFunction) except that the IntToLongFunction must also implement Serializable
<U> CacheStream<U>	mapToObj(IntFunction<? extends U> mapper)
default <U> CacheStream<U>	mapToObj(SerializableIntFunction<? extends U> mapper) Same as mapToObj(IntFunction) except that the IntFunction must also implement Serializable
default boolean	noneMatch(SerializableIntPredicate predicate) Same as IntStream.noneMatch(IntPredicate) except that the IntPredicate must also implement Serializable
IntCacheStream	onClose(Runnable closeHandler)
IntCacheStream	parallel()
IntCacheStream	peek(IntConsumer action)
default IntCacheStream	peek(SerializableIntConsumer action) Same as flatMap(IntFunction) except that the IntFunction must also implement Serializable
default int	reduce(int identity, SerializableIntBinaryOperator op) Same as IntStream.reduce(int, IntBinaryOperator) except that the IntBinaryOperator must also implement Serializable
default OptionalInt	reduce(SerializableIntBinaryOperator op) Same as IntStream.reduce(IntBinaryOperator) except that the IntBinaryOperator must also implement Serializable
IntCacheStream	sequential()
IntCacheStream	skip(long n)
IntCacheStream	sorted()
IntCacheStream	unordered()

Methods inherited from interface java.util.stream.IntStream

allMatch, anyMatch, average, builder, collect, concat, count, empty, findAny, findFirst, forEach, forEachOrdered, generate, iterate, iterator, max, min, noneMatch, of, of, range, rangeClosed, reduce, reduce, spliterator, sum, summaryStatistics, toArray

Methods inherited from interface java.util.stream.BaseStream

close, isParallel

Method Detail

filter

IntCacheStream filter(IntPredicate predicate)

Specified by:

filter in interface IntStream

Returns:

the new cache int stream

filter

default IntCacheStream filter(SerializableIntPredicate predicate)

Same as filter(IntPredicate) except that the IntPredicate must also implement Serializable

The compiler will pick this overload for lambda parameters, making them Serializable

Parameters:

predicate - a non-interfering, stateless predicate to apply to each element to determine if it should be included

Returns:

the new cache int stream

map

IntCacheStream map(IntUnaryOperator mapper)

Specified by:

map in interface IntStream

Returns:

the new cache int stream

map

default IntCacheStream map(SerializableIntUnaryOperator mapper)

Same as map(IntUnaryOperator) except that the IntUnaryOperator must also implement Serializable

The compiler will pick this overload for lambda parameters, making them Serializable

Parameters:

mapper - a non-interfering, stateless function to apply to each element

Returns:

the new cache int stream

mapToObj

<U> CacheStream<U> mapToObj(IntFunction<? extends U> mapper)

Specified by:

mapToObj in interface IntStream

Returns:

the new cache stream

mapToObj

default <U> CacheStream<U> mapToObj(SerializableIntFunction<? extends U> mapper)

Same as mapToObj(IntFunction) except that the IntFunction must also implement Serializable

The compiler will pick this overload for lambda parameters, making them Serializable

Type Parameters:

U - the element type of the new stream

Parameters:

mapper - a non-interfering, stateless function to apply to each element

Returns:

the new cache stream

mapToDouble

DoubleCacheStream mapToDouble(IntToDoubleFunction mapper)

Specified by:

mapToDouble in interface IntStream

Returns:

the new cache double stream

mapToDouble

default DoubleCacheStream mapToDouble(SerializableIntToDoubleFunction mapper)

Same as mapToDouble(IntToDoubleFunction) except that the IntToIntFunction must also implement Serializable

The compiler will pick this overload for lambda parameters, making them Serializable

Parameters:

mapper - a non-interfering, stateless function to apply to each element

Returns:

the new cache double stream

mapToLong

LongCacheStream mapToLong(IntToLongFunction mapper)

Specified by:

mapToLong in interface IntStream

Returns:

the new cache long stream

mapToLong

default LongCacheStream mapToLong(SerializableIntToLongFunction mapper)

Same as mapToLong(IntToLongFunction) except that the IntToLongFunction must also implement Serializable

The compiler will pick this overload for lambda parameters, making them Serializable

Parameters:

mapper - a non-interfering, stateless function to apply to each element

Returns:

the new cache long stream

flatMap

IntCacheStream flatMap(IntFunction<? extends IntStream> mapper)

Specified by:

flatMap in interface IntStream

Returns:

the new cache int stream

flatMap

default IntCacheStream flatMap(SerializableIntFunction<? extends IntStream> mapper)

Same as flatMap(IntFunction) except that the IntFunction must also implement Serializable

The compiler will pick this overload for lambda parameters, making them Serializable

Parameters:

mapper - a non-interfering, stateless function to apply to each element which produces a IntStream of new values

Returns:

the new cache int stream

distinct

IntCacheStream distinct()

Specified by:

distinct in interface IntStream

Returns:

the new cache int stream

sorted

IntCacheStream sorted()

Specified by:

sorted in interface IntStream

Returns:

the new cache int stream

peek

IntCacheStream peek(IntConsumer action)

Specified by:

peek in interface IntStream

Returns:

the new cache int stream

peek

default IntCacheStream peek(SerializableIntConsumer action)

Same as flatMap(IntFunction) except that the IntFunction must also implement Serializable

The compiler will pick this overload for lambda parameters, making them Serializable

Parameters:

action - a non-interfering action to perform on the elements as they are consumed from the stream

Returns:

the new cache int stream

limit

IntCacheStream limit(long maxSize)

Specified by:

limit in interface IntStream

Returns:

the new cache int stream

skip

IntCacheStream skip(long n)

Specified by:

skip in interface IntStream

Returns:

the new cache int stream

forEach

default void forEach(SerializableIntConsumer action)

Same as IntStream.forEach(IntConsumer) except that the IntConsumer must also implement Serializable

The compiler will pick this overload for lambda parameters, making them Serializable

Parameters:

action - a non-interfering action to perform on the elements

forEach

<K,V> void forEach(ObjIntConsumer<Cache<K,V>> action)

Same as IntStream.forEach(IntConsumer) except that it takes an ObjIntConsumer that provides access to the underlying Cache that is backing this stream.

Note that the CacheAware interface is not supported for injection using this method as the cache is provided in the consumer directly.

Type Parameters:

K - key type of the cache

V - value type of the cache

Parameters:

action - consumer to be ran for each element in the stream

forEach

default <K,V> void forEach(SerializableObjIntConsumer<Cache<K,V>> action)

Same as forEach(ObjIntConsumer) except that the BiConsumer must also implement Serializable

Type Parameters:

K - key type of the cache

V - value type of the cache

Parameters:

action - consumer to be ran for each element in the stream

reduce

default int reduce(int identity,
                   SerializableIntBinaryOperator op)

Same as IntStream.reduce(int, IntBinaryOperator) except that the IntBinaryOperator must also implement Serializable

The compiler will pick this overload for lambda parameters, making them Serializable

Parameters:

identity - the identity value for the accumulating function

op - an associative, non-interfering, stateless function for combining two values

Returns:

the result of the reduction

reduce

default OptionalInt reduce(SerializableIntBinaryOperator op)

Same as IntStream.reduce(IntBinaryOperator) except that the IntBinaryOperator must also implement Serializable

The compiler will pick this overload for lambda parameters, making them Serializable

Parameters:

op - an associative, non-interfering, stateless function for combining two values

Returns:

the result of the reduction

collect

default <R> R collect(SerializableSupplier<R> supplier,
                      SerializableObjIntConsumer<R> accumulator,
                      SerializableBiConsumer<R,R> combiner)

Same as IntStream.collect(Supplier, ObjIntConsumer, BiConsumer) except that the arguments must also implement Serializable

The compiler will pick this overload for lambda parameters, making them Serializable

Type Parameters:

R - type of the result

Parameters:

supplier - a function that creates a new result container. For a parallel execution, this function may be called multiple times and must return a fresh value each time.

accumulator - an associative, non-interfering, stateless function for incorporating an additional element into a result

combiner - an associative, non-interfering, stateless function for combining two values, which must be compatible with the accumulator function

Returns:

the result of the reduction

anyMatch

default boolean anyMatch(SerializableIntPredicate predicate)

Same as IntStream.anyMatch(IntPredicate) except that the IntPredicate must also implement Serializable

The compiler will pick this overload for lambda parameters, making them Serializable

Parameters:

predicate - a non-interfering, stateless predicate to apply to elements of this stream

Returns:

true if any elements of the stream match the provided predicate, otherwise false

allMatch

default boolean allMatch(SerializableIntPredicate predicate)

Same as IntStream.allMatch(IntPredicate) except that the IntPredicate must also implement Serializable

The compiler will pick this overload for lambda parameters, making them Serializable

Parameters:

predicate - a non-interfering, stateless predicate to apply to elements of this stream

Returns:

true if either all elements of the stream match the provided predicate or the stream is empty, otherwise false

noneMatch

default boolean noneMatch(SerializableIntPredicate predicate)

Same as IntStream.noneMatch(IntPredicate) except that the IntPredicate must also implement Serializable

The compiler will pick this overload for lambda parameters, making them Serializable

Parameters:

predicate - a non-interfering, stateless predicate to apply to elements of this stream

Returns:

true if either no elements of the stream match the provided predicate or the stream is empty, otherwise false

boxed

CacheStream<Integer> boxed()

Specified by:

boxed in interface IntStream

Returns:

the new cache stream containing integers

asDoubleStream

DoubleCacheStream asDoubleStream()

Specified by:

asDoubleStream in interface IntStream

Returns:

the cache double stream

asLongStream

LongCacheStream asLongStream()

Specified by:

asLongStream in interface IntStream

Returns:

the cache long stream

sequential

IntCacheStream sequential()

Specified by:

sequential in interface BaseStream<Integer,IntStream>

Specified by:

sequential in interface IntStream

Returns:

a sequential cache int stream

parallel

IntCacheStream parallel()

Specified by:

parallel in interface BaseStream<Integer,IntStream>

Specified by:

parallel in interface IntStream

Returns:

a parallel cache int stream

unordered

IntCacheStream unordered()

Specified by:

unordered in interface BaseStream<Integer,IntStream>

Returns:

an unordered cache int stream

onClose

IntCacheStream onClose(Runnable closeHandler)

Specified by:

onClose in interface BaseStream<Integer,IntStream>

Returns:

a cache int stream with the handler applied