com.landawn.abacus.util.stream

Class EntryStream<K,V>

java.lang.Object

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

All Implemented Interfaces:

java.lang.AutoCloseable

public final class EntryStream<K,V>
extends java.lang.Object
implements java.lang.AutoCloseable

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

Method Summary

Modifier and Type	Method and Description
<R> R	__(Function<? super EntryStream<K,V>,R> transfer)
<E extends java.lang.Exception> boolean	allMatch(Try.BiPredicate<? super K,? super V,E> predicate)
<E extends java.lang.Exception> boolean	allMatch(Try.Predicate<? super java.util.Map.Entry<K,V>,E> predicate)
<E extends java.lang.Exception> boolean	anyMatch(Try.BiPredicate<? super K,? super V,E> predicate)
<E extends java.lang.Exception> boolean	anyMatch(Try.Predicate<? super java.util.Map.Entry<K,V>,E> predicate)
<M extends java.util.Map<? extends K,? extends V>> EntryStream<K,V>	append(M map)
EntryStream<K,V>	appendIfEmpty(Supplier<? extends EntryStream<K,V>> supplier)
<KK,VV> EntryStream<KK,VV>	chain(Function<? super Stream<java.util.Map.Entry<K,V>>,? extends Stream<java.util.Map.Entry<KK,VV>>> transfer)
void	close()
Stream<java.util.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,A> R	collect(Collector<? super java.util.Map.Entry<K,V>,A,R> collector)
<R,A> R	collect(java.util.stream.Collector<? super java.util.Map.Entry<K,V>,A,R> collector)
<R> R	collect(Supplier<R> supplier, BiConsumer<? super R,? super java.util.Map.Entry<K,V>> accumulator)
<R> R	collect(Supplier<R> supplier, BiConsumer<? super R,? super java.util.Map.Entry<K,V>> accumulator, BiConsumer<R,R> combiner)
<R,A,RR> RR	collectAndThen(Collector<? super java.util.Map.Entry<K,V>,A,R> downstream, Function<? super R,RR> finisher)
<R,A,RR> RR	collectAndThen(java.util.stream.Collector<? super java.util.Map.Entry<K,V>,A,R> downstream, java.util.function.Function<? super R,RR> finisher)
static <K,V> EntryStream<K,V>	concat(java.util.Collection<? extends java.util.Map<K,V>> maps)
static <K,V> EntryStream<K,V>	concat(java.util.Map<K,V>... maps)
long	count()
EntryStream<K,V>	distinct()
EntryStream<K,V>	distinct(Predicate<? super java.lang.Long> occurrencesFilter)
EntryStream<K,V>	distinctBy(Function<? super java.util.Map.Entry<K,V>,?> keyMapper)
EntryStream<K,V>	distinctBy(Function<? super java.util.Map.Entry<K,V>,?> keyMapper, Predicate<? super java.lang.Long> occurrencesFilter)
EntryStream<K,V>	distinctByKey()
EntryStream<K,V>	distinctByValue()
<KK> EntryStream<K,V>	dropWhile(BiPredicate<? super K,? super V> predicate)
<KK> EntryStream<K,V>	dropWhile(Predicate<? super java.util.Map.Entry<K,V>> predicate)
static <K,V> EntryStream<K,V>	empty()
Stream<java.util.Map.Entry<K,V>>	entries()
<KK> EntryStream<K,V>	filter(BiPredicate<? super K,? super V> predicate)
<KK> EntryStream<K,V>	filter(Predicate<? super java.util.Map.Entry<K,V>> predicate)
<KK> EntryStream<K,V>	filterByKey(Predicate<? super K> keyPredicate)
<KK> EntryStream<K,V>	filterByValue(Predicate<? super V> valuePredicate)
<E extends java.lang.Exception> u.Optional<java.util.Map.Entry<K,V>>	findAny(Try.BiPredicate<? super K,? super V,E> predicate)
<E extends java.lang.Exception> u.Optional<java.util.Map.Entry<K,V>>	findAny(Try.Predicate<? super java.util.Map.Entry<K,V>,E> predicate)
<E extends java.lang.Exception> u.Optional<java.util.Map.Entry<K,V>>	findFirst(Try.BiPredicate<? super K,? super V,E> predicate)
<E extends java.lang.Exception> u.Optional<java.util.Map.Entry<K,V>>	findFirst(Try.Predicate<? super java.util.Map.Entry<K,V>,E> predicate)
u.Optional<java.util.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 java.util.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 java.util.Map<? extends KK,? extends VV>> mapper)
<KK,VV> EntryStream<KK,VV>	flatMapp(Function<? super java.util.Map.Entry<K,V>,? extends java.util.Map<? 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 Stream<? extends java.util.Map.Entry<? extends KK,? extends VV>>> mapper)
<KK,VV> EntryStream<KK,VV>	flattMap(Function<? super java.util.Map.Entry<K,V>,? extends Stream<? extends java.util.Map.Entry<? extends KK,? extends VV>>> mapper)
<KK> EntryStream<KK,V>	flattMapKey(BiFunction<? super K,? super V,? extends java.util.Collection<? extends KK>> keyMapper)
<KK> EntryStream<KK,V>	flattMapKey(Function<? super K,? extends java.util.Collection<? extends KK>> keyMapper)
<KK> EntryStream<KK,V>	flattMapKeyToDisposableEntry(Function<? super K,? extends java.util.Collection<? extends KK>> keyMapper) Deprecated.
<VV> EntryStream<K,VV>	flattMapValue(BiFunction<? super K,? super V,? extends java.util.Collection<? extends VV>> valueMapper)
<VV> EntryStream<K,VV>	flattMapValue(Function<? super V,? extends java.util.Collection<? extends VV>> valueMapper)
<VV> EntryStream<K,VV>	flattMapValueToDisposableEntry(Function<? super V,? extends java.util.Collection<? extends VV>> valueMapper) Deprecated.
<E extends java.lang.Exception> void	forEach(Try.BiConsumer<? super K,? super V,E> action)
<E extends java.lang.Exception> void	forEach(Try.Consumer<? super java.util.Map.Entry<K,V>,E> action)
EntryStream<K,java.util.List<V>>	groupBy()
EntryStream<K,V>	groupBy(BinaryOperator<V> mergeFunction)
EntryStream<K,V>	groupBy(BinaryOperator<V> mergeFunction, Supplier<? extends java.util.Map<K,V>> mapFactory)
<A,D> EntryStream<K,D>	groupBy(Collector<? super java.util.Map.Entry<K,V>,A,D> downstream)
<A,D> EntryStream<K,D>	groupBy(Collector<? super java.util.Map.Entry<K,V>,A,D> downstream, Supplier<? extends java.util.Map<K,D>> mapFactory)
<KK,A,D> EntryStream<KK,D>	groupBy(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper, Collector<? super java.util.Map.Entry<K,V>,A,D> downstream)
<KK,A,D> EntryStream<KK,D>	groupBy(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper, Collector<? super java.util.Map.Entry<K,V>,A,D> downstream, Supplier<? extends java.util.Map<KK,D>> mapFactory)
<KK,VV> EntryStream<KK,java.util.List<VV>>	groupBy(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper, Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper)
<KK,VV> EntryStream<KK,VV>	groupBy(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper, Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper, BinaryOperator<VV> mergeFunction)
<KK,VV> EntryStream<KK,VV>	groupBy(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper, Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper, BinaryOperator<VV> mergeFunction, Supplier<? extends java.util.Map<KK,VV>> mapFactory)
<KK,VV> EntryStream<KK,java.util.List<VV>>	groupBy(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper, Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper, Supplier<? extends java.util.Map<KK,java.util.List<VV>>> mapFactory)
EntryStream<K,java.util.List<V>>	groupBy(Supplier<? extends java.util.Map<K,java.util.List<V>>> mapFactory)
java.util.Map<K,java.util.List<V>>	groupTo()
<KK,VV> java.util.Map<KK,java.util.List<VV>>	groupTo(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper, Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper)
<KK,VV,M extends java.util.Map<KK,java.util.List<VV>>> M	groupTo(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper, Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper, Supplier<? extends M> mapFactory)
<M extends java.util.Map<K,java.util.List<V>>> M	groupTo(Supplier<? extends M> mapFactory)
<R> R	groupToAndThen(Function<? super java.util.Map<K,java.util.List<V>>,R> func)
EntryStream<V,K>	inversed()
EntryStream<V,K>	inversedToDisposableEntry() Deprecated.
boolean	isParallel()
BiIterator<K,V>	iterator() Remember to close this Stream after the iteration is done, if required.
java.lang.String	join(java.lang.CharSequence delimiter)
java.lang.String	join(java.lang.CharSequence delimiter, java.lang.CharSequence keyValueDelimiter)
java.lang.String	join(java.lang.CharSequence delimiter, java.lang.CharSequence prefix, java.lang.CharSequence suffix)
java.lang.String	join(java.lang.CharSequence delimiter, java.lang.CharSequence keyValueDelimiter, java.lang.CharSequence prefix, java.lang.CharSequence suffix)
Stream<K>	keys()
u.Optional<java.util.Map.Entry<K,V>>	last()
EntryStream<K,V>	limit(long maxSize)
<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(BiFunction<? super K,? super V,? extends java.util.Map.Entry<? extends KK,? extends VV>> mapper)
<KK,VV> EntryStream<KK,VV>	map(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper, Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper)
<KK,VV> EntryStream<KK,VV>	map(Function<? super java.util.Map.Entry<K,V>,? extends java.util.Map.Entry<? extends KK,? extends VV>> mapper)
<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,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 java.util.Map.Entry<K,V>,? extends KK> keyMapper, Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper) Deprecated.
<VV> EntryStream<K,VV>	mapValue(BiFunction<? super K,? super V,? extends VV> keyMapper)
<VV> EntryStream<K,VV>	mapValue(Function<? super V,? extends VV> valueMapper)
u.Optional<java.util.Map.Entry<K,V>>	max(java.util.Comparator<? super java.util.Map.Entry<K,V>> comparator)
u.Optional<java.util.Map.Entry<K,V>>	maxBy(Function<? super java.util.Map.Entry<K,V>,? extends java.lang.Comparable> keyMapper)
u.Optional<java.util.Map.Entry<K,V>>	maxByKey(java.util.Comparator<? super K> keyComparator)
u.Optional<java.util.Map.Entry<K,V>>	maxByValue(java.util.Comparator<? super V> valueComparator)
static <K,V> EntryStream<K,V>	merge(java.util.Collection<? extends java.util.Map<K,V>> maps, BiFunction<? super java.util.Map.Entry<K,V>,? super java.util.Map.Entry<K,V>,com.landawn.abacus.util.Nth> nextSelector)
static <K,V> EntryStream<K,V>	merge(java.util.Map<K,V> a, java.util.Map<K,V> b, BiFunction<? super java.util.Map.Entry<K,V>,? super java.util.Map.Entry<K,V>,com.landawn.abacus.util.Nth> nextSelector)
static <K,V> EntryStream<K,V>	merge(java.util.Map<K,V> a, java.util.Map<K,V> b, java.util.Map<K,V> c, BiFunction<? super java.util.Map.Entry<K,V>,? super java.util.Map.Entry<K,V>,com.landawn.abacus.util.Nth> nextSelector)
u.Optional<java.util.Map.Entry<K,V>>	min(java.util.Comparator<? super java.util.Map.Entry<K,V>> comparator)
u.Optional<java.util.Map.Entry<K,V>>	minBy(Function<? super java.util.Map.Entry<K,V>,? extends java.lang.Comparable> keyMapper)
u.Optional<java.util.Map.Entry<K,V>>	minByKey(java.util.Comparator<? super K> keyComparator)
u.Optional<java.util.Map.Entry<K,V>>	minByValue(java.util.Comparator<? super V> valueComparator)
<E extends java.lang.Exception> boolean	noneMatch(Try.BiPredicate<? super K,? super V,E> predicate)
<E extends java.lang.Exception> boolean	noneMatch(Try.Predicate<? super java.util.Map.Entry<K,V>,E> predicate)
static <K,V> EntryStream<K,V>	of(java.util.Collection<? extends java.util.Map.Entry<? extends K,? extends V>> entries)
static <K,T> EntryStream<K,T>	of(java.util.Collection<? extends T> c, Function<? super T,K> keyMapper)
static <K,V> EntryStream<K,V>	of(java.util.Iterator<? extends java.util.Map.Entry<? extends K,? extends V>> iterator)
static <K,T> EntryStream<K,T>	of(java.util.Iterator<? extends T> iter, Function<? super T,K> keyMapper)
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 <E> EntryStream<E,java.lang.Long>	of(LongMultiset<E> multiset)
static <K,V> EntryStream<K,V>	of(java.util.Map<K,V> map)
static <K,E,V extends java.util.Collection<E>> EntryStream<K,V>	of(Multimap<K,E,V> mulitmap)
static <E> EntryStream<E,java.lang.Integer>	of(Multiset<E> multiset)
static <K,T> EntryStream<K,T>	of(T[] a, Function<? super T,K> keyMapper)
EntryStream<K,V>	onClose(java.lang.Runnable closeHandler)
EntryStream<K,V>	parallel()
EntryStream<K,V>	parallel(java.util.concurrent.Executor executor)
EntryStream<K,V>	parallel(int threadNum)
EntryStream<K,V>	parallel(int maxThreadNum, BaseStream.Splitor splitor)
EntryStream<K,V>	parallel(int maxThreadNum, java.util.concurrent.Executor executor)
EntryStream<K,V>	peek(BiConsumer<? super K,? super V> action)
EntryStream<K,V>	peek(Consumer<? super java.util.Map.Entry<K,V>> action)
<M extends java.util.Map<? extends K,? extends V>> EntryStream<K,V>	prepend(M map)
u.Optional<java.util.Map.Entry<K,V>>	reduce(BinaryOperator<java.util.Map.Entry<K,V>> accumulator)
java.util.Map.Entry<K,V>	reduce(ImmutableEntry<K,V> identity, BinaryOperator<java.util.Map.Entry<K,V>> accumulator)
<KK> EntryStream<K,V>	removeIf(BiPredicate<? super K,? super V> predicate)
<KK> EntryStream<K,V>	removeIf(Predicate<? super java.util.Map.Entry<K,V>> predicate)
EntryStream<K,V>	reversed()
EntryStream<K,V>	rotated(int distance)
<KK> EntryStream<KK,V>	selectByKey(java.lang.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(java.lang.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()
EntryStream<K,V>	shuffled(java.util.Random rnd)
EntryStream<K,V>	skip(long n)
EntryStream<K,V>	slice(long from, long to)
EntryStream<K,V>	sorted(java.util.Comparator<? super java.util.Map.Entry<K,V>> comparator)
EntryStream<K,V>	sortedBy(Function<? super java.util.Map.Entry<K,V>,? extends java.lang.Comparable> keyMapper)
EntryStream<K,V>	sortedByDouble(ToDoubleFunction<? super java.util.Map.Entry<K,V>> keyMapper)
EntryStream<K,V>	sortedByInt(ToIntFunction<? super java.util.Map.Entry<K,V>> keyMapper)
EntryStream<K,V>	sortedByKey(java.util.Comparator<? super K> keyComparator)
EntryStream<K,V>	sortedByLong(ToLongFunction<? super java.util.Map.Entry<K,V>> keyMapper)
EntryStream<K,V>	sortedByValue(java.util.Comparator<? super V> valueComparator)
<KK> EntryStream<K,V>	takeWhile(BiPredicate<? super K,? super V> predicate)
<KK> EntryStream<K,V>	takeWhile(Predicate<? super java.util.Map.Entry<K,V>> predicate)
<T,CC extends java.util.Collection<T>> CC	toCollection(BiFunction<? super K,? super V,? extends T> mapper, Supplier<? extends CC> supplier)
<T,CC extends java.util.Collection<T>> CC	toCollection(Function<? super java.util.Map.Entry<K,V>,? extends T> mapper, Supplier<? extends CC> supplier)
ImmutableMap<K,V>	toImmutableMap()
ImmutableMap<K,V>	toImmutableMap(BinaryOperator<V> mergeFunction)
<T> java.util.List<T>	toList(BiFunction<? super K,? super V,? extends T> mapper)
<T> java.util.List<T>	toList(Function<? super java.util.Map.Entry<K,V>,? extends T> mapper)
java.util.Map<K,V>	toMap()
java.util.Map<K,V>	toMap(BinaryOperator<V> mergeFunction)
<M extends java.util.Map<K,V>> M	toMap(BinaryOperator<V> mergeFunction, Supplier<? extends M> mapFactory)
<A,D> java.util.Map<K,D>	toMap(Collector<? super java.util.Map.Entry<K,V>,A,D> downstream)
<A,D,M extends java.util.Map<K,D>> M	toMap(Collector<? super java.util.Map.Entry<K,V>,A,D> downstream, Supplier<? extends M> mapFactory)
<KK,A,D> java.util.Map<KK,D>	toMap(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper, Collector<? super java.util.Map.Entry<K,V>,A,D> downstream)
<KK,A,D,M extends java.util.Map<KK,D>> M	toMap(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper, Collector<? super java.util.Map.Entry<K,V>,A,D> downstream, Supplier<? extends M> mapFactory)
<KK,VV> java.util.Map<KK,VV>	toMap(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper, Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper)
<KK,VV> java.util.Map<KK,VV>	toMap(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper, Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper, BinaryOperator<VV> mergeFunction)
<KK,VV,M extends java.util.Map<KK,VV>> M	toMap(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper, Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper, BinaryOperator<VV> mergeFunction, Supplier<? extends M> mapFactory)
<KK,VV,M extends java.util.Map<KK,VV>> M	toMap(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper, Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper, Supplier<? extends M> mapFactory)
<M extends java.util.Map<K,V>> M	toMap(Supplier<? extends M> mapFactory)
<R> R	toMapAndThen(Function<? super java.util.Map<K,V>,R> func)
ListMultimap<K,V>	toMultimap()
<KK,VV> ListMultimap<KK,VV>	toMultimap(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper, Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper)
<KK,VV,C extends java.util.Collection<VV>,M extends Multimap<KK,VV,C>> M	toMultimap(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper, Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper, Supplier<? extends M> mapFactory)
<C extends java.util.Collection<V>,M extends Multimap<K,V,C>> M	toMultimap(Supplier<? extends M> mapFactory)
<T> java.util.Set<T>	toSet(BiFunction<? super K,? super V,? extends T> mapper)
<T> java.util.Set<T>	toSet(Function<? super java.util.Map.Entry<K,V>,? extends T> mapper)
Stream<V>	values()
static <K,V> EntryStream<K,V>	zip(java.util.Collection<? extends K> keys, java.util.Collection<? extends V> values)
static <K,V> EntryStream<K,V>	zip(java.util.Collection<? extends K> keys, java.util.Collection<? 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 Detail

keys

public Stream<K> keys()

values

public Stream<V> values()

entries

public Stream<java.util.Map.Entry<K,V>> entries()

inversed

@ParallelSupported
public EntryStream<V,K> inversed()

selectByKey

@SequentialOnly
public <KK> EntryStream<KK,V> selectByKey(java.lang.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:

the new stream

selectByValue

@SequentialOnly
public <VV> EntryStream<K,VV> selectByValue(java.lang.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:

the new stream

filter

@ParallelSupported
public <KK> EntryStream<K,V> filter(Predicate<? super java.util.Map.Entry<K,V>> predicate)

filter

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

filterByKey

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

filterByValue

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

removeIf

@ParallelSupported
public <KK> EntryStream<K,V> removeIf(Predicate<? super java.util.Map.Entry<K,V>> predicate)

removeIf

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

takeWhile

@ParallelSupported
public <KK> EntryStream<K,V> takeWhile(Predicate<? super java.util.Map.Entry<K,V>> predicate)

takeWhile

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

dropWhile

@ParallelSupported
public <KK> EntryStream<K,V> dropWhile(Predicate<? super java.util.Map.Entry<K,V>> predicate)

dropWhile

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

map

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

map

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

map

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

map

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

mapKey

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

mapKey

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

mapValue

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

mapValue

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

flatMap

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

flatMap

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

flattMap

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

flattMap

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

flatMapp

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

flatMapp

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

flatMapKey

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

flatMapKey

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

flattMapKey

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

flattMapKey

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

flatMapValue

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

flatMapValue

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

flattMapValue

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

flattMapValue

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

groupBy

@SequentialOnly
public EntryStream<K,java.util.List<V>> groupBy()

Parameters:

keyMapper -

Returns:

See Also:

Collectors.groupingBy(Function)

groupBy

@SequentialOnly
public EntryStream<K,java.util.List<V>> groupBy(Supplier<? extends java.util.Map<K,java.util.List<V>>> mapFactory)

Parameters:

keyMapper -

mapFactory -

Returns:

See Also:

Collectors.groupingBy(Function, Supplier)

groupBy

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

groupBy

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

Parameters:

keyMapper -

valueMapper -

mapFactory -

Returns:

See Also:

Collectors.toMultimap(Function, Function, Supplier)

groupBy

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

Parameters:

downstream -

Returns:

See Also:

Collectors.groupingBy(Function, Collector)

groupBy

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

Parameters:

downstream -

mapFactory -

Returns:

See Also:

Collectors.groupingBy(Function, Collector)

groupBy

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

Parameters:

keyMapper -

downstream -

mapFactory -

Returns:

See Also:

Collectors.groupingBy(Function, Collector, Supplier)

groupBy

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

Parameters:

keyMapper -

downstream -

Returns:

See Also:

Collectors.groupingBy(Function, Collector)

groupBy

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

Parameters:

mergeFunction -

Returns:

groupBy

@SequentialOnly
public EntryStream<K,V> groupBy(BinaryOperator<V> mergeFunction,
                                                 Supplier<? extends java.util.Map<K,V>> mapFactory)

Parameters:

mergeFunction -

mapFactory -

Returns:

groupBy

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

Parameters:

keyMapper -

valueMapper -

mergeFunction -

Returns:

See Also:

Collectors#groupBy(Function, Function, BinaryOperator)

groupBy

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

Parameters:

keyMapper -

valueMapper -

mergeFunction -

mapFactory -

Returns:

See Also:

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

collapseByKey

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

Parameters:

collapsible -

Returns:

See Also:

Stream.collapse(BiPredicate, Collector)

collapseByKey

@SequentialOnly
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 run sequentially, even in parallel stream.

Parameters:

collapsible -

collector -

Returns:

sorted

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

sortedByKey

@ParallelSupported
public EntryStream<K,V> sortedByKey(java.util.Comparator<? super K> keyComparator)

sortedByValue

@ParallelSupported
public EntryStream<K,V> sortedByValue(java.util.Comparator<? super V> valueComparator)

sortedBy

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

sortedByInt

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

Parameters:

keyMapper -

Returns:

sortedByLong

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

Parameters:

keyMapper -

Returns:

sortedByDouble

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

Parameters:

keyMapper -

Returns:

distinct

@SequentialOnly
public EntryStream<K,V> distinct()

distinctByKey

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

distinctByValue

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

distinctBy

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

distinct

@ParallelSupported
public EntryStream<K,V> distinct(Predicate<? super java.lang.Long> occurrencesFilter)

distinctBy

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

reversed

@SequentialOnly
public EntryStream<K,V> reversed()

shuffled

@SequentialOnly
public EntryStream<K,V> shuffled()

shuffled

@SequentialOnly
public EntryStream<K,V> shuffled(java.util.Random rnd)

rotated

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

prepend

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

append

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

appendIfEmpty

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

skip

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

limit

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

slice

@SequentialOnly
public EntryStream<K,V> slice(long from,
                                               long to)

peek

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

peek

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

forEach

@ParallelSupported
public <E extends java.lang.Exception> void forEach(Try.Consumer<? super java.util.Map.Entry<K,V>,E> action)
                                                                 throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

forEach

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

Throws:

E extends java.lang.Exception

min

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

minByKey

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

minByValue

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

minBy

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

max

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

maxByKey

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

maxByValue

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

maxBy

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

anyMatch

@ParallelSupported
public <E extends java.lang.Exception> boolean anyMatch(Try.Predicate<? super java.util.Map.Entry<K,V>,E> predicate)
                                                                     throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

anyMatch

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

Throws:

E extends java.lang.Exception

allMatch

@ParallelSupported
public <E extends java.lang.Exception> boolean allMatch(Try.Predicate<? super java.util.Map.Entry<K,V>,E> predicate)
                                                                     throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

allMatch

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

Throws:

E extends java.lang.Exception

noneMatch

@ParallelSupported
public <E extends java.lang.Exception> boolean noneMatch(Try.Predicate<? super java.util.Map.Entry<K,V>,E> predicate)
                                                                      throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

noneMatch

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

Throws:

E extends java.lang.Exception

findFirst

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

Throws:

E extends java.lang.Exception

findFirst

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

Throws:

E extends java.lang.Exception

findAny

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

Throws:

E extends java.lang.Exception

findAny

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

Throws:

E extends java.lang.Exception

first

@SequentialOnly
public u.Optional<java.util.Map.Entry<K,V>> first()

last

@SequentialOnly
public u.Optional<java.util.Map.Entry<K,V>> last()

count

@SequentialOnly
public long count()

iterator

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

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

Returns:

toList

public <T> java.util.List<T> toList(Function<? super java.util.Map.Entry<K,V>,? extends T> mapper)

toList

public <T> java.util.List<T> toList(BiFunction<? super K,? super V,? extends T> mapper)

toSet

public <T> java.util.Set<T> toSet(Function<? super java.util.Map.Entry<K,V>,? extends T> mapper)

toSet

public <T> java.util.Set<T> toSet(BiFunction<? super K,? super V,? extends T> mapper)

toCollection

public <T,CC extends java.util.Collection<T>> CC toCollection(Function<? super java.util.Map.Entry<K,V>,? extends T> mapper,
                                                              Supplier<? extends CC> supplier)

toCollection

public <T,CC extends java.util.Collection<T>> CC toCollection(BiFunction<? super K,? super V,? extends T> mapper,
                                                              Supplier<? extends CC> supplier)

toImmutableMap

@ParallelSupported
public ImmutableMap<K,V> toImmutableMap()

Returns:

toImmutableMap

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

Returns:

toMap

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

Returns:

toMap

@SequentialOnly
public java.util.Map<K,V> toMap(BinaryOperator<V> mergeFunction)

Parameters:

mergeFunction -

Returns:

toMap

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

Parameters:

mapFactory -

Returns:

toMap

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

Parameters:

mergeFunction -

mapFactory -

Returns:

toMap

@ParallelSupported
public <KK,VV> java.util.Map<KK,VV> toMap(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper,
                                                              Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper)

Parameters:

keyMapper -

valueMapper -

Returns:

See Also:

Collectors.toMap(Function, Function)

toMap

@ParallelSupported
public <KK,VV,M extends java.util.Map<KK,VV>> M toMap(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper,
                                                                          Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper,
                                                                          Supplier<? extends M> mapFactory)

Parameters:

keyMapper -

valueMapper -

mapFactory -

Returns:

See Also:

Collectors.toMap(Function, Function, Supplier)

toMap

@ParallelSupported
public <KK,VV> java.util.Map<KK,VV> toMap(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper,
                                                              Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper,
                                                              BinaryOperator<VV> mergeFunction)

Parameters:

keyMapper -

valueMapper -

mergeFunction -

Returns:

See Also:

Collectors.toMap(Function, Function, BinaryOperator)

toMap

@ParallelSupported
public <KK,VV,M extends java.util.Map<KK,VV>> M toMap(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper,
                                                                          Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper,
                                                                          BinaryOperator<VV> mergeFunction,
                                                                          Supplier<? extends M> mapFactory)

Parameters:

keyMapper -

valueMapper -

mergeFunction -

mapFactory -

Returns:

See Also:

Collectors.toMap(Function, Function, BinaryOperator, Supplier)

toMap

@ParallelSupported
public <A,D> java.util.Map<K,D> toMap(Collector<? super java.util.Map.Entry<K,V>,A,D> downstream)

Parameters:

downstream -

Returns:

See Also:

Collectors.groupingBy(Function, Collector)

toMap

@ParallelSupported
public <A,D,M extends java.util.Map<K,D>> M toMap(Collector<? super java.util.Map.Entry<K,V>,A,D> downstream,
                                                                      Supplier<? extends M> mapFactory)

Parameters:

downstream -

mapFactory -

Returns:

See Also:

Collectors.groupingBy(Function, Collector)

toMap

@ParallelSupported
public <KK,A,D> java.util.Map<KK,D> toMap(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper,
                                                              Collector<? super java.util.Map.Entry<K,V>,A,D> downstream)

Parameters:

keyMapper -

downstream -

mapFactory -

Returns:

See Also:

Collectors.groupingBy(Function, Collector, Supplier)

toMap

@ParallelSupported
public <KK,A,D,M extends java.util.Map<KK,D>> M toMap(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper,
                                                                          Collector<? super java.util.Map.Entry<K,V>,A,D> downstream,
                                                                          Supplier<? extends M> mapFactory)

Parameters:

keyMapper -

downstream -

Returns:

See Also:

Collectors.groupingBy(Function, Collector)

toMapAndThen

@SequentialOnly
public <R> R toMapAndThen(Function<? super java.util.Map<K,V>,R> func)

groupTo

@SequentialOnly
public java.util.Map<K,java.util.List<V>> groupTo()

Parameters:

keyMapper -

Returns:

See Also:

Collectors.groupingBy(Function)

groupTo

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

Parameters:

keyMapper -

mapFactory -

Returns:

See Also:

Collectors.groupingBy(Function, Supplier)

groupTo

@ParallelSupported
public <KK,VV> java.util.Map<KK,java.util.List<VV>> groupTo(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper,
                                                                                Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper)

groupTo

@ParallelSupported
public <KK,VV,M extends java.util.Map<KK,java.util.List<VV>>> M groupTo(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper,
                                                                                            Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper,
                                                                                            Supplier<? extends M> mapFactory)

Parameters:

keyMapper -

valueMapper -

mapFactory -

Returns:

See Also:

Collectors.toMultimap(Function, Function, Supplier)

groupToAndThen

@SequentialOnly
public <R> R groupToAndThen(Function<? super java.util.Map<K,java.util.List<V>>,R> func)

toMultimap

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

Parameters:

keyMapper -

Returns:

See Also:

Collectors.toMultimap(Function, Function)

toMultimap

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

Parameters:

keyMapper -

mapFactory -

Returns:

See Also:

Collectors.toMultimap(Function, Function, Supplier)

toMultimap

@ParallelSupported
public <KK,VV> ListMultimap<KK,VV> toMultimap(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper,
                                                                  Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper)

Parameters:

keyMapper -

valueMapper -

Returns:

See Also:

Collectors.toMultimap(Function, Function)

toMultimap

@ParallelSupported
public <KK,VV,C extends java.util.Collection<VV>,M extends Multimap<KK,VV,C>> M toMultimap(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper,
                                                                                                               Function<? super java.util.Map.Entry<K,V>,? extends VV> valueMapper,
                                                                                                               Supplier<? extends M> mapFactory)

Parameters:

keyMapper -

valueMapper -

mapFactory -

Returns:

See Also:

Collectors.toMultimap(Function, Function, Supplier)

reduce

@ParallelSupported
public java.util.Map.Entry<K,V> reduce(ImmutableEntry<K,V> identity,
                                                           BinaryOperator<java.util.Map.Entry<K,V>> accumulator)

reduce

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

collect

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

collect

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

collect

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

collect

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

collectAndThen

@ParallelSupported
public <R,A,RR> RR collectAndThen(Collector<? super java.util.Map.Entry<K,V>,A,R> downstream,
                                                      Function<? super R,RR> finisher)

collectAndThen

@ParallelSupported
public <R,A,RR> RR collectAndThen(java.util.stream.Collector<? super java.util.Map.Entry<K,V>,A,R> downstream,
                                                      java.util.function.Function<? super R,RR> finisher)

join

@SequentialOnly
public java.lang.String join(java.lang.CharSequence delimiter)

join

@SequentialOnly
public java.lang.String join(java.lang.CharSequence delimiter,
                                              java.lang.CharSequence prefix,
                                              java.lang.CharSequence suffix)

join

@SequentialOnly
public java.lang.String join(java.lang.CharSequence delimiter,
                                              java.lang.CharSequence keyValueDelimiter)

join

@SequentialOnly
public java.lang.String join(java.lang.CharSequence delimiter,
                                              java.lang.CharSequence keyValueDelimiter,
                                              java.lang.CharSequence prefix,
                                              java.lang.CharSequence suffix)

chain

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

__

@SequentialOnly
public <R> R __(Function<? super EntryStream<K,V>,R> transfer)

sequential

public EntryStream<K,V> sequential()

parallel

public EntryStream<K,V> parallel()

parallel

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

parallel

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

parallel

public EntryStream<K,V> parallel(int maxThreadNum,
                                 java.util.concurrent.Executor executor)

parallel

public EntryStream<K,V> parallel(java.util.concurrent.Executor executor)

isParallel

public boolean isParallel()

inversedToDisposableEntry

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

Deprecated.

Returns:

See Also:

Stream.mapToDisposableEntry(Function, Function)

mapToDisposableEntry

@Deprecated
 @Beta
 @SequentialOnly
public <KK,VV> EntryStream<KK,VV> mapToDisposableEntry(Function<? super java.util.Map.Entry<K,V>,? extends KK> keyMapper,
                                                                                              Function<? super java.util.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

@Deprecated
 @Beta
 @SequentialOnly
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

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

Deprecated.

Parameters:

keyMapper -

Returns:

See Also:

mapToDisposableEntry(Function, Function)

flattMapKeyToDisposableEntry

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

Deprecated.

Parameters:

keyMapper -

Returns:

See Also:

mapToDisposableEntry(Function, Function)

flatMapValueToDisposableEntry

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

Deprecated.

Parameters:

valueMapper -

Returns:

See Also:

mapToDisposableEntry(Function, Function)

flattMapValueToDisposableEntry

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

Deprecated.

Parameters:

valueMapper -

Returns:

See Also:

mapToDisposableEntry(Function, Function)

onClose

@SequentialOnly
public EntryStream<K,V> onClose(java.lang.Runnable closeHandler)

close

@SequentialOnly
public void close()

Specified by:

close in interface java.lang.AutoCloseable

empty

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

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(java.util.Map<K,V> map)

of

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

of

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

of

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

of

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

of

public static <K,E,V extends java.util.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(java.util.Collection<? extends T> c,
                                        Function<? super T,K> keyMapper)

of

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

concat

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

concat

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

merge

public static <K,V> EntryStream<K,V> merge(java.util.Map<K,V> a,
                                           java.util.Map<K,V> b,
                                           BiFunction<? super java.util.Map.Entry<K,V>,? super java.util.Map.Entry<K,V>,com.landawn.abacus.util.Nth> nextSelector)

merge

public static <K,V> EntryStream<K,V> merge(java.util.Map<K,V> a,
                                           java.util.Map<K,V> b,
                                           java.util.Map<K,V> c,
                                           BiFunction<? super java.util.Map.Entry<K,V>,? super java.util.Map.Entry<K,V>,com.landawn.abacus.util.Nth> nextSelector)

merge

public static <K,V> EntryStream<K,V> merge(java.util.Collection<? extends java.util.Map<K,V>> maps,
                                           BiFunction<? super java.util.Map.Entry<K,V>,? super java.util.Map.Entry<K,V>,com.landawn.abacus.util.Nth> 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(java.util.Collection<? extends K> keys,
                                         java.util.Collection<? extends V> values)

zip

public static <K,V> EntryStream<K,V> zip(java.util.Collection<? extends K> keys,
                                         java.util.Collection<? extends V> values,
                                         K valueForNonKey,
                                         V valueForNonValue)