LongCacheStream (Infinispan JavaDoc All 9.2.5.Final API)

All Superinterfaces:

AutoCloseable, BaseCacheStream<Long,LongStream>, BaseStream<Long,LongStream>, LongStream
```
public interface LongCacheStream
extends LongStream, BaseCacheStream<Long,LongStream>
```
A LongStream that has additional methods to allow for Serializable instances. Please see CacheStream for additional details about various methods.

Since:

9.0

Author:

wburns

Nested Class Summary
- Nested classes/interfaces inherited from interface java.util.stream.LongStream
  LongStream.Builder
- Nested classes/interfaces inherited from interface org.infinispan.BaseCacheStream
  BaseCacheStream.SegmentCompletionListener

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default boolean`	`allMatch(SerializableLongPredicate predicate)` Same as `LongStream.allMatch(LongPredicate)` except that the LongPredicate must also implement Serializable.
`default boolean`	`anyMatch(SerializableLongPredicate predicate)` Same as `LongStream.anyMatch(LongPredicate)` except that the LongPredicate must also implement Serializable.
`DoubleCacheStream`	`asDoubleStream()`
`CacheStream<Long>`	`boxed()`
`default <R> R`	`collect(SerializableSupplier<R> supplier, SerializableObjLongConsumer<R> accumulator, SerializableBiConsumer<R,R> combiner)` Same as `LongStream.collect(Supplier, ObjLongConsumer, BiConsumer)` except that the arguments must also implement Serializable.
`LongCacheStream`	`disableRehashAware()` Disables tracking of rehash events that could occur to the underlying cache.
`LongCacheStream`	`distinct()`
`LongCacheStream`	`distributedBatchSize(int batchSize)` Controls how many keys are returned from a remote node when using a stream terminal operation with a distributed cache to back this stream.
`LongCacheStream`	`filter(LongPredicate predicate)`
`default LongCacheStream`	`filter(SerializableLongPredicate predicate)` Same as `filter(LongPredicate)` except that the LongPredicate must also implement Serializable.
`LongCacheStream`	`filterKeys(Set<?> keys)` Filters which entries are returned by only returning ones that map to the given key.
`LongCacheStream`	`filterKeySegments(Set<Integer> segments)` Filters which entries are returned by what segment they are present in.
`LongCacheStream`	`flatMap(LongFunction<? extends LongStream> mapper)`
`default LongCacheStream`	`flatMap(SerializableLongFunction<? extends LongStream> mapper)` Same as `flatMap(LongFunction)` except that the LongFunction must also implement Serializable.
`<K,V> void`	`forEach(ObjLongConsumer<Cache<K,V>> action)` Same as `LongStream.forEach(LongConsumer)` except that it takes an `ObjLongConsumer` that provides access to the underlying `Cache` that is backing this stream.
`default void`	`forEach(SerializableLongConsumer action)` Same as `LongStream.forEach(LongConsumer)` except that the LongConsumer must also implement Serializable.
`default <K,V> void`	`forEach(SerializableObjLongConsumer<Cache<K,V>> action)` Same as `forEach(ObjLongConsumer)` except that the `BiConsumer` must also implement `Serializable`
`LongCacheStream`	`limit(long maxSize)`
`LongCacheStream`	`map(LongUnaryOperator mapper)`
`default LongCacheStream`	`map(SerializableLongUnaryOperator mapper)` Same as `map(LongUnaryOperator)` except that the LongUnaryOperator must also implement Serializable.
`DoubleCacheStream`	`mapToDouble(LongToDoubleFunction mapper)`
`default DoubleCacheStream`	`mapToDouble(SerializableLongToDoubleFunction mapper)` Same as `mapToDouble(LongToDoubleFunction)` except that the LongToLongFunction must also implement Serializable.
`IntCacheStream`	`mapToInt(LongToIntFunction mapper)`
`default IntCacheStream`	`mapToInt(SerializableLongToIntFunction mapper)` Same as `mapToInt(LongToIntFunction)` except that the LongToIntFunction must also implement Serializable.
`<U> CacheStream<U>`	`mapToObj(LongFunction<? extends U> mapper)`
`default <U> CacheStream<U>`	`mapToObj(SerializableLongFunction<? extends U> mapper)` Same as `mapToObj(LongFunction)` except that the LongFunction must also implement Serializable.
`default boolean`	`noneMatch(SerializableLongPredicate predicate)` Same as `LongStream.noneMatch(LongPredicate)` except that the LongPredicate must also implement Serializable.
`LongCacheStream`	`onClose(Runnable closeHandler)`
`LongCacheStream`	`parallel()`
`LongCacheStream`	`parallelDistribution()` This would enable sending requests to all other remote nodes when a terminal operator is performed.
`LongCacheStream`	`peek(LongConsumer action)`
`default LongCacheStream`	`peek(SerializableLongConsumer action)` Same as `flatMap(LongFunction)` except that the LongFunction must also implement Serializable.
`default long`	`reduce(long identity, SerializableLongBinaryOperator op)` Same as `LongStream.reduce(long, LongBinaryOperator)` except that the LongBinaryOperator must also implement Serializable.
`default OptionalLong`	`reduce(SerializableLongBinaryOperator op)` Same as `LongStream.reduce(LongBinaryOperator)` except that the LongBinaryOperator must also implement Serializable.
`LongCacheStream`	`segmentCompletionListener(BaseCacheStream.SegmentCompletionListener listener)` Allows registration of a segment completion listener that is notified when a segment has completed processing.
`LongCacheStream`	`sequential()`
`LongCacheStream`	`sequentialDistribution()` This would disable sending requests to all other remote nodes compared to one at a time.
`LongCacheStream`	`skip(long n)`
`LongCacheStream`	`sorted()`
`LongCacheStream`	`timeout(long timeout, TimeUnit unit)` Sets a given time to wait for a remote operation to respond by.
`LongCacheStream`	`unordered()`

Methods inherited from interface java.util.stream.LongStream
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
  - sequentialDistribution
```
LongCacheStream sequentialDistribution()
```
    This would disable sending requests to all other remote nodes compared to one at a time. This can reduce memory pressure on the originator node at the cost of performance.
    Parallel distribution is enabled by default except for CacheStream.iterator() & CacheStream.spliterator()
    
    Specified by:
    
    sequentialDistribution in interface BaseCacheStream<Long,LongStream>
    
    Returns:
    
    a stream with parallel distribution disabled.
  - parallelDistribution
```
LongCacheStream parallelDistribution()
```
    Description copied from interface: BaseCacheStream
    
    This would enable sending requests to all other remote nodes when a terminal operator is performed. This requires additional overhead as it must process results concurrently from various nodes, but should perform faster in the majority of cases.
    Parallel distribution is enabled by default except for CacheStream.iterator() & CacheStream.spliterator()
    
    Specified by:
    
    parallelDistribution in interface BaseCacheStream<Long,LongStream>
    
    Returns:
    
    a stream with parallel distribution enabled.
  - filterKeySegments
```
LongCacheStream filterKeySegments(Set<Integer> segments)
```
    Filters which entries are returned by what segment they are present in. This method can be substantially more efficient than using a regular CacheStream.filter(Predicate) method as this can control what nodes are asked for data and what entries are read from the underlying CacheStore if present.
    
    Specified by:
    
    filterKeySegments in interface BaseCacheStream<Long,LongStream>
    
    Parameters:
    
    segments - The segments to use for this stream operation. Any segments not in this set will be ignored.
    
    Returns:
    
    a stream with the segments filtered.
  - filterKeys
```
LongCacheStream filterKeys(Set<?> keys)
```
    Filters which entries are returned by only returning ones that map to the given key. This method will be faster than a regular CacheStream.filter(Predicate) if the filter is holding references to the same keys.
    
    Specified by:
    
    filterKeys in interface BaseCacheStream<Long,LongStream>
    
    Parameters:
    
    keys - The keys that this stream will only operate on.
    
    Returns:
    
    a stream with the keys filtered.
  - distributedBatchSize
```
LongCacheStream distributedBatchSize(int batchSize)
```
    Controls how many keys are returned from a remote node when using a stream terminal operation with a distributed cache to back this stream. This value is ignored when terminal operators that don't track keys are used. Key tracking terminal operators are CacheStream.iterator(), CacheStream.spliterator(), CacheStream.forEach(Consumer). Please see those methods for additional information on how this value may affect them.
    This value may be used in the case of a a terminal operator that doesn't track keys if an intermediate operation is performed that requires bringing keys locally to do computations. Examples of such intermediate operations are CacheStream.sorted(), CacheStream.sorted(Comparator), CacheStream.distinct(), CacheStream.limit(long), CacheStream.skip(long)
    
    This value is always ignored when this stream is backed by a cache that is not distributed as all values are already local.
    
    Specified by:
    
    distributedBatchSize in interface BaseCacheStream<Long,LongStream>
    
    Parameters:
    
    batchSize - The size of each batch. This defaults to the state transfer chunk size.
    
    Returns:
    
    a stream with the batch size updated
  - segmentCompletionListener
```
LongCacheStream segmentCompletionListener(BaseCacheStream.SegmentCompletionListener listener)
```
    Allows registration of a segment completion listener that is notified when a segment has completed processing. If the terminal operator has a short circuit this listener may never be called.
    This method is designed for the sole purpose of use with the CacheStream.iterator() to allow for a user to track completion of segments as they are returned from the iterator. Behavior of other methods is not specified. Please see CacheStream.iterator() for more information.
    
    Multiple listeners may be registered upon multiple invocations of this method. The ordering of notified listeners is not specified.
    
    This is only used if this stream did not invoke BaseCacheStream.disableRehashAware() and has no flat map based operations. If this is done no segments will be notified.
    
    Specified by:
    
    segmentCompletionListener in interface BaseCacheStream<Long,LongStream>
    
    Parameters:
    
    listener - The listener that will be called back as segments are completed.
    
    Returns:
    
    a stream with the listener registered.
  - disableRehashAware
```
LongCacheStream disableRehashAware()
```
    Disables tracking of rehash events that could occur to the underlying cache. If a rehash event occurs while a terminal operation is being performed it is possible for some values that are in the cache to not be found. Note that you will never have an entry duplicated when rehash awareness is disabled, only lost values.
    Most terminal operations will run faster with rehash awareness disabled even without a rehash occuring. However if a rehash occurs with this disabled be prepared to possibly receive only a subset of values.
    
    Specified by:
    
    disableRehashAware in interface BaseCacheStream<Long,LongStream>
    
    Returns:
    
    a stream with rehash awareness disabled.
  - timeout
```
LongCacheStream timeout(long timeout,
                        TimeUnit unit)
```
    Sets a given time to wait for a remote operation to respond by. This timeout does nothing if the terminal operation does not go remote.
    If a timeout does occur then a TimeoutException is thrown from the terminal operation invoking thread or on the next call to the Iterator or Spliterator.
    
    Note that if a rehash occurs this timeout value is reset for the subsequent retry if rehash aware is enabled.
    
    Specified by:
    
    timeout in interface BaseCacheStream<Long,LongStream>
    
    Parameters:
    
    timeout - the maximum time to wait
    
    unit - the time unit of the timeout argument
    
    Returns:
    
    a stream with the timeout set
  - filter
```
LongCacheStream filter(LongPredicate predicate)
```
    Specified by:
    
    filter in interface LongStream
    
    Returns:
    
    the new cache long stream
  - filter
```
default LongCacheStream filter(SerializableLongPredicate predicate)
```
    Same as filter(LongPredicate) except that the LongPredicate must also implement Serializable.
    This method will be used automatically by lambdas, which prevents users from having to manually cast to a Serializable lambda.
    
    Parameters:
    
    predicate - a non-interfering, stateless predicate to apply to each element to determine if it should be included
    
    Returns:
    
    the new cache long stream
  - map
```
LongCacheStream map(LongUnaryOperator mapper)
```
    Specified by:
    
    map in interface LongStream
    
    Returns:
    
    the new cache long stream
  - map
```
default LongCacheStream map(SerializableLongUnaryOperator mapper)
```
    Same as map(LongUnaryOperator) except that the LongUnaryOperator must also implement Serializable.
    This method will be used automatically by lambdas, which prevents users from having to manually cast to a Serializable lambda.
    
    Parameters:
    
    mapper - a non-interfering, stateless function to apply to each element
    
    Returns:
    
    the new cache long stream
  - mapToObj
```
<U> CacheStream<U> mapToObj(LongFunction<? extends U> mapper)
```
    Specified by:
    
    mapToObj in interface LongStream
    
    Returns:
    
    the new cache stream
  - mapToObj
```
default <U> CacheStream<U> mapToObj(SerializableLongFunction<? extends U> mapper)
```
    Same as mapToObj(LongFunction) except that the LongFunction must also implement Serializable.
    This method will be used automatically by lambdas, which prevents users from having to manually cast to a Serializable lambda.
    
    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
  - mapToInt
```
IntCacheStream mapToInt(LongToIntFunction mapper)
```
    Specified by:
    
    mapToInt in interface LongStream
    
    Returns:
    
    the new cache int stream
  - mapToInt
```
default IntCacheStream mapToInt(SerializableLongToIntFunction mapper)
```
    Same as mapToInt(LongToIntFunction) except that the LongToIntFunction must also implement Serializable.
    This method will be used automatically by lambdas, which prevents users from having to manually cast to a Serializable lambda.
    
    Parameters:
    
    mapper - a non-interfering, stateless function to apply to each element
    
    Returns:
    
    the new cache int stream
  - mapToDouble
```
DoubleCacheStream mapToDouble(LongToDoubleFunction mapper)
```
    Specified by:
    
    mapToDouble in interface LongStream
    
    Returns:
    
    the new cache double stream
  - mapToDouble
```
default DoubleCacheStream mapToDouble(SerializableLongToDoubleFunction mapper)
```
    Same as mapToDouble(LongToDoubleFunction) except that the LongToLongFunction must also implement Serializable.
    This method will be used automatically by lambdas, which prevents users from having to manually cast to a Serializable lambda.
    
    Parameters:
    
    mapper - a non-interfering, stateless function to apply to each element
    
    Returns:
    
    the new cache double stream
  - flatMap
```
LongCacheStream flatMap(LongFunction<? extends LongStream> mapper)
```
    Specified by:
    
    flatMap in interface LongStream
    
    Returns:
    
    the new cache long stream
  - flatMap
```
default LongCacheStream flatMap(SerializableLongFunction<? extends LongStream> mapper)
```
    Same as flatMap(LongFunction) except that the LongFunction must also implement Serializable.
    This method will be used automatically by lambdas, which prevents users from having to manually cast to a Serializable lambda.
    
    Parameters:
    
    mapper - a non-interfering, stateless function to apply to each element which produces a LongStream of new values
    
    Returns:
    
    the new cache long stream
  - distinct
```
LongCacheStream distinct()
```
    Specified by:
    
    distinct in interface LongStream
    
    Returns:
    
    the new cache long stream
  - sorted
```
LongCacheStream sorted()
```
    Specified by:
    
    sorted in interface LongStream
    
    Returns:
    
    the new cache long stream
  - peek
```
LongCacheStream peek(LongConsumer action)
```
    Specified by:
    
    peek in interface LongStream
    
    Returns:
    
    the new cache long stream
  - peek
```
default LongCacheStream peek(SerializableLongConsumer action)
```
    Same as flatMap(LongFunction) except that the LongFunction must also implement Serializable.
    This method will be used automatically by lambdas, which prevents users from having to manually cast to a Serializable lambda.
    
    Parameters:
    
    action - a non-interfering action to perform on the elements as they are consumed from the stream
    
    Returns:
    
    the new cache long stream
  - limit
```
LongCacheStream limit(long maxSize)
```
    Specified by:
    
    limit in interface LongStream
    
    Returns:
    
    the new cache long stream
  - skip
```
LongCacheStream skip(long n)
```
    Specified by:
    
    skip in interface LongStream
    
    Returns:
    
    the new cache long stream
  - forEach
```
default void forEach(SerializableLongConsumer action)
```
    Same as LongStream.forEach(LongConsumer) except that the LongConsumer must also implement Serializable.
    This method will be used automatically by lambdas, which prevents users from having to manually cast to a Serializable lambda.
    
    Parameters:
    
    action - a non-interfering action to perform on the elements
  - forEach
```
<K,V> void forEach(ObjLongConsumer<Cache<K,V>> action)
```
    Same as LongStream.forEach(LongConsumer) except that it takes an ObjLongConsumer 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(SerializableObjLongConsumer<Cache<K,V>> action)
```
    Same as forEach(ObjLongConsumer) 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 long reduce(long identity,
                    SerializableLongBinaryOperator op)
```
    Same as LongStream.reduce(long, LongBinaryOperator) except that the LongBinaryOperator must also implement Serializable.
    This method will be used automatically by lambdas, which prevents users from having to manually cast to a Serializable lambda.
    
    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 OptionalLong reduce(SerializableLongBinaryOperator op)
```
    Same as LongStream.reduce(LongBinaryOperator) except that the LongBinaryOperator must also implement Serializable.
    This method will be used automatically by lambdas, which prevents users from having to manually cast to a Serializable lambda.
    
    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,
                      SerializableObjLongConsumer<R> accumulator,
                      SerializableBiConsumer<R,R> combiner)
```
    Same as LongStream.collect(Supplier, ObjLongConsumer, BiConsumer) except that the arguments must also implement Serializable.
    This method will be used automatically by lambdas, which prevents users from having to manually cast to a Serializable lambda.
    
    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(SerializableLongPredicate predicate)
```
    Same as LongStream.anyMatch(LongPredicate) except that the LongPredicate must also implement Serializable.
    This method will be used automatically by lambdas, which prevents users from having to manually cast to a Serializable lambda.
    
    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(SerializableLongPredicate predicate)
```
    Same as LongStream.allMatch(LongPredicate) except that the LongPredicate must also implement Serializable.
    This method will be used automatically by lambdas, which prevents users from having to manually cast to a Serializable lambda.
    
    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(SerializableLongPredicate predicate)
```
    Same as LongStream.noneMatch(LongPredicate) except that the LongPredicate must also implement Serializable.
    This method will be used automatically by lambdas, which prevents users from having to manually cast to a Serializable lambda.
    
    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<Long> boxed()
```
    Specified by:
    
    boxed in interface LongStream
    
    Returns:
    
    the new cache stream containing longs
  - asDoubleStream
```
DoubleCacheStream asDoubleStream()
```
    Specified by:
    
    asDoubleStream in interface LongStream
    
    Returns:
    
    the cache double stream
  - sequential
```
LongCacheStream sequential()
```
    Specified by:
    
    sequential in interface BaseStream<Long,LongStream>
    
    Specified by:
    
    sequential in interface LongStream
    
    Returns:
    
    a sequential cache long stream
  - parallel
```
LongCacheStream parallel()
```
    Specified by:
    
    parallel in interface BaseStream<Long,LongStream>
    
    Specified by:
    
    parallel in interface LongStream
    
    Returns:
    
    a parallel cache long stream
  - unordered
```
LongCacheStream unordered()
```
    Specified by:
    
    unordered in interface BaseStream<Long,LongStream>
    
    Returns:
    
    an unordered cache long stream
  - onClose
```
LongCacheStream onClose(Runnable closeHandler)
```
    Specified by:
    
    onClose in interface BaseStream<Long,LongStream>
    
    Returns:
    
    a cache long stream with the handler applied

Interface LongCacheStream

Nested Class Summary

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

Nested classes/interfaces inherited from interface org.infinispan.BaseCacheStream

Method Summary

Methods inherited from interface java.util.stream.LongStream

Methods inherited from interface java.util.stream.BaseStream

Method Detail

sequentialDistribution

parallelDistribution

filterKeySegments

filterKeys

distributedBatchSize

segmentCompletionListener

disableRehashAware

timeout

filter

filter

map

map

mapToObj

mapToObj

mapToInt

mapToInt

mapToDouble

mapToDouble

flatMap

flatMap

distinct

sorted

peek

peek

limit

skip

forEach

forEach

forEach

reduce

reduce

collect

anyMatch

allMatch

noneMatch

boxed

asDoubleStream

sequential

parallel

unordered

onClose