Package com.landawn.abacus.util.stream

Class EntryStream<K,V>

java.lang.Object

com.landawn.abacus.util.stream.EntryStream<K,V>

All Implemented Interfaces:

Immutable, BaseStream<Map.Entry<K,V>,Object[],Predicate<? super Map.Entry<K,V>>,Consumer<? super Map.Entry<K,V>>,List<Map.Entry<K,V>>,u.Optional<Map.Entry<K,V>>,Indexed<Map.Entry<K,V>>,ObjIterator<Map.Entry<K,V>>,EntryStream<K,V>>, Closeable, AutoCloseable

@Immutable
public final class EntryStream<K,V>
extends Object

The Stream will be automatically closed after execution(A terminal method is executed/triggered).

See Also:

• BaseStream
• Stream
• IntStream
• LongStream
• DoubleStream
• EntryStream
• ExceptionalStream
• Collectors
• Fn
• Comparators

Nested Class Summary

Nested classes/interfaces inherited from interface com.landawn.abacus.util.stream.BaseStream

BaseStream.ParallelSettings, BaseStream.Splitor

Method Summary

Modifier and Type	Method	Description
<SS extends BaseStream> SS	__(Function<? super EntryStream<K,V>,? extends SS> transfer)
<E extends Exception> If.OrElse	acceptIfNotEmpty(Throwables.Consumer<? super EntryStream<K,V>,E> action)	This is a terminal operation.
<E extends Exception> boolean	allMatch(Throwables.BiPredicate<? super K,? super V,E> predicate)
<E extends Exception> boolean	allMatch(Throwables.Predicate<? super Map.Entry<K,V>,E> predicate)
<E extends Exception> boolean	anyMatch(Throwables.BiPredicate<? super K,? super V,E> predicate)
<E extends Exception> boolean	anyMatch(Throwables.Predicate<? super Map.Entry<K,V>,E> predicate)
EntryStream<K,V>	append(EntryStream<K,V> stream)
EntryStream<K,V>	append(u.Optional<Map.Entry<K,V>> op)
<M extends Map<? extends K, ? extends V>> EntryStream<K,V>	append(M map)
EntryStream<K,V>	appendIfEmpty(Supplier<? extends EntryStream<K,V>> supplier)
<M extends Map<? extends K, ? extends V>> EntryStream<K,V>	appendIfEmpty(M map)
<R, E extends Exception> u.Optional<R>	applyIfNotEmpty(Throwables.Function<? super EntryStream<K,V>,R,E> func)	This is a terminal operation.
BiIterator<K,V>	biIterator()	Remember to close this Stream after the iteration is done, if needed.
<KK, VV> EntryStream<KK,VV>	chain(Function<? super Stream<Map.Entry<K,V>>,? extends Stream<Map.Entry<KK,VV>>> transfer)
void	close()	It will be called by terminal operations in final.
Stream<List<V>>	collapseByKey(BiPredicate<? super K,? super K> collapsible)
<R, A> Stream<R>	collapseByKey(BiPredicate<? super K,? super K> collapsible, Collector<? super V,A,R> collector)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
<R> R	collect(Supplier<R> supplier, BiConsumer<? super R,? super Map.Entry<K,V>> accumulator)
<R> R	collect(Supplier<R> supplier, BiConsumer<? super R,? super Map.Entry<K,V>> accumulator, BiConsumer<R,R> combiner)
<R, A> R	collect(Collector<? super Map.Entry<K,V>,A,R> collector)
<R, A, RR, E extends Exception> RR	collectAndThen(Collector<? super Map.Entry<K,V>,A,R> downstream, Throwables.Function<? super R,RR,E> finisher)
static <K, V> EntryStream<K,V>	concat(Collection<? extends Map<K,V>> maps)
static <K, V> EntryStream<K,V>	concat(Map<K,V>... maps)
long	count()
EntryStream<K,V>	cycled()	This method only runs sequentially, even in parallel stream and retrieved elements will be saved in memory for next cycle.
EntryStream<K,V>	cycled(long rounds)	This method only runs sequentially, even in parallel stream and retrieved elements will be saved in memory for next cycle.
EntryStream<K,V>	difference(Collection<?> c)	This method only runs sequentially, even in parallel stream.
EntryStream<K,V>	distinct()	Returns a stream consisting of the distinct elements of this stream.
EntryStream<K,V>	distinct(BinaryOperator<Map.Entry<K,V>> mergeFunction)
EntryStream<K,V>	distinct(Predicate<? super Long> occurrencesFilter)
EntryStream<K,V>	distinctBy(Function<? super Map.Entry<K,V>,?> keyMapper)
EntryStream<K,V>	distinctBy(Function<? super Map.Entry<K,V>,?> keyMapper, BinaryOperator<Map.Entry<K,V>> mergeFunction)
EntryStream<K,V>	distinctBy(Function<? super Map.Entry<K,V>,?> keyMapper, Predicate<? super Long> occurrencesFilter)
EntryStream<K,V>	distinctByKey()
EntryStream<K,V>	distinctByValue()
EntryStream<K,V>	dropWhile(BiPredicate<? super K,? super V> predicate)
EntryStream<K,V>	dropWhile(Predicate<? super Map.Entry<K,V>> predicate)	Remove the elements until the given predicate returns false.
EntryStream<K,V>	dropWhile(Predicate<? super Map.Entry<K,V>> predicate, Consumer<? super Map.Entry<K,V>> actionOnDroppedItem)	Remove the elements until the given predicate returns false.
u.Optional<Map.Entry<K,V>>	elementAt(long position)
static <K, V> EntryStream<K,V>	empty()
Stream<Map.Entry<K,V>>	entries()
EntryStream<K,V>	filter(BiPredicate<? super K,? super V> predicate)
EntryStream<K,V>	filter(Predicate<? super Map.Entry<K,V>> predicate)	Returns a stream consisting of the elements of this stream that match the given predicate.
EntryStream<K,V>	filter(Predicate<? super Map.Entry<K,V>> predicate, Consumer<? super Map.Entry<K,V>> actionOnDroppedItem)	Returns a stream consisting of the elements of this stream that match the given predicate.
EntryStream<K,V>	filterByKey(Predicate<? super K> keyPredicate)
EntryStream<K,V>	filterByValue(Predicate<? super V> valuePredicate)
<E extends Exception> u.Optional<Map.Entry<K,V>>	findAny(Throwables.BiPredicate<? super K,? super V,E> predicate)
<E extends Exception> u.Optional<Map.Entry<K,V>>	findAny(Throwables.Predicate<? super Map.Entry<K,V>,E> predicate)
<E extends Exception> u.Optional<Map.Entry<K,V>>	findFirst(Throwables.BiPredicate<? super K,? super V,E> predicate)
<E extends Exception> u.Optional<Map.Entry<K,V>>	findFirst(Throwables.Predicate<? super Map.Entry<K,V>,E> predicate)
u.Optional<Map.Entry<K,V>>	first()
<KK, VV> EntryStream<KK,VV>	flatMap(BiFunction<? super K,? super V,? extends EntryStream<? extends KK,? extends VV>> mapper)
<KK, VV> EntryStream<KK,VV>	flatMap(Function<? super Map.Entry<K,V>,? extends EntryStream<? extends KK,? extends VV>> mapper)
<KK> EntryStream<KK,V>	flatMapKey(BiFunction<? super K,? super V,? extends Stream<? extends KK>> keyMapper)
<KK> EntryStream<KK,V>	flatMapKey(Function<? super K,? extends Stream<? extends KK>> keyMapper)
<KK> EntryStream<KK,V>	flatMapKeyToDisposableEntry(Function<? super K,? extends Stream<? extends KK>> keyMapper)	Deprecated.
<KK, VV> EntryStream<KK,VV>	flatMapp(BiFunction<? super K,? super V,? extends Stream<? extends Map.Entry<? extends KK,? extends VV>>> mapper)
<KK, VV> EntryStream<KK,VV>	flatMapp(Function<? super Map.Entry<K,V>,? extends Stream<? extends Map.Entry<? extends KK,? extends VV>>> mapper)
<VV> EntryStream<K,VV>	flatMapValue(BiFunction<? super K,? super V,? extends Stream<? extends VV>> valueMapper)
<VV> EntryStream<K,VV>	flatMapValue(Function<? super V,? extends Stream<? extends VV>> valueMapper)
<VV> EntryStream<K,VV>	flatMapValueToDisposableEntry(Function<? super V,? extends Stream<? extends VV>> valueMapper)	Deprecated.
<KK, VV> EntryStream<KK,VV>	flattMap(BiFunction<? super K,? super V,? extends Map<? extends KK,? extends VV>> mapper)
<KK, VV> EntryStream<KK,VV>	flattMap(Function<? super Map.Entry<K,V>,? extends Map<? extends KK,? extends VV>> mapper)
<KK> EntryStream<KK,V>	flattMapKey(BiFunction<? super K,? super V,? extends Collection<? extends KK>> keyMapper)
<KK> EntryStream<KK,V>	flattMapKey(Function<? super K,? extends Collection<? extends KK>> keyMapper)
<KK> EntryStream<KK,V>	flattMapKeyToDisposableEntry(Function<? super K,? extends Collection<? extends KK>> keyMapper)	Deprecated.
<VV> EntryStream<K,VV>	flattMapValue(BiFunction<? super K,? super V,? extends Collection<? extends VV>> valueMapper)
<VV> EntryStream<K,VV>	flattMapValue(Function<? super V,? extends Collection<? extends VV>> valueMapper)
<VV> EntryStream<K,VV>	flattMapValueToDisposableEntry(Function<? super V,? extends Collection<? extends VV>> valueMapper)	Deprecated.
<E extends Exception> void	forEach(Throwables.BiConsumer<? super K,? super V,E> action)
<E extends Exception> void	forEach(Throwables.Consumer<? super Map.Entry<K,V>,E> action)
<E extends Exception> void	forEachIndexed(Throwables.IndexedConsumer<? super Map.Entry<K,V>,E> action)
EntryStream<K,List<V>>	groupBy()
EntryStream<K,V>	groupBy(BinaryOperator<V> mergeFunction)
EntryStream<K,V>	groupBy(BinaryOperator<V> mergeFunction, Supplier<? extends Map<K,V>> mapFactory)
<KK, VV> EntryStream<KK,List<VV>>	groupBy(Function<? super Map.Entry<K,V>,? extends KK> keyMapper, Function<? super Map.Entry<K,V>,? extends VV> valueMapper)
<KK, VV> EntryStream<KK,VV>	groupBy(Function<? super Map.Entry<K,V>,? extends KK> keyMapper, Function<? super Map.Entry<K,V>,? extends VV> valueMapper, BinaryOperator<VV> mergeFunction)
<KK, VV> EntryStream<KK,VV>	groupBy(Function<? super Map.Entry<K,V>,? extends KK> keyMapper, Function<? super Map.Entry<K,V>,? extends VV> valueMapper, BinaryOperator<VV> mergeFunction, Supplier<? extends Map<KK,VV>> mapFactory)
<KK, VV> EntryStream<KK,List<VV>>	groupBy(Function<? super Map.Entry<K,V>,? extends KK> keyMapper, Function<? super Map.Entry<K,V>,? extends VV> valueMapper, Supplier<? extends Map<KK,List<VV>>> mapFactory)
<KK, A, D> EntryStream<KK,D>	groupBy(Function<? super Map.Entry<K,V>,? extends KK> keyMapper, Collector<? super Map.Entry<K,V>,A,D> downstream)
<KK, A, D> EntryStream<KK,D>	groupBy(Function<? super Map.Entry<K,V>,? extends KK> keyMapper, Collector<? super Map.Entry<K,V>,A,D> downstream, Supplier<? extends Map<KK,D>> mapFactory)
EntryStream<K,List<V>>	groupBy(Supplier<? extends Map<K,List<V>>> mapFactory)
<A, D> EntryStream<K,D>	groupBy(Collector<? super Map.Entry<K,V>,A,D> downstream)
<A, D> EntryStream<K,D>	groupBy(Collector<? super Map.Entry<K,V>,A,D> downstream, Supplier<? extends Map<K,D>> mapFactory)
Map<K,List<V>>	groupTo()
<M extends Map<K, List<V>>> M	groupTo(Supplier<? extends M> mapFactory)
<R, E extends Exception> R	groupToAndThen(Throwables.Function<? super Map<K,List<V>>,R,E> func)
Stream<Indexed<Map.Entry<K,V>>>	indexed()	This method only runs sequentially, even in parallel stream.
EntryStream<K,V>	intersection(Collection<?> c)	This method only runs sequentially, even in parallel stream.
EntryStream<V,K>	inversed()
EntryStream<V,K>	inversedToDisposableEntry()	Deprecated.
boolean	isParallel()
ObjIterator<Map.Entry<K,V>>	iterator()	Remember to close this Stream after the iteration is done, if needed.
String	join(CharSequence delimiter)
String	join(CharSequence delimiter, CharSequence keyValueDelimiter)
String	join(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
String	join(CharSequence delimiter, CharSequence keyValueDelimiter, CharSequence prefix, CharSequence suffix)
Stream<K>	keys()
u.Optional<Map.Entry<K,V>>	last()
EntryStream<K,V>	limit(long maxSize)
<KK, VV> EntryStream<KK,VV>	map(BiFunction<? super K,? super V,? extends Map.Entry<? extends KK,? extends VV>> mapper)
<KK, VV> EntryStream<KK,VV>	map(BiFunction<? super K,? super V,? extends KK> keyMapper, BiFunction<? super K,? super V,? extends VV> valueMapper)
<KK, VV> EntryStream<KK,VV>	map(Function<? super Map.Entry<K,V>,? extends Map.Entry<? extends KK,? extends VV>> mapper)
<KK, VV> EntryStream<KK,VV>	map(Function<? super Map.Entry<K,V>,? extends KK> keyMapper, Function<? super Map.Entry<K,V>,? extends VV> valueMapper)
<KK> EntryStream<KK,V>	mapKey(BiFunction<? super K,? super V,? extends KK> keyMapper)
<KK> EntryStream<KK,V>	mapKey(Function<? super K,? extends KK> keyMapper)
<KK> EntryStream<KK,V>	mapKeyPartial(BiFunction<? super K,? super V,u.Optional<? extends KK>> keyMapper)
<KK> EntryStream<KK,V>	mapKeyPartial(Function<? super K,u.Optional<? extends KK>> keyMapper)
<KK, VV> EntryStream<KK,VV>	mapMulti(BiConsumer<? super Map.Entry<K,V>,? super Consumer<Map.Entry<KK,VV>>> mapper)
<KK, VV> EntryStream<KK,VV>	mapPartial(BiFunction<? super K,? super V,u.Optional<? extends Map.Entry<? extends KK,? extends VV>>> mapper)
<KK, VV> EntryStream<KK,VV>	mapPartial(Function<? super Map.Entry<K,V>,u.Optional<? extends Map.Entry<? extends KK,? extends VV>>> mapper)
<KK, VV> EntryStream<KK,VV>	mapToDisposableEntry(BiFunction<? super K,? super V,? extends KK> keyMapper, BiFunction<? super K,? super V,? extends VV> valueMapper)	Deprecated.
<KK, VV> EntryStream<KK,VV>	mapToDisposableEntry(Function<? super Map.Entry<K,V>,? extends KK> keyMapper, Function<? super Map.Entry<K,V>,? extends VV> valueMapper)	Deprecated.
<VV> EntryStream<K,VV>	mapValue(BiFunction<? super K,? super V,? extends VV> valueMapper)
<VV> EntryStream<K,VV>	mapValue(Function<? super V,? extends VV> valueMapper)
<VV> EntryStream<K,VV>	mapValuePartial(BiFunction<? super K,? super V,u.Optional<? extends VV>> valueMapper)
<VV> EntryStream<K,VV>	mapValuePartial(Function<? super V,u.Optional<? extends VV>> valueMapper)
u.Optional<Map.Entry<K,V>>	max(Comparator<? super Map.Entry<K,V>> comparator)
u.Optional<Map.Entry<K,V>>	maxBy(Function<? super Map.Entry<K,V>,? extends Comparable> keyMapper)
u.Optional<Map.Entry<K,V>>	maxByKey(Comparator<? super K> keyComparator)
u.Optional<Map.Entry<K,V>>	maxByValue(Comparator<? super V> valueComparator)
static <K, V> EntryStream<K,V>	merge(Collection<? extends Map<K,V>> maps, BiFunction<? super Map.Entry<K,V>,? super Map.Entry<K,V>,MergeResult> nextSelector)
static <K, V> EntryStream<K,V>	merge(Map<K,V> a, Map<K,V> b, BiFunction<? super Map.Entry<K,V>,? super Map.Entry<K,V>,MergeResult> nextSelector)
static <K, V> EntryStream<K,V>	merge(Map<K,V> a, Map<K,V> b, Map<K,V> c, BiFunction<? super Map.Entry<K,V>,? super Map.Entry<K,V>,MergeResult> nextSelector)
u.Optional<Map.Entry<K,V>>	min(Comparator<? super Map.Entry<K,V>> comparator)
u.Optional<Map.Entry<K,V>>	minBy(Function<? super Map.Entry<K,V>,? extends Comparable> keyMapper)
u.Optional<Map.Entry<K,V>>	minByKey(Comparator<? super K> keyComparator)
u.Optional<Map.Entry<K,V>>	minByValue(Comparator<? super V> valueComparator)
<E extends Exception> boolean	noneMatch(Throwables.BiPredicate<? super K,? super V,E> predicate)
<E extends Exception> boolean	noneMatch(Throwables.Predicate<? super Map.Entry<K,V>,E> predicate)
static <E> EntryStream<E,Long>	of(LongMultiset<E> multiset)
static <K, E, V extends Collection<E>> EntryStream<K,V>	of(Multimap<K,E,V> mulitmap)
static <E> EntryStream<E,Integer>	of(Multiset<E> multiset)
static <K, V> EntryStream<K,V>	of(Iterable<? extends Map.Entry<? extends K,? extends V>> entries)
static <K, T> EntryStream<K,T>	of(Iterable<? extends T> c, Function<? super T,K> keyMapper)
static <K, V> EntryStream<K,V>	of(Iterator<? extends Map.Entry<? extends K,? extends V>> iterator)
static <K, T> EntryStream<K,T>	of(Iterator<? extends T> iter, Function<? super T,K> keyMapper)
static <K, V> EntryStream<K,V>	of(Map<? extends K,? extends V> map)
static <K, V> EntryStream<K,V>	of(K k1, V v1)
static <K, V> EntryStream<K,V>	of(K k1, V v1, K k2, V v2)
static <K, V> EntryStream<K,V>	of(K k1, V v1, K k2, V v2, K k3, V v3)
static <K, V> EntryStream<K,V>	of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4)
static <K, V> EntryStream<K,V>	of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5)
static <K, V> EntryStream<K,V>	of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6)
static <K, V> EntryStream<K,V>	of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7)
static <K, T> EntryStream<K,T>	of(T[] a, Function<? super T,K> keyMapper)
static <K, V> EntryStream<K,V>	ofNullable(Map.Entry<K,V> entry)
EntryStream<K,V>	onClose(Runnable closeHandler)
EntryStream<K,V>	onEach(BiConsumer<? super K,? super V> action)
EntryStream<K,V>	onEach(Consumer<? super Map.Entry<K,V>> action)	Same as peek
u.Optional<Map.Entry<K,V>>	onlyOne()
EntryStream<K,V>	parallel()	Consider using sps(Function) if only next operation need to be parallelized.
EntryStream<K,V>	parallel(int threadNum)	Consider using sps(int, Function) if only next operation need to be parallelized.
EntryStream<K,V>	parallel(int maxThreadNum, BaseStream.Splitor splitor)	Returns an equivalent stream that is parallel.
EntryStream<K,V>	parallel(int maxThreadNum, BaseStream.Splitor splitor, Executor executor)	Consider using sps(ParallelSettings, Function) if only next operation need to be parallelized.
EntryStream<K,V>	parallel(int maxThreadNum, Executor executor)	Consider using sps(ParallelSettings, Function) if only next operation need to be parallelized.
EntryStream<K,V>	parallel(BaseStream.ParallelSettings ps)	Consider using sps(ParallelSettings, Function) if only next operation need to be parallelized.
EntryStream<K,V>	parallel(BaseStream.Splitor splitor)	Consider using sps(ParallelSettings, Function) if only next operation need to be parallelized.
EntryStream<K,V>	parallel(Executor executor)	Consider using sps(ParallelSettings, Function) if only next operation need to be parallelized.
EntryStream<K,V>	peek(BiConsumer<? super K,? super V> action)
EntryStream<K,V>	peek(Consumer<? super Map.Entry<K,V>> action)
u.Optional<Map<Percentage,Map.Entry<K,V>>>	percentiles()	All elements will be loaded to memory and sorted if not yet.
EntryStream<K,V>	prepend(EntryStream<K,V> stream)
EntryStream<K,V>	prepend(u.Optional<Map.Entry<K,V>> op)
<M extends Map<? extends K, ? extends V>> EntryStream<K,V>	prepend(M map)
void	println()
<SS extends BaseStream> SS	psp(Function<? super EntryStream<K,V>,? extends SS> ops)	Temporarily switch the stream to sequence stream for operation ops and then switch back to parallel stream with same maxThreadNum/splitor/asyncExecutor.
EntryStream<K,V>	rateLimited(double permitsPerSecond)
EntryStream<K,V>	rateLimited(RateLimiter rateLimiter)
u.Optional<Map.Entry<K,V>>	reduce(BinaryOperator<Map.Entry<K,V>> accumulator)
Map.Entry<K,V>	reduce(Map.Entry<K,V> identity, BinaryOperator<Map.Entry<K,V>> accumulator)
EntryStream<K,V>	removeIf(BiPredicate<? super K,? super V> predicate)	Deprecated.
EntryStream<K,V>	removeIf(Predicate<? super Map.Entry<K,V>> predicate)	Deprecated.
EntryStream<K,V>	removeIf(Predicate<? super Map.Entry<K,V>> predicate, Consumer<? super Map.Entry<K,V>> actionOnDroppedItem)	Deprecated.
EntryStream<K,V>	reversed()	This method only runs sequentially, even in parallel stream and all elements will be loaded to memory.
EntryStream<K,V>	reverseSorted()	Deprecated.
EntryStream<K,V>	reverseSorted(Comparator<? super Map.Entry<K,V>> comparator)
EntryStream<K,V>	rotated(int distance)	This method only runs sequentially, even in parallel stream and all elements will be loaded to memory.
<KK> EntryStream<KK,V>	selectByKey(Class<KK> clazz)	Returns a stream consisting of the elements of this stream which keys are instances of given class.
<VV> EntryStream<K,VV>	selectByValue(Class<VV> clazz)	Returns a stream consisting of the elements of this stream which values are instances of given class.
EntryStream<K,V>	sequential()
EntryStream<K,V>	shuffled()	This method only runs sequentially, even in parallel stream and all elements will be loaded to memory.
EntryStream<K,V>	shuffled(Random rnd)	This method only runs sequentially, even in parallel stream and all elements will be loaded to memory.
EntryStream<K,V>	skip(long n)
EntryStream<K,V>	skip(long n, Consumer<? super Map.Entry<K,V>> consumer)
EntryStream<K,V>	skipUntil(BiPredicate<? super K,? super V> predicate)
EntryStream<K,V>	skipUntil(Predicate<? super Map.Entry<K,V>> predicate)
Stream<EntryStream<K,V>>	sliding(int windowSize)
Stream<EntryStream<K,V>>	sliding(int windowSize, int increment)	Stream.of(1, 2, 3, 4, 5, 6, 7, 8).sliding(3, 1).forEach(Stream::println) output: [1, 2, 3] [2, 3, 4] [3, 4, 5] [4, 5, 6] [5, 6, 7] [6, 7, 8] ============================================================================ Stream.of(1, 2, 3, 4, 5, 6, 7, 8).sliding(3, 3).forEach(Stream::println) output: [1, 2, 3] [4, 5, 6] [7, 8] ============================================================================ Stream.of(1, 2, 3, 4, 5, 6, 7, 5).sliding(3, 5).forEach(Stream::println) output: [1, 2, 3] [6, 7, 8] This method only runs sequentially, even in parallel stream.
Stream<List<Map.Entry<K,V>>>	slidingToList(int windowSize)
Stream<List<Map.Entry<K,V>>>	slidingToList(int windowSize, int increment)
EntryStream<K,V>	sorted()	Deprecated.
EntryStream<K,V>	sorted(Comparator<? super Map.Entry<K,V>> comparator)
EntryStream<K,V>	sortedBy(Function<? super Map.Entry<K,V>,? extends Comparable> keyMapper)
EntryStream<K,V>	sortedByDouble(ToDoubleFunction<? super Map.Entry<K,V>> keyMapper)
EntryStream<K,V>	sortedByInt(ToIntFunction<? super Map.Entry<K,V>> keyMapper)
EntryStream<K,V>	sortedByKey(Comparator<? super K> keyComparator)
EntryStream<K,V>	sortedByLong(ToLongFunction<? super Map.Entry<K,V>> keyMapper)
EntryStream<K,V>	sortedByValue(Comparator<? super V> valueComparator)
Stream<EntryStream<K,V>>	split(int chunkSize)	Returns Stream of S with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
Stream<EntryStream<K,V>>	split(Predicate<? super Map.Entry<K,V>> predicate)	Split the stream by the specified predicate.
Stream<EntryStream<K,V>>	splitAt(int where)	Split the stream into two pieces at where.
Stream<EntryStream<K,V>>	splitAt(Predicate<? super Map.Entry<K,V>> where)	Split the stream into two pieces at where turns to true.
Stream<List<Map.Entry<K,V>>>	splitToList(int chunkSize)	Returns Stream of PL with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
Stream<List<Map.Entry<K,V>>>	splitToList(Predicate<? super Map.Entry<K,V>> predicate)	Split the stream by the specified predicate.
<SS extends BaseStream> SS	sps(int maxThreadNum, Function<? super EntryStream<K,V>,? extends SS> ops)	Temporarily switch the stream to parallel stream for operation ops and then switch back to sequence stream.
<SS extends BaseStream> SS	sps(Function<? super EntryStream<K,V>,? extends SS> ops)	Temporarily switch the stream to parallel stream for operation ops and then switch back to sequence stream.
<SS extends BaseStream> SS	sps(BaseStream.ParallelSettings ps, Function<? super EntryStream<K,V>,? extends SS> ops)	Temporarily switch the stream to parallel stream for operation ops and then switch back to sequence stream.
EntryStream<K,V>	step(long step)
EntryStream<K,V>	symmetricDifference(Collection<Map.Entry<K,V>> c)	This method only runs sequentially, even in parallel stream.
EntryStream<K,V>	takeWhile(BiPredicate<? super K,? super V> predicate)
EntryStream<K,V>	takeWhile(Predicate<? super Map.Entry<K,V>> predicate)	Keep the elements until the given predicate returns false.
EntryStream<K,V>	throwIfEmpty(Supplier<? extends RuntimeException> exceptionSupplier)
Object[]	toArray()
<CC extends Collection<Map.Entry<K, V>>> CC	toCollection(Supplier<? extends CC> supplier)
ImmutableList<Map.Entry<K,V>>	toImmutableList()
ImmutableMap<K,V>	toImmutableMap()
ImmutableMap<K,V>	toImmutableMap(BinaryOperator<V> mergeFunction)
ImmutableSet<Map.Entry<K,V>>	toImmutableSet()
List<Map.Entry<K,V>>	toList()
LongMultiset<Map.Entry<K,V>>	toLongMultiset()
LongMultiset<Map.Entry<K,V>>	toLongMultiset(Supplier<? extends LongMultiset<Map.Entry<K,V>>> supplier)
Map<K,V>	toMap()
Map<K,V>	toMap(BinaryOperator<V> mergeFunction)
<M extends Map<K, V>> M	toMap(BinaryOperator<V> mergeFunction, Supplier<? extends M> mapFactory)
<M extends Map<K, V>> M	toMap(Supplier<? extends M> mapFactory)
<R, E extends Exception> R	toMapAndThen(Throwables.Function<? super Map<K,V>,R,E> func)
ListMultimap<K,V>	toMultimap()
<C extends Collection<V>, M extends Multimap<K, V, C>> M	toMultimap(Supplier<? extends M> mapFactory)
Multiset<Map.Entry<K,V>>	toMultiset()
Multiset<Map.Entry<K,V>>	toMultiset(Supplier<? extends Multiset<Map.Entry<K,V>>> supplier)
Set<Map.Entry<K,V>>	toSet()
Stream<V>	values()
static <K, V> EntryStream<K,V>	zip(Iterable<? extends K> keys, Iterable<? extends V> values)
static <K, V> EntryStream<K,V>	zip(Iterable<? extends K> keys, Iterable<? extends V> values, K valueForNonKey, V valueForNonValue)
static <K, V> EntryStream<K,V>	zip(K[] keys, V[] values)
static <K, V> EntryStream<K,V>	zip(K[] keys, V[] values, K valueForNonKey, V valueForNonValue)

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Details

keys

@SequentialOnly
@IntermediateOp
public Stream<K> keys()

values

@SequentialOnly
@IntermediateOp
public Stream<V> values()

entries

@SequentialOnly
@IntermediateOp
public Stream<Map.Entry<K,V>> entries()

inversed

@SequentialOnly
@IntermediateOp
public EntryStream<V,K> inversed()

selectByKey

@SequentialOnly
@IntermediateOp
public <KK> EntryStream<KK,V> selectByKey(Class<KK> clazz)

Returns a stream consisting of the elements of this stream which keys are instances of given class.

This is an intermediate operation.

Type Parameters:

KK - a type of keys to select.

Parameters:

clazz - a class to filter the keys.

Returns:

selectByValue

@SequentialOnly
@IntermediateOp
public <VV> EntryStream<K,VV> selectByValue(Class<VV> clazz)

Returns a stream consisting of the elements of this stream which values are instances of given class.

This is an intermediate operation.

Type Parameters:

VV - a type of values to select.

Parameters:

clazz - a class to filter the values.

Returns:

filter

public EntryStream<K,V> filter(Predicate<? super Map.Entry<K,V>> predicate)

Description copied from interface: BaseStream

Returns a stream consisting of the elements of this stream that match the given predicate.

Returns:

filter

@ParallelSupported
@IntermediateOp
public EntryStream<K,V> filter(BiPredicate<? super K,? super V> predicate)

filter

public EntryStream<K,V> filter(Predicate<? super Map.Entry<K,V>> predicate,
 Consumer<? super Map.Entry<K,V>> actionOnDroppedItem)

Description copied from interface: BaseStream

Returns a stream consisting of the elements of this stream that match the given predicate.

Returns:

filterByKey

@ParallelSupported
@IntermediateOp
public EntryStream<K,V> filterByKey(Predicate<? super K> keyPredicate)

filterByValue

@ParallelSupported
@IntermediateOp
public EntryStream<K,V> filterByValue(Predicate<? super V> valuePredicate)

removeIf

@Deprecated
public EntryStream<K,V> removeIf(Predicate<? super Map.Entry<K,V>> predicate)

Deprecated.

Type Parameters:

KK -

Parameters:

predicate -

Returns:

removeIf

@ParallelSupported
@Deprecated
public EntryStream<K,V> removeIf(BiPredicate<? super K,? super V> predicate)

Deprecated.

Type Parameters:

KK -

Parameters:

predicate -

Returns:

removeIf

@Deprecated
public EntryStream<K,V> removeIf(Predicate<? super Map.Entry<K,V>> predicate,
 Consumer<? super Map.Entry<K,V>> actionOnDroppedItem)

Deprecated.

Returns:

takeWhile

public EntryStream<K,V> takeWhile(Predicate<? super Map.Entry<K,V>> predicate)

Description copied from interface: BaseStream

Keep the elements until the given predicate returns false. The stream should be sorted, which means if x is the first element: predicate.text(x) returns false, any element y behind x: predicate.text(y) should returns false. In parallel Streams, the elements after the first element which predicate returns false may be tested by predicate too.
For example:

 // For sequential stream:
 Stream.of(1, 2, 3, 4, 5, 6).takeWhile(it -> it invalid input: '<' 5).toList() ===> [1, 2, 3, 4]
 Stream.of(1, 2, 5, 6, 3, 4).takeWhile(it -> it invalid input: '<' 5).toList() ===> [1, 2]
 Stream.of(5, 6, 1, 2, 3, 4).takeWhile(it -> it invalid input: '<' 5).toList() ===> []


 // For parallel stream:
 Stream.of(1, 2, 3, 4, 5, 6).parallel().takeWhile(it -> it invalid input: '<' 5).toList() ===> [1, 2, 3, 4] // Order could be different since it's in parallel stream.
 Stream.of(1, 2, 5, 6, 3, 4).parallel().takeWhile(it -> it invalid input: '<' 5).toList() ===> [1, 2] // or [1, 2, 3] or [1, 2, 3, 4] // Order could be different since it's in parallel stream.
 Stream.of(5, 6, 1, 2, 3, 4).parallel().takeWhile(it -> it invalid input: '<' 5).toList() ===> any sub set of [1, 2, 3, 4], including [] // Order could be different since it's in parallel stream.
 

Returns:

takeWhile

@ParallelSupported
@IntermediateOp
public EntryStream<K,V> takeWhile(BiPredicate<? super K,? super V> predicate)

dropWhile

public EntryStream<K,V> dropWhile(Predicate<? super Map.Entry<K,V>> predicate)

Description copied from interface: BaseStream

Remove the elements until the given predicate returns false. The stream should be sorted, which means if x is the first element: predicate.text(x) returns true, any element y behind x: predicate.text(y) should returns true. In parallel Streams, the elements after the first element which predicate returns false may be tested by predicate too.
For example:

 // For sequential stream:
 Stream.of(1, 2, 3, 4, 5, 6).dropWhile(it -> it invalid input: '<' 4).toList() ===> [4, 5, 6]
 Stream.of(1, 2, 5, 6, 3, 4).dropWhile(it -> it invalid input: '<' 4).toList() ===> [5, 6, 3, 4]
 Stream.of(5, 6, 1, 2, 3, 4).dropWhile(it -> it invalid input: '<' 4).toList() ===> [5, 6, 1, 2, 3, 4]


 // For parallel stream:
 Stream.of(1, 2, 3, 4, 5, 6).parallel().dropWhile(it -> it invalid input: '<' 4).toList() ===> [4, 5, 6] // Order could be different since it's in parallel stream.
 Stream.of(1, 2, 5, 6, 3, 4).parallel().dropWhile(it -> it invalid input: '<' 4).toList() ===> [5, 6, 4] // or [5, 6, 3, 4] // Order could be different since it's in parallel stream.
 Stream.of(5, 6, 1, 2, 3, 4).parallel().dropWhile(it -> it invalid input: '<' 4).toList() ===> [5, 6] + any sub set of [1, 2, 3, 4] // Order could be different since it's in parallel stream.
 

Returns:

dropWhile

@ParallelSupported
@IntermediateOp
public EntryStream<K,V> dropWhile(BiPredicate<? super K,? super V> predicate)

dropWhile

public EntryStream<K,V> dropWhile(Predicate<? super Map.Entry<K,V>> predicate,
 Consumer<? super Map.Entry<K,V>> actionOnDroppedItem)

Description copied from interface: BaseStream

Remove the elements until the given predicate returns false. The stream should be sorted, which means if x is the first element: predicate.text(x) returns true, any element y behind x: predicate.text(y) should returns true. In parallel Streams, the elements after the first element which predicate returns false may be tested by predicate too.

Returns:

BaseStream.dropWhile(Object)

skipUntil

public EntryStream<K,V> skipUntil(Predicate<? super Map.Entry<K,V>> predicate)

Returns:

See Also:

• BaseStream.dropWhile(Object)

skipUntil

@ParallelSupported
@IntermediateOp
public EntryStream<K,V> skipUntil(BiPredicate<? super K,? super V> predicate)

map

@ParallelSupported
@IntermediateOp
public <KK,
VV> EntryStream<KK,VV> map(Function<? super Map.Entry<K,V>,? extends Map.Entry<? extends KK,? extends VV>> mapper)

map

@ParallelSupported
@IntermediateOp
public <KK,
VV> EntryStream<KK,VV> map(Function<? super Map.Entry<K,V>,? extends KK> keyMapper,
 Function<? super Map.Entry<K,V>,? extends VV> valueMapper)

map

@ParallelSupported
@IntermediateOp
public <KK,
VV> EntryStream<KK,VV> map(BiFunction<? super K,? super V,? extends Map.Entry<? extends KK,? extends VV>> mapper)

map

@ParallelSupported
@IntermediateOp
public <KK,
VV> EntryStream<KK,VV> map(BiFunction<? super K,? super V,? extends KK> keyMapper,
 BiFunction<? super K,? super V,? extends VV> valueMapper)

mapMulti

@Beta
@ParallelSupported
@IntermediateOp
public <KK,
VV> EntryStream<KK,VV> mapMulti(BiConsumer<? super Map.Entry<K,V>,? super Consumer<Map.Entry<KK,VV>>> mapper)

mapPartial

@ParallelSupported
@IntermediateOp
public <KK,
VV> EntryStream<KK,VV> mapPartial(Function<? super Map.Entry<K,V>,u.Optional<? extends Map.Entry<? extends KK,? extends VV>>> mapper)

mapPartial

@ParallelSupported
@IntermediateOp
public <KK,
VV> EntryStream<KK,VV> mapPartial(BiFunction<? super K,? super V,u.Optional<? extends Map.Entry<? extends KK,? extends VV>>> mapper)

mapKey

@ParallelSupported
@IntermediateOp
public <KK> EntryStream<KK,V> mapKey(Function<? super K,? extends KK> keyMapper)

mapKey

@ParallelSupported
@IntermediateOp
public <KK> EntryStream<KK,V> mapKey(BiFunction<? super K,? super V,? extends KK> keyMapper)

mapValue

@ParallelSupported
@IntermediateOp
public <VV> EntryStream<K,VV> mapValue(Function<? super V,? extends VV> valueMapper)

mapValue

@ParallelSupported
@IntermediateOp
public <VV> EntryStream<K,VV> mapValue(BiFunction<? super K,? super V,? extends VV> valueMapper)

mapKeyPartial

@ParallelSupported
@IntermediateOp
public <KK> EntryStream<KK,V> mapKeyPartial(Function<? super K,u.Optional<? extends KK>> keyMapper)

mapKeyPartial

@ParallelSupported
@IntermediateOp
public <KK> EntryStream<KK,V> mapKeyPartial(BiFunction<? super K,? super V,u.Optional<? extends KK>> keyMapper)

mapValuePartial

@ParallelSupported
@IntermediateOp
public <VV> EntryStream<K,VV> mapValuePartial(Function<? super V,u.Optional<? extends VV>> valueMapper)

mapValuePartial

@ParallelSupported
@IntermediateOp
public <VV> EntryStream<K,VV> mapValuePartial(BiFunction<? super K,? super V,u.Optional<? extends VV>> valueMapper)

flatMap

@ParallelSupported
@IntermediateOp
public <KK,
VV> EntryStream<KK,VV> flatMap(Function<? super Map.Entry<K,V>,? extends EntryStream<? extends KK,? extends VV>> mapper)

flatMap

@ParallelSupported
@IntermediateOp
public <KK,
VV> EntryStream<KK,VV> flatMap(BiFunction<? super K,? super V,? extends EntryStream<? extends KK,? extends VV>> mapper)

flattMap

@ParallelSupported
@IntermediateOp
public <KK,
VV> EntryStream<KK,VV> flattMap(Function<? super Map.Entry<K,V>,? extends Map<? extends KK,? extends VV>> mapper)

flattMap

@ParallelSupported
@IntermediateOp
public <KK,
VV> EntryStream<KK,VV> flattMap(BiFunction<? super K,? super V,? extends Map<? extends KK,? extends VV>> mapper)

flatMapp

@ParallelSupported
@IntermediateOp
public <KK,
VV> EntryStream<KK,VV> flatMapp(Function<? super Map.Entry<K,V>,? extends Stream<? extends Map.Entry<? extends KK,? extends VV>>> mapper)

flatMapp

@ParallelSupported
@IntermediateOp
public <KK,
VV> EntryStream<KK,VV> flatMapp(BiFunction<? super K,? super V,? extends Stream<? extends Map.Entry<? extends KK,? extends VV>>> mapper)

flatMapKey

@ParallelSupported
@IntermediateOp
public <KK> EntryStream<KK,V> flatMapKey(Function<? super K,? extends Stream<? extends KK>> keyMapper)

flatMapKey

@ParallelSupported
@IntermediateOp
public <KK> EntryStream<KK,V> flatMapKey(BiFunction<? super K,? super V,? extends Stream<? extends KK>> keyMapper)

flattMapKey

@ParallelSupported
@IntermediateOp
public <KK> EntryStream<KK,V> flattMapKey(Function<? super K,? extends Collection<? extends KK>> keyMapper)

flattMapKey

@ParallelSupported
@IntermediateOp
public <KK> EntryStream<KK,V> flattMapKey(BiFunction<? super K,? super V,? extends Collection<? extends KK>> keyMapper)

flatMapValue

@ParallelSupported
@IntermediateOp
public <VV> EntryStream<K,VV> flatMapValue(Function<? super V,? extends Stream<? extends VV>> valueMapper)

flatMapValue

@ParallelSupported
@IntermediateOp
public <VV> EntryStream<K,VV> flatMapValue(BiFunction<? super K,? super V,? extends Stream<? extends VV>> valueMapper)

flattMapValue

@ParallelSupported
@IntermediateOp
public <VV> EntryStream<K,VV> flattMapValue(Function<? super V,? extends Collection<? extends VV>> valueMapper)

flattMapValue

@ParallelSupported
@IntermediateOp
public <VV> EntryStream<K,VV> flattMapValue(BiFunction<? super K,? super V,? extends Collection<? extends VV>> valueMapper)

groupBy

@SequentialOnly
@IntermediateOp
@TerminalOpTriggered
public EntryStream<K,List<V>> groupBy()

Parameters:

keyMapper -

Returns:

See Also:

• invalid @see

  Collectors#groupingBy(Function)

groupBy

@SequentialOnly
@IntermediateOp
@TerminalOpTriggered
public EntryStream<K,List<V>> groupBy(Supplier<? extends Map<K,List<V>>> mapFactory)

Parameters:

mapFactory -

keyMapper -

Returns:

See Also:

• invalid @see

  Collectors#groupingBy(Function, Supplier)

groupBy

@ParallelSupported
@IntermediateOp
@TerminalOpTriggered
public <KK,
VV> EntryStream<KK,List<VV>> groupBy(Function<? super Map.Entry<K,V>,? extends KK> keyMapper,
 Function<? super Map.Entry<K,V>,? extends VV> valueMapper)

groupBy

@ParallelSupported
@IntermediateOp
@TerminalOpTriggered
public <KK,
VV> EntryStream<KK,List<VV>> groupBy(Function<? super Map.Entry<K,V>,? extends KK> keyMapper,
 Function<? super Map.Entry<K,V>,? extends VV> valueMapper,
 Supplier<? extends Map<KK,List<VV>>> mapFactory)

Parameters:

keyMapper -

valueMapper -

mapFactory -

Returns:

See Also:

• invalid @see

  Collectors#toMultimap(Function, Function, Supplier)

groupBy

@ParallelSupported
@IntermediateOp
@TerminalOpTriggered
public <A,
D> EntryStream<K,D> groupBy(Collector<? super Map.Entry<K,V>,A,D> downstream)

Parameters:

downstream -

Returns:

See Also:

• invalid @see

  Collectors#groupingBy(Function, Collector)

groupBy

@ParallelSupported
@IntermediateOp
@TerminalOpTriggered
public <A,
D> EntryStream<K,D> groupBy(Collector<? super Map.Entry<K,V>,A,D> downstream,
 Supplier<? extends Map<K,D>> mapFactory)

Parameters:

downstream -

mapFactory -

Returns:

See Also:

• invalid @see

  Collectors#groupingBy(Function, Collector)

groupBy

@ParallelSupported
@IntermediateOp
@TerminalOpTriggered
public <KK,
A,
D> EntryStream<KK,D> groupBy(Function<? super Map.Entry<K,V>,? extends KK> keyMapper,
 Collector<? super Map.Entry<K,V>,A,D> downstream)

Parameters:

keyMapper -

downstream -

mapFactory -

Returns:

See Also:

• invalid @see

  Collectors#groupingBy(Function, Collector, Supplier)

groupBy

@ParallelSupported
@IntermediateOp
@TerminalOpTriggered
public <KK,
A,
D> EntryStream<KK,D> groupBy(Function<? super Map.Entry<K,V>,? extends KK> keyMapper,
 Collector<? super Map.Entry<K,V>,A,D> downstream,
 Supplier<? extends Map<KK,D>> mapFactory)

Parameters:

keyMapper -

downstream -

Returns:

See Also:

• invalid @see

  Collectors#groupingBy(Function, Collector)

groupBy

@SequentialOnly
@IntermediateOp
@TerminalOpTriggered
public EntryStream<K,V> groupBy(BinaryOperator<V> mergeFunction)

Parameters:

mergeFunction -

Returns:

groupBy

@SequentialOnly
@IntermediateOp
@TerminalOpTriggered
public EntryStream<K,V> groupBy(BinaryOperator<V> mergeFunction,
 Supplier<? extends Map<K,V>> mapFactory)

Parameters:

mergeFunction -

mapFactory -

Returns:

groupBy

@ParallelSupported
@IntermediateOp
@TerminalOpTriggered
public <KK,
VV> EntryStream<KK,VV> groupBy(Function<? super Map.Entry<K,V>,? extends KK> keyMapper,
 Function<? super Map.Entry<K,V>,? extends VV> valueMapper,
 BinaryOperator<VV> mergeFunction)

Parameters:

keyMapper -

valueMapper -

mergeFunction -

Returns:

See Also:

• invalid @see

  Collectors#groupBy(Function, Function, BinaryOperator)

groupBy

@ParallelSupported
@IntermediateOp
@TerminalOpTriggered
public <KK,
VV> EntryStream<KK,VV> groupBy(Function<? super Map.Entry<K,V>,? extends KK> keyMapper,
 Function<? super Map.Entry<K,V>,? extends VV> valueMapper,
 BinaryOperator<VV> mergeFunction,
 Supplier<? extends Map<KK,VV>> mapFactory)

Parameters:

keyMapper -

valueMapper -

mergeFunction -

mapFactory -

Returns:

See Also:

• invalid @see

  Collectors#groupBy(Function, Function, BinaryOperator, Supplier)

collapseByKey

@SequentialOnly
@IntermediateOp
public Stream<List<V>> collapseByKey(BiPredicate<? super K,? super K> collapsible)

Parameters:

collapsible -

Returns:

See Also:

• Stream.collapse(BiPredicate, Collector)

collapseByKey

@SequentialOnly
@IntermediateOp
public <R,
A> Stream<R> collapseByKey(BiPredicate<? super K,? super K> collapsible,
 Collector<? super V,A,R> collector)

Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
This method only runs sequentially, even in parallel stream.

Parameters:

collapsible -

collector -

Returns:

split

public Stream<EntryStream<K,V>> split(int chunkSize)

Description copied from interface: BaseStream

Returns Stream of S with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).

Parameters:

chunkSize - the desired size of each sub sequence (the last may be smaller).

Returns:

splitToList

public Stream<List<Map.Entry<K,V>>> splitToList(int chunkSize)

Description copied from interface: BaseStream

Returns Stream of PL with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
This method only runs sequentially, even in parallel stream.

Parameters:

chunkSize - the desired size of each sub sequence (the last may be smaller).

Returns:

split

public Stream<EntryStream<K,V>> split(Predicate<? super Map.Entry<K,V>> predicate)

Description copied from interface: BaseStream

Split the stream by the specified predicate. This stream should be sorted by value which is used to verify the border.
This method only runs sequentially, even in parallel stream.

Returns:

splitToList

public Stream<List<Map.Entry<K,V>>> splitToList(Predicate<? super Map.Entry<K,V>> predicate)

Description copied from interface: BaseStream

Split the stream by the specified predicate. This method only runs sequentially, even in parallel stream.

Returns:

splitAt

public Stream<EntryStream<K,V>> splitAt(int where)

Description copied from interface: BaseStream

Split the stream into two pieces at where. The first piece will be loaded into memory.

Returns:

splitAt

public Stream<EntryStream<K,V>> splitAt(Predicate<? super Map.Entry<K,V>> where)

Description copied from interface: BaseStream

Split the stream into two pieces at where turns to true. The first piece will be loaded into memory.

 
 Stream.of(1, 3, 2, 4, 2, 5).splitAt(it -> it >= 4).forEach(s -> s.println()); // [1, 3, 2], [4, 2, 5]
 
 

Returns:

sliding

public Stream<EntryStream<K,V>> sliding(int windowSize,
 int increment)

Description copied from interface: BaseStream

Stream.of(1, 2, 3, 4, 5, 6, 7, 8).sliding(3, 1).forEach(Stream::println)
output:
[1, 2, 3]
[2, 3, 4]
[3, 4, 5]
[4, 5, 6]
[5, 6, 7]
[6, 7, 8]

============================================================================
Stream.of(1, 2, 3, 4, 5, 6, 7, 8).sliding(3, 3).forEach(Stream::println)
output:
[1, 2, 3]
[4, 5, 6]
[7, 8]

============================================================================
Stream.of(1, 2, 3, 4, 5, 6, 7, 5).sliding(3, 5).forEach(Stream::println)
output:
[1, 2, 3]
[6, 7, 8]

This method only runs sequentially, even in parallel stream.

Returns:

slidingToList

public Stream<List<Map.Entry<K,V>>> slidingToList(int windowSize,
 int increment)

Returns:

See Also:

• BaseStream.sliding(int, int)

intersection

public EntryStream<K,V> intersection(Collection<?> c)

Description copied from interface: BaseStream

This method only runs sequentially, even in parallel stream.

Returns:

See Also:

• IntList.intersection(IntList)

difference

public EntryStream<K,V> difference(Collection<?> c)

Description copied from interface: BaseStream

This method only runs sequentially, even in parallel stream.

Returns:

See Also:

• IntList.difference(IntList)

symmetricDifference

public EntryStream<K,V> symmetricDifference(Collection<Map.Entry<K,V>> c)

Description copied from interface: BaseStream

This method only runs sequentially, even in parallel stream.

Returns:

See Also:

• IntList.symmetricDifference(IntList)

sorted

@Deprecated
public EntryStream<K,V> sorted()

Deprecated.

Compares keys and then compares values if key is equals.

Returns:

sorted

@ParallelSupported
@IntermediateOp
@TerminalOpTriggered
public EntryStream<K,V> sorted(Comparator<? super Map.Entry<K,V>> comparator)

sortedByKey

@ParallelSupported
@IntermediateOp
@TerminalOpTriggered
public EntryStream<K,V> sortedByKey(Comparator<? super K> keyComparator)

sortedByValue

@ParallelSupported
@IntermediateOp
@TerminalOpTriggered
public EntryStream<K,V> sortedByValue(Comparator<? super V> valueComparator)

sortedBy

@ParallelSupported
@IntermediateOp
@TerminalOpTriggered
public EntryStream<K,V> sortedBy(Function<? super Map.Entry<K,V>,? extends Comparable> keyMapper)

sortedByInt

@ParallelSupported
@IntermediateOp
@TerminalOpTriggered
public EntryStream<K,V> sortedByInt(ToIntFunction<? super Map.Entry<K,V>> keyMapper)

Parameters:

keyMapper -

Returns:

sortedByLong

@ParallelSupported
@IntermediateOp
@TerminalOpTriggered
public EntryStream<K,V> sortedByLong(ToLongFunction<? super Map.Entry<K,V>> keyMapper)

Parameters:

keyMapper -

Returns:

sortedByDouble

@ParallelSupported
@IntermediateOp
@TerminalOpTriggered
public EntryStream<K,V> sortedByDouble(ToDoubleFunction<? super Map.Entry<K,V>> keyMapper)

Parameters:

keyMapper -

Returns:

reverseSorted

@ParallelSupported
@IntermediateOp
@TerminalOpTriggered
public EntryStream<K,V> reverseSorted(Comparator<? super Map.Entry<K,V>> comparator)

indexed

public Stream<Indexed<Map.Entry<K,V>>> indexed()

Description copied from interface: BaseStream

This method only runs sequentially, even in parallel stream.

Returns:

distinct

public EntryStream<K,V> distinct()

Description copied from interface: BaseStream

Returns a stream consisting of the distinct elements of this stream.

Returns:

distinct

@ParallelSupported
@IntermediateOp
@TerminalOpTriggered
public EntryStream<K,V> distinct(BinaryOperator<Map.Entry<K,V>> mergeFunction)

distinct

@ParallelSupported
@IntermediateOp
@TerminalOpTriggered
public EntryStream<K,V> distinct(Predicate<? super Long> occurrencesFilter)

distinctByKey

@SequentialOnly
@IntermediateOp
public EntryStream<K,V> distinctByKey()

distinctByValue

@SequentialOnly
@IntermediateOp
public EntryStream<K,V> distinctByValue()

distinctBy

@ParallelSupported
@IntermediateOp
public EntryStream<K,V> distinctBy(Function<? super Map.Entry<K,V>,?> keyMapper)

distinctBy

@ParallelSupported
@IntermediateOp
@TerminalOpTriggered
public EntryStream<K,V> distinctBy(Function<? super Map.Entry<K,V>,?> keyMapper,
 BinaryOperator<Map.Entry<K,V>> mergeFunction)

Parameters:

keyMapper -

mergeFunction -

Returns:

See Also:

• groupBy(Function, Function, BinaryOperator)

distinctBy

@ParallelSupported
@IntermediateOp
@TerminalOpTriggered
public EntryStream<K,V> distinctBy(Function<? super Map.Entry<K,V>,?> keyMapper,
 Predicate<? super Long> occurrencesFilter)

Parameters:

keyMapper -

occurrencesFilter -

Returns:

See Also:

• groupBy(Function, Collector)

rotated

public EntryStream<K,V> rotated(int distance)

Description copied from interface: BaseStream

This method only runs sequentially, even in parallel stream and all elements will be loaded to memory.

Returns:

shuffled

public EntryStream<K,V> shuffled()

Description copied from interface: BaseStream

This method only runs sequentially, even in parallel stream and all elements will be loaded to memory.

Specified by:

shuffled in interface BaseStream<Map.Entry<K,V>,Object[],Predicate<? super Map.Entry<K,V>>,Consumer<? super Map.Entry<K,V>>,List<Map.Entry<K,V>>,u.Optional<Map.Entry<K,V>>,Indexed<Map.Entry<K,V>>,ObjIterator<Map.Entry<K,V>>,EntryStream<K,V>>

Returns:

shuffled

public EntryStream<K,V> shuffled(Random rnd)

Description copied from interface: BaseStream

This method only runs sequentially, even in parallel stream and all elements will be loaded to memory.

Returns:

reversed

public EntryStream<K,V> reversed()

Description copied from interface: BaseStream

This method only runs sequentially, even in parallel stream and all elements will be loaded to memory.

Returns:

reverseSorted

@Deprecated
public EntryStream<K,V> reverseSorted()

Deprecated.

cycled

public EntryStream<K,V> cycled()

Description copied from interface: BaseStream

This method only runs sequentially, even in parallel stream and retrieved elements will be saved in memory for next cycle.

Returns:

cycled

public EntryStream<K,V> cycled(long rounds)

Description copied from interface: BaseStream

This method only runs sequentially, even in parallel stream and retrieved elements will be saved in memory for next cycle.

Returns:

prepend

@SequentialOnly
@IntermediateOp
public <M extends Map<? extends K,
? extends V>>
EntryStream<K,V> prepend(M map)

prepend

public EntryStream<K,V> prepend(EntryStream<K,V> stream)

prepend

public EntryStream<K,V> prepend(u.Optional<Map.Entry<K,V>> op)

append

@SequentialOnly
@IntermediateOp
public <M extends Map<? extends K,
? extends V>>
EntryStream<K,V> append(M map)

append

public EntryStream<K,V> append(EntryStream<K,V> stream)

append

public EntryStream<K,V> append(u.Optional<Map.Entry<K,V>> op)

appendIfEmpty

@SequentialOnly
@IntermediateOp
public <M extends Map<? extends K,
? extends V>>
EntryStream<K,V> appendIfEmpty(M map)

appendIfEmpty

public EntryStream<K,V> appendIfEmpty(Supplier<? extends EntryStream<K,V>> supplier)

applyIfNotEmpty

public <R,
E extends Exception> u.Optional<R> applyIfNotEmpty(Throwables.Function<? super EntryStream<K,V>,R,E> func)
                                                      throws E

Description copied from interface: BaseStream

This is a terminal operation. That's to say this stream will be closed after this operation.

Returns:

Throws:

E

acceptIfNotEmpty

public <E extends Exception> If.OrElse acceptIfNotEmpty(Throwables.Consumer<? super EntryStream<K,V>,E> action)
                                                 throws E

Description copied from interface: BaseStream

This is a terminal operation. That's to say this stream will be closed after this operation.

Returns:

Throws:

E

skip

@SequentialOnly
@IntermediateOp
public EntryStream<K,V> skip(long n)

Returns:

skip

public EntryStream<K,V> skip(long n,
 Consumer<? super Map.Entry<K,V>> consumer)

Returns:

limit

@SequentialOnly
@IntermediateOp
public EntryStream<K,V> limit(long maxSize)

Returns:

step

public EntryStream<K,V> step(long step)

rateLimited

public EntryStream<K,V> rateLimited(RateLimiter rateLimiter)

Returns:

See Also:

• RateLimiter.acquire()

peek

public EntryStream<K,V> peek(Consumer<? super Map.Entry<K,V>> action)

Specified by:

peek in interface BaseStream<Map.Entry<K,V>,Object[],Predicate<? super Map.Entry<K,V>>,Consumer<? super Map.Entry<K,V>>,List<Map.Entry<K,V>>,u.Optional<Map.Entry<K,V>>,Indexed<Map.Entry<K,V>>,ObjIterator<Map.Entry<K,V>>,EntryStream<K,V>>

peek

@ParallelSupported
@IntermediateOp
public EntryStream<K,V> peek(BiConsumer<? super K,? super V> action)

onEach

public EntryStream<K,V> onEach(Consumer<? super Map.Entry<K,V>> action)

Description copied from interface: BaseStream

Same as peek

Returns:

See Also:

• BaseStream.peek(Object)

onEach

@ParallelSupported
@IntermediateOp
public EntryStream<K,V> onEach(BiConsumer<? super K,? super V> action)

forEach

@ParallelSupported
@TerminalOp
public <E extends Exception> void forEach(Throwables.Consumer<? super Map.Entry<K,V>,E> action)
                                   throws E

Throws:

E extends Exception

forEach

@ParallelSupported
@TerminalOp
public <E extends Exception> void forEach(Throwables.BiConsumer<? super K,? super V,E> action)
                                   throws E

Throws:

E extends Exception

forEachIndexed

@ParallelSupported
@TerminalOp
public <E extends Exception> void forEachIndexed(Throwables.IndexedConsumer<? super Map.Entry<K,V>,E> action)
                                          throws E

Throws:

E extends Exception

min

@ParallelSupported
@TerminalOp
public u.Optional<Map.Entry<K,V>> min(Comparator<? super Map.Entry<K,V>> comparator)

minByKey

@ParallelSupported
@TerminalOp
public u.Optional<Map.Entry<K,V>> minByKey(Comparator<? super K> keyComparator)

minByValue

@ParallelSupported
@TerminalOp
public u.Optional<Map.Entry<K,V>> minByValue(Comparator<? super V> valueComparator)

minBy

@ParallelSupported
@TerminalOp
public u.Optional<Map.Entry<K,V>> minBy(Function<? super Map.Entry<K,V>,? extends Comparable> keyMapper)

max

@ParallelSupported
@TerminalOp
public u.Optional<Map.Entry<K,V>> max(Comparator<? super Map.Entry<K,V>> comparator)

maxByKey

@ParallelSupported
@TerminalOp
public u.Optional<Map.Entry<K,V>> maxByKey(Comparator<? super K> keyComparator)

maxByValue

@ParallelSupported
@TerminalOp
public u.Optional<Map.Entry<K,V>> maxByValue(Comparator<? super V> valueComparator)

maxBy

@ParallelSupported
@TerminalOp
public u.Optional<Map.Entry<K,V>> maxBy(Function<? super Map.Entry<K,V>,? extends Comparable> keyMapper)

anyMatch

@ParallelSupported
@TerminalOp
public <E extends Exception> boolean anyMatch(Throwables.Predicate<? super Map.Entry<K,V>,E> predicate)
                                       throws E

Throws:

E extends Exception

anyMatch

@ParallelSupported
@TerminalOp
public <E extends Exception> boolean anyMatch(Throwables.BiPredicate<? super K,? super V,E> predicate)
                                       throws E

Throws:

E extends Exception

allMatch

@ParallelSupported
@TerminalOp
public <E extends Exception> boolean allMatch(Throwables.Predicate<? super Map.Entry<K,V>,E> predicate)
                                       throws E

Throws:

E extends Exception

allMatch

@ParallelSupported
@TerminalOp
public <E extends Exception> boolean allMatch(Throwables.BiPredicate<? super K,? super V,E> predicate)
                                       throws E

Throws:

E extends Exception

noneMatch

@ParallelSupported
@TerminalOp
public <E extends Exception> boolean noneMatch(Throwables.Predicate<? super Map.Entry<K,V>,E> predicate)
                                        throws E

Throws:

E extends Exception

noneMatch

@ParallelSupported
@TerminalOp
public <E extends Exception> boolean noneMatch(Throwables.BiPredicate<? super K,? super V,E> predicate)
                                        throws E

Throws:

E extends Exception

findFirst

@ParallelSupported
@TerminalOp
public <E extends Exception>
u.Optional<Map.Entry<K,V>> findFirst(Throwables.Predicate<? super Map.Entry<K,V>,E> predicate)
                              throws E

Throws:

E extends Exception

findFirst

@ParallelSupported
@TerminalOp
public <E extends Exception>
u.Optional<Map.Entry<K,V>> findFirst(Throwables.BiPredicate<? super K,? super V,E> predicate)
                              throws E

Throws:

E extends Exception

findAny

@ParallelSupported
@TerminalOp
public <E extends Exception>
u.Optional<Map.Entry<K,V>> findAny(Throwables.Predicate<? super Map.Entry<K,V>,E> predicate)
                            throws E

Throws:

E extends Exception

findAny

@ParallelSupported
@TerminalOp
public <E extends Exception>
u.Optional<Map.Entry<K,V>> findAny(Throwables.BiPredicate<? super K,? super V,E> predicate)
                            throws E

Throws:

E extends Exception

first

public u.Optional<Map.Entry<K,V>> first()

last

public u.Optional<Map.Entry<K,V>> last()

elementAt

public u.Optional<Map.Entry<K,V>> elementAt(long position)

Specified by:

elementAt in interface BaseStream<Map.Entry<K,V>,Object[],Predicate<? super Map.Entry<K,V>>,Consumer<? super Map.Entry<K,V>>,List<Map.Entry<K,V>>,u.Optional<Map.Entry<K,V>>,Indexed<Map.Entry<K,V>>,ObjIterator<Map.Entry<K,V>>,EntryStream<K,V>>

Parameters:

position - in current stream(not upstream or origin source). It starts from 0.

Returns:

onlyOne

public u.Optional<Map.Entry<K,V>> onlyOne()
                                   throws DuplicatedResultException

Returns:

Throws:

DuplicatedResultException - if there are more than one element in this stream.

percentiles

public u.Optional<Map<Percentage,Map.Entry<K,V>>> percentiles()

Description copied from interface: BaseStream

All elements will be loaded to memory and sorted if not yet.

Returns:

count

public long count()

iterator

public ObjIterator<Map.Entry<K,V>> iterator()

Remember to close this Stream after the iteration is done, if needed.

Returns:

biIterator

@SequentialOnly
public BiIterator<K,V> biIterator()

Remember to close this Stream after the iteration is done, if needed.

Returns:

toList

public List<Map.Entry<K,V>> toList()

toSet

public Set<Map.Entry<K,V>> toSet()

toCollection

public <CC extends Collection<Map.Entry<K,
V>>> CC toCollection(Supplier<? extends CC> supplier)

toMultiset

public Multiset<Map.Entry<K,V>> toMultiset()

toMultiset

public Multiset<Map.Entry<K,V>> toMultiset(Supplier<? extends Multiset<Map.Entry<K,V>>> supplier)

toLongMultiset

public LongMultiset<Map.Entry<K,V>> toLongMultiset()

toLongMultiset

public LongMultiset<Map.Entry<K,V>> toLongMultiset(Supplier<? extends LongMultiset<Map.Entry<K,V>>> supplier)

toMap

@SequentialOnly
public Map<K,V> toMap()

toMap

@SequentialOnly
@TerminalOp
public Map<K,V> toMap(BinaryOperator<V> mergeFunction)

Parameters:

mergeFunction -

Returns:

toMap

@SequentialOnly
@TerminalOp
public <M extends Map<K,
V>> M toMap(Supplier<? extends M> mapFactory)

Parameters:

mapFactory -

Returns:

toMap

@SequentialOnly
@TerminalOp
public <M extends Map<K,
V>> M toMap(BinaryOperator<V> mergeFunction,
 Supplier<? extends M> mapFactory)

Parameters:

mergeFunction -

mapFactory -

Returns:

toMapAndThen

@SequentialOnly
@TerminalOp
public <R,
E extends Exception> R toMapAndThen(Throwables.Function<? super Map<K,V>,R,E> func)
                                       throws E

Throws:

E extends Exception

toImmutableMap

@SequentialOnly
@TerminalOp
public ImmutableMap<K,V> toImmutableMap()

toImmutableMap

@SequentialOnly
@TerminalOp
public ImmutableMap<K,V> toImmutableMap(BinaryOperator<V> mergeFunction)

toMultimap

@SequentialOnly
@TerminalOp
public ListMultimap<K,V> toMultimap()

Parameters:

keyMapper -

Returns:

See Also:

• invalid @see

  Collectors#toMultimap(Function, Function)

toMultimap

@SequentialOnly
@TerminalOp
public <C extends Collection<V>,
M extends Multimap<K,
V,
C>>
M toMultimap(Supplier<? extends M> mapFactory)

Parameters:

mapFactory -

keyMapper -

Returns:

See Also:

• invalid @see

  Collectors#toMultimap(Function, Function, Supplier)

groupTo

@SequentialOnly
@TerminalOp
public Map<K,List<V>> groupTo()

Parameters:

keyMapper -

Returns:

See Also:

• invalid @see

  Collectors#groupingBy(Function)

groupTo

@SequentialOnly
@TerminalOp
public <M extends Map<K,
List<V>>> M groupTo(Supplier<? extends M> mapFactory)

Parameters:

mapFactory -

keyMapper -

Returns:

See Also:

• invalid @see

  Collectors#groupingBy(Function, Supplier)

groupToAndThen

@SequentialOnly
@TerminalOp
public <R,
E extends Exception> R groupToAndThen(Throwables.Function<? super Map<K,List<V>>,R,E> func)
                                         throws E

Throws:

E extends Exception

reduce

@SequentialOnly
@TerminalOp
public Map.Entry<K,V> reduce(Map.Entry<K,V> identity,
 BinaryOperator<Map.Entry<K,V>> accumulator)

reduce

@ParallelSupported
@TerminalOp
public u.Optional<Map.Entry<K,V>> reduce(BinaryOperator<Map.Entry<K,V>> accumulator)

collect

@ParallelSupported
@TerminalOp
public <R> R collect(Supplier<R> supplier,
 BiConsumer<? super R,? super Map.Entry<K,V>> accumulator,
 BiConsumer<R,R> combiner)

Type Parameters:

R -

Parameters:

supplier -

accumulator -

combiner -

Returns:

See Also:

• Stream.collect(Supplier, BiConsumer, BiConsumer)

collect

@ParallelSupported
@TerminalOp
public <R> R collect(Supplier<R> supplier,
 BiConsumer<? super R,? super Map.Entry<K,V>> accumulator)

Type Parameters:

R -

Parameters:

supplier -

accumulator -

Returns:

See Also:

• Stream.collect(Supplier, BiConsumer)

collect

@ParallelSupported
@TerminalOp
public <R,
A> R collect(Collector<? super Map.Entry<K,V>,A,R> collector)

collectAndThen

@ParallelSupported
@TerminalOp
public <R,
A,
RR,
E extends Exception> RR collectAndThen(Collector<? super Map.Entry<K,V>,A,R> downstream,
 Throwables.Function<? super R,RR,E> finisher)
                                               throws E

Throws:

E extends Exception

join

public String join(CharSequence delimiter)

Specified by:

join in interface BaseStream<Map.Entry<K,V>,Object[],Predicate<? super Map.Entry<K,V>>,Consumer<? super Map.Entry<K,V>>,List<Map.Entry<K,V>>,u.Optional<Map.Entry<K,V>>,Indexed<Map.Entry<K,V>>,ObjIterator<Map.Entry<K,V>>,EntryStream<K,V>>

join

public String join(CharSequence delimiter,
 CharSequence prefix,
 CharSequence suffix)

join

@SequentialOnly
@TerminalOp
public String join(CharSequence delimiter,
 CharSequence keyValueDelimiter)

join

@SequentialOnly
@TerminalOp
public String join(CharSequence delimiter,
 CharSequence keyValueDelimiter,
 CharSequence prefix,
 CharSequence suffix)

chain

@SequentialOnly
@TerminalOp
public <KK,
VV> EntryStream<KK,VV> chain(Function<? super Stream<Map.Entry<K,V>>,? extends Stream<Map.Entry<KK,VV>>> transfer)

isParallel

public boolean isParallel()

Specified by:

isParallel in interface BaseStream<Map.Entry<K,V>,Object[],Predicate<? super Map.Entry<K,V>>,Consumer<? super Map.Entry<K,V>>,List<Map.Entry<K,V>>,u.Optional<Map.Entry<K,V>>,Indexed<Map.Entry<K,V>>,ObjIterator<Map.Entry<K,V>>,EntryStream<K,V>>

sequential

public EntryStream<K,V> sequential()

Specified by:

sequential in interface BaseStream<Map.Entry<K,V>,Object[],Predicate<? super Map.Entry<K,V>>,Consumer<? super Map.Entry<K,V>>,List<Map.Entry<K,V>>,u.Optional<Map.Entry<K,V>>,Indexed<Map.Entry<K,V>>,ObjIterator<Map.Entry<K,V>>,EntryStream<K,V>>

parallel

public EntryStream<K,V> parallel()

Description copied from interface: BaseStream

Consider using sps(Function) if only next operation need to be parallelized. For example:

 stream.parallel().map(f).filter(p)...;

 // Replace above line of code with "sps" if only "f" need to be parallelized. And "p" is fast enough to be executed in sequential Stream.
 stream.sps(s -> s.map(f)).filter(p)...;
 // Or switch the stream back sequential stream if don't use "sps".
 stream.parallel().map(f).sequential().filter(p)...;

 

In most scenarios, there could be only one operation need be parallelized in the stream. So sps(Function) is recommended in most of scenarios.

Specified by:

parallel in interface BaseStream<Map.Entry<K,V>,Object[],Predicate<? super Map.Entry<K,V>>,Consumer<? super Map.Entry<K,V>>,List<Map.Entry<K,V>>,u.Optional<Map.Entry<K,V>>,Indexed<Map.Entry<K,V>>,ObjIterator<Map.Entry<K,V>>,EntryStream<K,V>>

Returns:

See Also:

• BaseStream.parallel(Executor)
• BaseStream.parallel(int, Executor)
• BaseStream.parallel(int, Splitor, Executor)
• BaseStream.sps(Function)
• BaseStream.sps(int, Function)
• BaseStream.sps(ParallelSettings, Function)

parallel

public EntryStream<K,V> parallel(int threadNum)

Description copied from interface: BaseStream

Consider using sps(int, Function) if only next operation need to be parallelized. For example:

 stream.parallel(maxThreadNum).map(f).filter(p)...;

 // Replace above line of code with "sps" if only "f" need to be parallelized. And "p" is fast enough to be executed in sequential Stream.
 stream.sps(maxThreadNum, s -> s.map(f)).filter(p)...;
 // Or switch the stream back sequential stream if don't use "sps".
 stream.parallel(maxThreadNum).map(f).sequential().filter(p)...;

 

In most scenarios, there could be only one operation need be parallelized in the stream. So sps(int, Function) is recommended in most of scenarios.

Specified by:

parallel in interface BaseStream<Map.Entry<K,V>,Object[],Predicate<? super Map.Entry<K,V>>,Consumer<? super Map.Entry<K,V>>,List<Map.Entry<K,V>>,u.Optional<Map.Entry<K,V>>,Indexed<Map.Entry<K,V>>,ObjIterator<Map.Entry<K,V>>,EntryStream<K,V>>

Returns:

See Also:

• BaseStream.parallel(Executor)
• BaseStream.parallel(int, Executor)
• BaseStream.parallel(int, Splitor, Executor)
• BaseStream.sps(Function)
• BaseStream.sps(int, Function)
• BaseStream.sps(ParallelSettings, Function)

parallel

public EntryStream<K,V> parallel(int maxThreadNum,
 BaseStream.Splitor splitor)

Description copied from interface: BaseStream

Returns an equivalent stream that is parallel. May return itself if the stream was already parallel with the same maxThreadNum and splitor as the specified ones.

When to use parallel Streams?

• First of all, do NOT and should NOT use parallel Streams if you don't have any problem with sequential Streams, because using parallel Streams has extra cost.
• Consider using parallel Streams only when N(the number of elements) * Q(cost per element of F, the per-element function (usually a lambda)) is big enough(e.g. IO involved. Network: DB/web service request..., Reading/Writing file...).
• It's easy to test out the differences of performance by sequential Streams and parallel Streams with Profiler:

 
 Profiler.run(1, 1, 3, "sequential", () -> Stream.of(list).operation(F)...).printResult();
 Profiler.run(1, 1, 3, "parallel", () -> Stream.of(list).parallel().operation(F)...).printResult();
 
 

Here is a sample performance test with computer: CPU Intel i7-3520M 4-cores 2.9 GHz, JDK 1.8.0_101, Windows 7:

 

     public void test_perf() {
        final String[] strs = new String[10_000];
        N.fill(strs, N.uuid());
    
        final int m = 10;
        final Function<String, Long> mapper = str -> {
            long result = 0;
            for (int i = 0; i invalid input: '<' m; i++) {
                result += N.sum(str.toCharArray()) + 1;
            }
            return result;
        };
    
        final MutableLong sum = MutableLong.of(0);
    
        for (int i = 0, len = strs.length; i invalid input: '<' len; i++) {
            sum.add(mapper.apply(strs[i]));
        }
    
        final int threadNum = 1, loopNum = 100, roundNum = 3;
    
        Profiler.run(threadNum, loopNum, roundNum, "For Loop", () -> {
            long result = 0;
            for (int i = 0, len = strs.length; i invalid input: '<' len; i++) {
                result += mapper.apply(strs[i]);
            }
            assertEquals(sum.longValue(), result);
        }).printResult();
    
        Profiler.run(threadNum, loopNum, roundNum, "JDK Sequential",
                () -> assertEquals(sum.longValue(), java.util.stream.Stream.of(strs).map(mapper).mapToLong(e -> e).sum())).printResult();
    
        Profiler.run(threadNum, loopNum, roundNum, "JDK Parallel",
                () -> assertEquals(sum.longValue(), java.util.stream.Stream.of(strs).parallel().map(mapper).mapToLong(e -> e).sum())).printResult();
    
        Profiler.run(threadNum, loopNum, roundNum, "Abcus Sequential", () -> assertEquals(sum.longValue(), Stream.of(strs).map(mapper).mapToLong(e -> e).sum()))
                .printResult();
    
        Profiler.run(threadNum, loopNum, roundNum, "Abcus Parallel",
                () -> assertEquals(sum.longValue(), Stream.of(strs).parallel().map(mapper).mapToLong(e -> e).sum())).printResult();
    
        Profiler.run(threadNum, loopNum, roundNum, "Abcus Parallel by chunck", () -> assertEquals(sum.longValue(),
                Stream.of(strs).splitToList(100).parallel().map(it -> N.sumLong(it, e -> mapper.apply(e))).mapToLong(e -> e).sum())).printResult();
     }
    
 
 

And test result: Unit is milliseconds. N(the number of elements) is 10_000, Q(cost per element of F, the per-element function (usually a lambda), here is mapper) is calculated by: value of 'For loop' / N(10_000).

	m = 1	m = 10	m = 50	m = 100	m = 500	m = 1000
Q	0.00002	0.0002	0.001	0.002	0.01	0.02
For Loop	0.23	2.3	11	22	110	219
JDK Sequential	0.28	2.3	11	22	114	212
JDK Parallel	0.22	1.3	6	12	66	122
Abcus Sequential	0.3	2	11	22	112	212
Abcus Parallel	11	11	11	16	77	128

Comparison:

• Again, do NOT and should NOT use parallel Streams if you don't have any performance problem with sequential Streams, because using parallel Streams has extra cost.
• Again, consider using parallel Streams only when N(the number of elements) * Q(cost per element of F, the per-element function (usually a lambda)) is big enough.
• The implementation of parallel Streams in Abacus is more than 10 times, slower than parallel Streams in JDK when Q is tiny(here is less than 0.0002 milliseconds by the test):
• The implementation of parallel Streams in JDK 8 still can beat the sequential/for loop when Q is tiny(Here is 0.00002 milliseconds by the test). That's amazing, considering the extra cost brought by parallel computation. It's well done.
• The implementation of parallel Streams in Abacus is pretty simple and straight forward. The extra cost(starting threads/synchronization/queue...) brought by parallel Streams in Abacus is too bigger to tiny Q(Here is less than 0.001 milliseconds by the test). But it starts to be faster than sequential Streams when Q is big enough(Here is 0.001 milliseconds by the test) and starts to catch the parallel Streams in JDK when Q is bigger(Here is 0.01 milliseconds by the test).
• Consider using the parallel Streams in Abacus when Q is big enough, specially when IO involved in F. Because one IO operation(e.g. DB/web service request..., Reading/Writing file...) usually takes 1 to 1000 milliseconds, or even longer. By the parallel Streams APIs in Abacus, it's very simple to specify max thread numbers. Sometimes, it's much faster to execute IO/Network requests with a bit more threads. It's fair to say that the parallel Streams in Abacus is high efficient, may same as or faster than the parallel Streams in JDK when Q is big enough, except F is heavy cpu-used operation. Most of the times, the Q is big enough to consider using parallel Stream is because IO/Network is involved in F.
• JDK 7 is supported by the Streams in Abacus. It's perfect to work with retrolambda on Android
• All primitive types are supported by Stream APIs in Abacus except boolean

A bit more about Lambdas/Stream APIs, you may heard that Lambdas/Stream APIs is 5 time slower than imperative programming. It's true when Q and F is VERY, VERY tiny, like f = (int a, int b) -> a + b;. But if we look into the samples in the article and think about it: it just takes less than 1 milliseconds to get the max value in 100k numbers. There is potential performance issue only if the "get the max value in 100K numbers" call many, many times in your API or single request. Otherwise, the difference between 0.1 milliseconds to 0.5 milliseconds can be totally ignored. Usually we meet performance issue only if Q and F is big enough. However, the performance of Lambdas/Streams APIs is closed to for loop when Q and F is big enough. No matter in which scenario, We don't need and should not concern the performance of Lambdas/Stream APIs.

Although it's is parallel Streams, it doesn't means all the methods are executed in parallel. Because the sequential way is as fast, or even faster than the parallel way for some methods, or is pretty difficult, if not possible, to implement the method by parallel approach. Here are the methods which are executed sequentially even in parallel Streams.

splitXXX/splitAt/splitBy/slidingXXX/collapse, distinct, reverse, rotate, shuffle, indexed, cached, top, kthLargest, count, toArray, toList, toList, toSet, toMultiset, toLongMultiset, intersection(Collection c), difference(Collection c), symmetricDifference(Collection c), forEach(identity, accumulator, predicate), findFirstOrLast, findFirstAndLast

Specified by:

parallel in interface BaseStream<Map.Entry<K,V>,Object[],Predicate<? super Map.Entry<K,V>>,Consumer<? super Map.Entry<K,V>>,List<Map.Entry<K,V>>,u.Optional<Map.Entry<K,V>>,Indexed<Map.Entry<K,V>>,ObjIterator<Map.Entry<K,V>>,EntryStream<K,V>>

Parameters:

maxThreadNum - Default value is the number of cpu-cores. Steps/operations will be executed sequentially if maxThreadNum is 1.

splitor - The target array is split by ranges for multiple threads if splitor is splitor.ARRAY and target stream composed by array. It looks like:

 for (int i = 0; i invalid input: '<' maxThreadNum; i++) {
     final int sliceIndex = i;

     futureList.add(asyncExecutor.execute(new Runnable() {
         public void run() {
             int cursor = fromIndex + sliceIndex * sliceSize;
             final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
             while (cursor invalid input: '<' to) {
                 action.accept(elements[cursor++]);
             }
        }
    }));
 }
 

Otherwise, each thread will get the elements from the target array/iterator in the stream one by one with the target array/iterator synchronized. It looks like:

 for (int i = 0; i invalid input: '<' maxThreadNum; i++) {
     futureList.add(asyncExecutor.execute(new Runnable() {
         public void run() {
             T next = null;

             while (true) {
                 synchronized (elements) {
                     if (cursor.intValue() invalid input: '<' toIndex) {
                         next = elements[cursor.getAndIncrement()];
                     } else {
                         break;
                     }
                 }

                 action.accept(next);
             }
         }
     }));
 }
 

Using splitor.ARRAY only when F (the per-element function (usually a lambda)) is very tiny and the cost of synchronization on the target array/iterator is too big to it. For the F involving IO or taking 'long' to complete, choose splitor.ITERATOR. Default value is splitor.ITERATOR.

Consider using sps(ParallelSettings, Function) if only next operation need to be parallelized. For example:

 stream.parallel(maxThreadNum, splitor).map(f).filter(p)...;

 // Replace above line of code with "sps" if only "f" need to be parallelized. And "p" is fast enough to be executed in sequential Stream.
 stream.sps(SP.create(maxThreadNum, splitor), s -> s.map(f)).filter(p)...;
 // Or switch the stream back sequential stream if don't use "sps".
 stream.parallel(maxThreadNum, splitor).map(f).sequential().filter(p)...;

 

In most scenarios, there could be only one operation need be parallelized in the stream. So sps(ParallelSettings, Function) is recommended in most of scenarios.

Returns:

See Also:

• BaseStream.parallel(Executor)
• BaseStream.parallel(int, Executor)
• BaseStream.parallel(int, Splitor, Executor)
• BaseStream.sps(Function)
• BaseStream.sps(int, Function)
• BaseStream.sps(ParallelSettings, Function)
• MergeResult
• invalid @see

  com.landawn.abacus.util.Profiler#run(int, int, int, String, Runnable)

• Understanding Parallel Stream Performance in Java SE 8
• When to use parallel Streams

parallel

public EntryStream<K,V> parallel(int maxThreadNum,
 BaseStream.Splitor splitor,
 Executor executor)

Description copied from interface: BaseStream

Consider using sps(ParallelSettings, Function) if only next operation need to be parallelized. For example:

 stream.parallel(maxThreadNum, splitor, executor).map(f).filter(p)...;

 // Replace above line of code with "sps" if only "f" need to be parallelized. And "p" is fast enough to be executed in sequential Stream.
 stream.sps(SP.create(maxThreadNum, splitor, executor), s -> s.map(f)).filter(p)...;
 // Or switch the stream back sequential stream if don't use "sps".
 stream.parallel(maxThreadNum, splitor, executor).map(f).sequential().filter(p)...;

 

In most scenarios, there could be only one operation need be parallelized in the stream. So sps(ParallelSettings, Function) is recommended in most of scenarios.

Specified by:

parallel in interface BaseStream<Map.Entry<K,V>,Object[],Predicate<? super Map.Entry<K,V>>,Consumer<? super Map.Entry<K,V>>,List<Map.Entry<K,V>>,u.Optional<Map.Entry<K,V>>,Indexed<Map.Entry<K,V>>,ObjIterator<Map.Entry<K,V>>,EntryStream<K,V>>

Parameters:

executor - should be able to execute maxThreadNum * following up operations in parallel.

Returns:

See Also:

• BaseStream.sps(Function)
• BaseStream.sps(int, Function)
• BaseStream.sps(ParallelSettings, Function)

parallel

public EntryStream<K,V> parallel(int maxThreadNum,
 Executor executor)

Description copied from interface: BaseStream

Consider using sps(ParallelSettings, Function) if only next operation need to be parallelized. For example:

 stream.parallel(maxThreadNum, executor).map(f).filter(p)...;

 // Replace above line of code with "sps" if only "f" need to be parallelized. And "p" is fast enough to be executed in sequential Stream.
 stream.sps(SP.create(maxThreadNum,  executor), s -> s.map(f)).filter(p)...;
 // Or switch the stream back sequential stream if don't use "sps".
 stream.parallel(maxThreadNum, executor).map(f).sequential().filter(p)...;

 

In most scenarios, there could be only one operation need be parallelized in the stream. So sps(ParallelSettings, Function) is recommended in most of scenarios.

Specified by:

parallel in interface BaseStream<Map.Entry<K,V>,Object[],Predicate<? super Map.Entry<K,V>>,Consumer<? super Map.Entry<K,V>>,List<Map.Entry<K,V>>,u.Optional<Map.Entry<K,V>>,Indexed<Map.Entry<K,V>>,ObjIterator<Map.Entry<K,V>>,EntryStream<K,V>>

Parameters:

executor - should be able to execute maxThreadNum * following up operations in parallel.

Returns:

See Also:

• BaseStream.sps(Function)
• BaseStream.sps(int, Function)
• BaseStream.sps(ParallelSettings, Function)

parallel

public EntryStream<K,V> parallel(Executor executor)

Description copied from interface: BaseStream

Consider using sps(ParallelSettings, Function) if only next operation need to be parallelized. For example:

 stream.parallel(executor).map(f).filter(p)...;

 // Replace above line of code with "sps" if only "f" need to be parallelized. And "p" is fast enough to be executed in sequential Stream.
 stream.sps(SP.create(executor), s -> s.map(f)).filter(p)...;
 // Or switch the stream back sequential stream if don't use "sps".
 stream.parallel(executor).map(f).sequential().filter(p)...;

 

In most scenarios, there could be only one operation need be parallelized in the stream. So sps(ParallelSettings, Function) is recommended in most of scenarios.

Specified by:

parallel in interface BaseStream<Map.Entry<K,V>,Object[],Predicate<? super Map.Entry<K,V>>,Consumer<? super Map.Entry<K,V>>,List<Map.Entry<K,V>>,u.Optional<Map.Entry<K,V>>,Indexed<Map.Entry<K,V>>,ObjIterator<Map.Entry<K,V>>,EntryStream<K,V>>

Parameters:

executor - should be able to execute maxThreadNum * following up operations in parallel.

Returns:

See Also:

• BaseStream.sps(Function)
• BaseStream.sps(int, Function)
• BaseStream.sps(ParallelSettings, Function)

inversedToDisposableEntry

@SequentialOnly
@Deprecated
@Beta
public EntryStream<V,K> inversedToDisposableEntry()

Deprecated.

Returns:

See Also:

• Stream.mapToDisposableEntry(Function, Function)

mapToDisposableEntry

@SequentialOnly
@Deprecated
@Beta
public <KK,
VV> EntryStream<KK,VV> mapToDisposableEntry(Function<? super Map.Entry<K,V>,? extends KK> keyMapper,
 Function<? super Map.Entry<K,V>,? extends VV> valueMapper)

Deprecated.

To reduce the memory footprint, Only one instance of DisposableEntry is created, and the same entry instance is returned and set with different keys/values during iteration of the returned stream. The elements only can be retrieved one by one, can't be modified or saved. The returned Stream doesn't support the operations which require two or more elements at the same time: (e.g. sort/distinct/pairMap/slidingMap/sliding/split/toList/toSet/...). , and can't be parallel stream. Operations: filter/map/toMap/groupBy/groupTo/... are supported.

Parameters:

keyMapper -

valueMapper -

Returns:

See Also:

• NoCachingNoUpdating.DisposableEntry
• NoCachingNoUpdating

mapToDisposableEntry

@SequentialOnly
@Deprecated
@Beta
public <KK,
VV> EntryStream<KK,VV> mapToDisposableEntry(BiFunction<? super K,? super V,? extends KK> keyMapper,
 BiFunction<? super K,? super V,? extends VV> valueMapper)

Deprecated.

Parameters:

keyMapper -

valueMapper -

Returns:

See Also:

• mapToDisposableEntry(Function, Function)

flatMapKeyToDisposableEntry

@SequentialOnly
@Deprecated
@Beta
public <KK> EntryStream<KK,V> flatMapKeyToDisposableEntry(Function<? super K,? extends Stream<? extends KK>> keyMapper)

Deprecated.

Parameters:

keyMapper -

Returns:

See Also:

• mapToDisposableEntry(Function, Function)

flattMapKeyToDisposableEntry

@SequentialOnly
@Deprecated
@Beta
public <KK> EntryStream<KK,V> flattMapKeyToDisposableEntry(Function<? super K,? extends Collection<? extends KK>> keyMapper)

Deprecated.

Parameters:

keyMapper -

Returns:

See Also:

• mapToDisposableEntry(Function, Function)

flatMapValueToDisposableEntry

@SequentialOnly
@Deprecated
@Beta
public <VV> EntryStream<K,VV> flatMapValueToDisposableEntry(Function<? super V,? extends Stream<? extends VV>> valueMapper)

Deprecated.

Parameters:

valueMapper -

Returns:

See Also:

• mapToDisposableEntry(Function, Function)

flattMapValueToDisposableEntry

@SequentialOnly
@Deprecated
@Beta
public <VV> EntryStream<K,VV> flattMapValueToDisposableEntry(Function<? super V,? extends Collection<? extends VV>> valueMapper)

Deprecated.

Parameters:

valueMapper -

Returns:

See Also:

• mapToDisposableEntry(Function, Function)

onClose

public EntryStream<K,V> onClose(Runnable closeHandler)

Returns:

close

public void close()

Description copied from interface: BaseStream

It will be called by terminal operations in final.

Specified by:

close in interface AutoCloseable

Specified by:

close in interface BaseStream<Map.Entry<K,V>,Object[],Predicate<? super Map.Entry<K,V>>,Consumer<? super Map.Entry<K,V>>,List<Map.Entry<K,V>>,u.Optional<Map.Entry<K,V>>,Indexed<Map.Entry<K,V>>,ObjIterator<Map.Entry<K,V>>,EntryStream<K,V>>

Specified by:

close in interface Closeable

empty

public static <K,
V> EntryStream<K,V> empty()

ofNullable

public static <K,
V> EntryStream<K,V> ofNullable(Map.Entry<K,V> entry)

of

public static <K,
V> EntryStream<K,V> of(K k1,
 V v1)

of

public static <K,
V> EntryStream<K,V> of(K k1,
 V v1,
 K k2,
 V v2)

of

public static <K,
V> EntryStream<K,V> of(K k1,
 V v1,
 K k2,
 V v2,
 K k3,
 V v3)

of

public static <K,
V> EntryStream<K,V> of(K k1,
 V v1,
 K k2,
 V v2,
 K k3,
 V v3,
 K k4,
 V v4)

of

public static <K,
V> EntryStream<K,V> of(K k1,
 V v1,
 K k2,
 V v2,
 K k3,
 V v3,
 K k4,
 V v4,
 K k5,
 V v5)

of

public static <K,
V> EntryStream<K,V> of(K k1,
 V v1,
 K k2,
 V v2,
 K k3,
 V v3,
 K k4,
 V v4,
 K k5,
 V v5,
 K k6,
 V v6)

of

public static <K,
V> EntryStream<K,V> of(K k1,
 V v1,
 K k2,
 V v2,
 K k3,
 V v3,
 K k4,
 V v4,
 K k5,
 V v5,
 K k6,
 V v6,
 K k7,
 V v7)

of

public static <K,
V> EntryStream<K,V> of(Map<? extends K,? extends V> map)

of

public static <K,
V> EntryStream<K,V> of(Iterator<? extends Map.Entry<? extends K,? extends V>> iterator)

of

public static <K,
V> EntryStream<K,V> of(Iterable<? extends Map.Entry<? extends K,? extends V>> entries)

of

public static <E> EntryStream<E,Integer> of(Multiset<E> multiset)

of

public static <E> EntryStream<E,Long> of(LongMultiset<E> multiset)

of

public static <K,
E,
V extends Collection<E>>
EntryStream<K,V> of(Multimap<K,E,V> mulitmap)

of

public static <K,
T> EntryStream<K,T> of(T[] a,
 Function<? super T,K> keyMapper)

of

public static <K,
T> EntryStream<K,T> of(Iterable<? extends T> c,
 Function<? super T,K> keyMapper)

of

public static <K,
T> EntryStream<K,T> of(Iterator<? extends T> iter,
 Function<? super T,K> keyMapper)

concat

@SafeVarargs
public static <K,
V> EntryStream<K,V> concat(Map<K,V>... maps)

concat

public static <K,
V> EntryStream<K,V> concat(Collection<? extends Map<K,V>> maps)

merge

public static <K,
V> EntryStream<K,V> merge(Map<K,V> a,
 Map<K,V> b,
 BiFunction<? super Map.Entry<K,V>,? super Map.Entry<K,V>,MergeResult> nextSelector)

merge

public static <K,
V> EntryStream<K,V> merge(Map<K,V> a,
 Map<K,V> b,
 Map<K,V> c,
 BiFunction<? super Map.Entry<K,V>,? super Map.Entry<K,V>,MergeResult> nextSelector)

merge

public static <K,
V> EntryStream<K,V> merge(Collection<? extends Map<K,V>> maps,
 BiFunction<? super Map.Entry<K,V>,? super Map.Entry<K,V>,MergeResult> nextSelector)

zip

public static <K,
V> EntryStream<K,V> zip(K[] keys,
 V[] values)

zip

public static <K,
V> EntryStream<K,V> zip(K[] keys,
 V[] values,
 K valueForNonKey,
 V valueForNonValue)

zip

public static <K,
V> EntryStream<K,V> zip(Iterable<? extends K> keys,
 Iterable<? extends V> values)

zip

public static <K,
V> EntryStream<K,V> zip(Iterable<? extends K> keys,
 Iterable<? extends V> values,
 K valueForNonKey,
 V valueForNonValue)

rateLimited

public EntryStream<K,V> rateLimited(double permitsPerSecond)

Specified by:

rateLimited in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

See Also:

• RateLimiter.create(double)

sliding

public Stream<EntryStream<K,V>> sliding(int windowSize)

Specified by:

sliding in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

See Also:

• BaseStream.sliding(int, int)

slidingToList

public Stream<List<Map.Entry<K,V>>> slidingToList(int windowSize)

Specified by:

slidingToList in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

See Also:

• BaseStream.sliding(int, int)

throwIfEmpty

@SequentialOnly
@IntermediateOp
public EntryStream<K,V> throwIfEmpty(Supplier<? extends RuntimeException> exceptionSupplier)

Specified by:

throwIfEmpty in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

toImmutableList

public ImmutableList<Map.Entry<K,V>> toImmutableList()

Specified by:

toImmutableList in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

toImmutableSet

public ImmutableSet<Map.Entry<K,V>> toImmutableSet()

Specified by:

toImmutableSet in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

println

public void println()

Specified by:

println in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

__

public <SS extends BaseStream> SS __(Function<? super EntryStream<K,V>,? extends SS> transfer)

Specified by:

__ in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

parallel

public EntryStream<K,V> parallel(BaseStream.Splitor splitor)

Description copied from interface: BaseStream

Consider using sps(ParallelSettings, Function) if only next operation need to be parallelized. For example:

 stream.parallel(splitor).map(f).filter(p)...;

 // Replace above line of code with "sps" if only "f" need to be parallelized. And "p" is fast enough to be executed in sequential Stream.
 stream.sps(SP.create(splitor), s -> s.map(f)).filter(p)...;
 // Or switch the stream back sequential stream if don't use "sps".
 stream.parallel(splitor).map(f).sequential().filter(p)...;

 

In most scenarios, there could be only one operation need be parallelized in the stream. So sps(ParallelSettings, Function) is recommended in most of scenarios.

Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

See Also:

• BaseStream.parallel(Executor)
• BaseStream.parallel(int, Executor)
• BaseStream.parallel(int, Splitor, Executor)
• BaseStream.sps(Function)
• BaseStream.sps(int, Function)
• BaseStream.sps(ParallelSettings, Function)

parallel

public EntryStream<K,V> parallel(BaseStream.ParallelSettings ps)

Description copied from interface: BaseStream

Consider using sps(ParallelSettings, Function) if only next operation need to be parallelized. For example:

 stream.parallel(parallelSettings).map(f).filter(p)...;

 // Replace above line of code with "sps" if only "f" need to be parallelized. And "p" is fast enough to be executed in sequential Stream.
 stream.sps(SP.create(parallelSettings), s -> s.map(f)).filter(p)...;
 // Or switch the stream back sequential stream if don't use "sps".
 stream.parallel(parallelSettings).map(f).sequential().filter(p)...;

 

In most scenarios, there could be only one operation need be parallelized in the stream. So sps(ParallelSettings, Function) is recommended in most of scenarios.

Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

See Also:

• BaseStream.sps(Function)
• BaseStream.sps(int, Function)
• BaseStream.sps(ParallelSettings, Function)

sps

public <SS extends BaseStream> SS sps(Function<? super EntryStream<K,V>,? extends SS> ops)

Description copied from interface: BaseStream

Temporarily switch the stream to parallel stream for operation ops and then switch back to sequence stream.
stream().parallel().ops(map/filter/...).sequence()

Specified by:

sps in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

sps

public <SS extends BaseStream> SS sps(int maxThreadNum,
 Function<? super EntryStream<K,V>,? extends SS> ops)

Description copied from interface: BaseStream

Temporarily switch the stream to parallel stream for operation ops and then switch back to sequence stream.
stream().parallel(maxThreadNum).ops(map/filter/...).sequence()

Specified by:

sps in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

sps

public <SS extends BaseStream> SS sps(BaseStream.ParallelSettings ps,
 Function<? super EntryStream<K,V>,? extends SS> ops)

Description copied from interface: BaseStream

Temporarily switch the stream to parallel stream for operation ops and then switch back to sequence stream.
stream().parallel(ps).ops(map/filter/...).sequence()

Specified by:

sps in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

psp

public <SS extends BaseStream> SS psp(Function<? super EntryStream<K,V>,? extends SS> ops)

Description copied from interface: BaseStream

Temporarily switch the stream to sequence stream for operation ops and then switch back to parallel stream with same maxThreadNum/splitor/asyncExecutor.
stream().sequence().ops(map/filter/...).parallel(sameMaxThreadNum, sameSplitor, sameAsyncExecutor)

Specified by:

psp in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

toArray

public Object[] toArray()

Specified by:

toArray in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>