Package org.miaixz.bus.core.center.stream

Class EntryStream<K,V>

java.lang.Object

org.miaixz.bus.core.center.stream.EnhancedWrappedStream<Map.Entry<K,V>,EntryStream<K,V>>

org.miaixz.bus.core.center.stream.EntryStream<K,V>

Type Parameters:

K - 键类型

V - 值类型

All Implemented Interfaces:

AutoCloseable, Iterable<Map.Entry<K,V>>, BaseStream<Map.Entry<K,V>,Stream<Map.Entry<K,V>>>, Stream<Map.Entry<K,V>>, TerminableWrappedStream<Map.Entry<K,V>,EntryStream<K,V>>, TransformableWrappedStream<Map.Entry<K,V>,EntryStream<K,V>>, WrappedStream<Map.Entry<K,V>,EntryStream<K,V>>

public class EntryStream<K,V>
extends EnhancedWrappedStream<Map.Entry<K,V>,EntryStream<K,V>>

参考StreamEx的EntryStream与vavr的Map，是针对键值对对象Map.Entry特化的单元素增强流实现。 本身可视为一个元素类型为Map.Entry的Stream， 用于支持流式处理Map集合中的、或其他键值对类型的数据。

Since:

Java 17+

Author:

Kimi Liu

Nested Class Summary

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

Stream.Builder<T>

Field Summary

Fields inherited from class org.miaixz.bus.core.center.stream.EnhancedWrappedStream

stream

Fields inherited from interface org.miaixz.bus.core.center.stream.WrappedStream

NOT_FOUND_ELEMENT_INDEX

Method Summary

Modifier and Type	Method	Description
boolean	allMatch(BiPredicate<? super K,? super V> predicate)	所有键值对是否都符合条件
boolean	anyMatch(BiPredicate<? super K,? super V> predicate)	是否存在任意符合条件的键值对
EntryStream<K,V>	append(Iterable<? extends Map.Entry<K,V>> entries)	将输入元素转为流，返回一个前半段为当前流，后半段为新流的新EasyStream实例
<R> R	collectKeys(Collector<K,?,R> collector)	收集键
<R> R	collectValues(Collector<V,?,R> collector)	收集值
EntryStream<K,V>	distinctByKey()	根据键去重，默认丢弃靠后的
EntryStream<K,V>	distinctByValue()	根据值去重，默认丢弃靠后的
static <K, V> EntryStream<K,V>	empty()	创建一个空的串行流
EntryStream<K,V>	filter(BiPredicate<? super K,? super V> filter)	根据键和值过滤键值对
EntryStream<K,V>	filterByKey(Predicate<? super K> filter)	根据键过滤键值对
EntryStream<K,V>	filterByValue(Predicate<? super V> filter)	根据值过滤键值对
<R> EasyStream<R>	flatMap(Function<? super Map.Entry<K,V>,? extends Stream<? extends R>> mapper)	扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流 这是一个无状态中间操作 例如，将users里所有user的id和parentId组合在一起，形成一个新的流:
<N> EntryStream<N,V>	flatMapKey(Function<? super K,Stream<? extends N>> keyMapper)	将原有流的键执行mapper操作映射为流，流中的所有所有元素仍然对应原本的值， 然后再返回由这些流中所有元素组成的流新EntryStream串行流。 效果类似：
<N> EntryStream<K,N>	flatMapValue(Function<? super V,Stream<? extends N>> valueMapper)	将原有流的值执行mapper操作映射为流，流中的所有所有元素仍然对应原本的键， 然后再返回由这些流中所有元素组成的流新EntryStream串行流。 效果类似：
void	forEach(BiConsumer<K,V> consumer)	遍历键值对
Map<K,List<V>>	groupByKey()	将键值对按键分组
<C extends Collection<V>, M extends Map<K, C>> M	groupByKey(Supplier<M> mapFactory, Collector<V,?,C> collector)	将键值对按键分组
<C extends Collection<V>> Map<K,C>	groupByKey(Collector<V,?,C> collector)	将键值对按键分组
EntryStream<V,K>	inverse()	将键值对翻转
<N> EasyStream<N>	map(BiFunction<? super K,? super V,? extends N> mapper)	将实例转为根据键值对生成的单对象Stream实例
<R> EasyStream<R>	map(Function<? super Map.Entry<K,V>,? extends R> mapper)	返回与指定函数将元素作为参数执行的结果组成的流 这是一个无状态中间操作
<N> EntryStream<N,V>	mapKeys(Function<? super K,? extends N> mapper)	将键映射为另一类型
<N> EntryStream<K,N>	mapValues(Function<? super V,? extends N> mapper)	将值映射为另一类型
static <K, V> EntryStream<K,V>	merge(Iterable<K> keys, Iterable<V> values)	根据键与值的集合创建键值对流，若两集合在相同下标的位置找不到对应的键或值，则使用null填充。 比如: [1, 2, 3]与[1, 2]合并，则得到[{1=1}, {2=2}, {3=null}]。
boolean	noneMatch(BiPredicate<? super K,? super V> predicate)	所有键值对是否都不符合条件
EntryStream<K,V>	nonNullKey()	过滤流中键值对本身，或键值对的键为null的元素
EntryStream<K,V>	nonNullKeyValue()	过滤流中键值对本身、键值对中的值或键为null的元素
EntryStream<K,V>	nonNullValue()	过滤流中键值对本身，或键值对的值为null的元素
static <K, V> EntryStream<K,V>	of(Iterable<? extends Map.Entry<K,V>> entries)	根据一个Map.Entry类型的Iterable创建一个串行流， 对流的操作不会影响到入参的entries实例本身。 若输入流中存在元素为null，则会映射为一个键值皆为null的键值对。
static <T, K, V> EntryStream<K,V>	of(Iterable<T> source, Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper)	根据一个Collection集合中创建一个串行流
static <K, V> EntryStream<K,V>	of(Map<K,V> map)	根据一个Map集合中的键值对创建一个串行流， 对流的操作不会影响到入参的map实例本身
static <K, V> EntryStream<K,V>	of(Stream<? extends Map.Entry<K,V>> stream)	包装一个已有的流，若入参为空则返回一个空的串行流。 若输入流中存在元素为null，则会映射为一个键值皆为null的键值对。
EntryStream<K,V>	peekKey(Consumer<? super K> consumer)	检查键
EntryStream<K,V>	peekValue(Consumer<? super V> consumer)	检查值
EntryStream<K,V>	prepend(Iterable<? extends Map.Entry<K,V>> entries)	将输入元素转为流，返回一个前半段为新流，后半段为当前流的新EasyStream实例
EntryStream<K,V>	push(K key, V value)	向当前流末尾追加元素
EntryStream<K,V>	sortByKey(Comparator<? super K> comparator)	根据键排序
EntryStream<K,V>	sortByValue(Comparator<? super V> comparator)	根据值排序
EasyStream<K>	toKeyStream()	转为键的流
Map<K,V>	toMap()	转为HashMap集合
Map<K,V>	toMap(Supplier<Map<K,V>> mapFactory)	转为Map集合
Map<K,V>	toMap(Supplier<Map<K,V>> mapFactory, BinaryOperator<V> operator)	转为Map集合
<N> Table<N,K,V>	toTable(BiFunction<? super K,? super V,? extends N> rowKeyMapper)	将键值对分组后再转为二维HashMap集合，最终返回一个Table集合
<N> Table<N,K,V>	toTable(BiFunction<? super K,? super V,? extends N> rowKeyMapper, Supplier<Map<K,V>> colMapFactory, BinaryOperator<V> operator)	将键值对分组后再转为二维Map集合，最终返回一个Table集合
<N> Table<N,K,V>	toTableByKey(Function<? super K,? extends N> rowKeyMapper)	将键值对按键分组后再转为二维HashMap集合，最终返回一个Table集合
<N> Table<N,K,V>	toTableByKey(Function<? super K,? extends N> rowKeyMapper, Supplier<Map<K,V>> colMapFactory, BinaryOperator<V> operator)	将键值对按值分组后再转为二维Map集合，最终返回一个Table集合
<N> Table<N,K,V>	toTableByValue(Function<? super V,? extends N> rowKeyMapper)	将键值对按键分组后再转为二维HashMap集合，最终返回一个Table集合
<N> Table<N,K,V>	toTableByValue(Function<? super V,? extends N> rowKeyMapper, Supplier<Map<K,V>> colMapFactory, BinaryOperator<V> operator)	将键值对按值分组后再转为二维Map集合，最终返回一个Table集合
EasyStream<V>	toValueStream()	转为值的流
EntryStream<K,V>	unshift(K key, V value)	项当前流队首追加元素
EntryStream<K,V>	wrap(Stream<Map.Entry<K,V>> stream)	根据一个原始的流，返回一个新包装类实例

Methods inherited from class org.miaixz.bus.core.center.stream.EnhancedWrappedStream

equals, exec, hashCode, toString, unwrap

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.stream.Stream

mapMultiToDouble, mapMultiToInt, mapMultiToLong

Methods inherited from interface org.miaixz.bus.core.center.stream.TerminableWrappedStream

at, findFirst, findFirstIdx, findLast, findLast, findLastIdx, forEachIdx, forEachOrderedIdx, group, group, group, isEmpty, isNotEmpty, join, join, join, partition, partition, partition, toColl, toIdxMap, toIdxMap, toList, toMap, toMap, toMap, toMap, toSet, toUnmodifiableList, toUnmodifiableMap, toUnmodifiableMap, toUnmodifiableSet, toZip

Methods inherited from interface org.miaixz.bus.core.center.stream.TransformableWrappedStream

distinct, dropWhile, filter, filterIdx, flat, flat, flatMapIdx, flatNonNull, flatTree, log, mapIdx, mapMulti, mapNonNull, nonNull, parallel, peekIdx, push, reverse, splice, split, splitList, takeWhile, toEntries, toEntries, unshift, zip

Methods inherited from interface org.miaixz.bus.core.center.stream.WrappedStream

allMatch, anyMatch, close, collect, collect, count, distinct, easyStream, filter, findAny, findFirst, flatMapToDouble, flatMapToInt, flatMapToLong, forEach, forEachOrdered, isParallel, iterator, limit, mapToDouble, mapToInt, mapToLong, max, min, noneMatch, onClose, parallel, peek, reduce, reduce, reduce, sequential, skip, sorted, sorted, spliterator, toArray, toArray, unordered

Method Details

merge

public static <K,
V> EntryStream<K,V> merge(Iterable<K> keys,
 Iterable<V> values)

根据键与值的集合创建键值对流，若两集合在相同下标的位置找不到对应的键或值，则使用null填充。 比如: [1, 2, 3]与[1, 2]合并，则得到[{1=1}, {2=2}, {3=null}]。

Type Parameters:

K - 键类型

V - 值类型

Parameters:

keys - 键集合

values - 值集合

Returns:

EntryStream实例

of

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

根据一个Map集合中的键值对创建一个串行流， 对流的操作不会影响到入参的map实例本身

Type Parameters:

K - 键类型

V - 值类型

Parameters:

map - 集合

Returns:

EntryStream实例

of

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

根据一个Map.Entry类型的Iterable创建一个串行流， 对流的操作不会影响到入参的entries实例本身。 若输入流中存在元素为null，则会映射为一个键值皆为null的键值对。

Type Parameters:

K - 键类型

V - 值类型

Parameters:

entries - Iterable实例

Returns:

EntryStream实例

of

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

根据一个Collection集合中创建一个串行流

Type Parameters:

T - 元素类型

K - 键类型

V - 值类型

Parameters:

source - 原始集合

keyMapper - 键的映射方法

valueMapper - 值的映射方法

Returns:

EntryStream实例

of

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

包装一个已有的流，若入参为空则返回一个空的串行流。 若输入流中存在元素为null，则会映射为一个键值皆为null的键值对。

Type Parameters:

K - 键类型

V - 值类型

Parameters:

stream - 流

Returns:

EntryStream实例

empty

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

创建一个空的串行流

Type Parameters:

K - 键类型

V - 值类型

Returns:

EntryStream实例

distinctByKey

public EntryStream<K,V> distinctByKey()

根据键去重，默认丢弃靠后的

Returns:

EntryStream实例

distinctByValue

public EntryStream<K,V> distinctByValue()

根据值去重，默认丢弃靠后的

Returns:

EntryStream实例

filter

public EntryStream<K,V> filter(BiPredicate<? super K,? super V> filter)

根据键和值过滤键值对

Parameters:

filter - 判断条件

Returns:

EntryStream实例

filterByKey

public EntryStream<K,V> filterByKey(Predicate<? super K> filter)

根据键过滤键值对

Parameters:

filter - 判断条件

Returns:

EntryStream实例

filterByValue

public EntryStream<K,V> filterByValue(Predicate<? super V> filter)

根据值过滤键值对

Parameters:

filter - 判断条件

Returns:

EntryStream实例

nonNullKeyValue

public EntryStream<K,V> nonNullKeyValue()

过滤流中键值对本身、键值对中的值或键为null的元素

Returns:

EntryStream实例

nonNullKey

public EntryStream<K,V> nonNullKey()

过滤流中键值对本身，或键值对的键为null的元素

Returns:

EntryStream实例

nonNullValue

public EntryStream<K,V> nonNullValue()

过滤流中键值对本身，或键值对的值为null的元素

Returns:

EntryStream实例

peekKey

public EntryStream<K,V> peekKey(Consumer<? super K> consumer)

检查键

Parameters:

consumer - 操作

Returns:

EntryStream实例

peekValue

public EntryStream<K,V> peekValue(Consumer<? super V> consumer)

检查值

Parameters:

consumer - 操作

Returns:

EntryStream实例

sortByKey

public EntryStream<K,V> sortByKey(Comparator<? super K> comparator)

根据键排序

Parameters:

comparator - 排序器

Returns:

EntryStream实例

sortByValue

public EntryStream<K,V> sortByValue(Comparator<? super V> comparator)

根据值排序

Parameters:

comparator - 排序器

Returns:

EntryStream实例

push

public EntryStream<K,V> push(K key,
 V value)

向当前流末尾追加元素

Parameters:

key - 键

value - 值

Returns:

EntryStream实例

unshift

public EntryStream<K,V> unshift(K key,
 V value)

项当前流队首追加元素

Parameters:

key - 键

value - 值

Returns:

EntryStream实例

append

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

将输入元素转为流，返回一个前半段为当前流，后半段为新流的新EasyStream实例

Parameters:

entries - 键值对

Returns:

EntryStream实例

prepend

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

将输入元素转为流，返回一个前半段为新流，后半段为当前流的新EasyStream实例

Parameters:

entries - 键值对

Returns:

EntryStream实例

toValueStream

public EasyStream<V> toValueStream()

转为值的流

Returns:

值的流

toKeyStream

public EasyStream<K> toKeyStream()

转为键的流

Returns:

值的流

mapKeys

public <N> EntryStream<N,V> mapKeys(Function<? super K,? extends N> mapper)

将键映射为另一类型

Type Parameters:

N - 新的键类型

Parameters:

mapper - 映射方法

Returns:

EntryStream实例

mapValues

public <N> EntryStream<K,N> mapValues(Function<? super V,? extends N> mapper)

将值映射为另一类型

Type Parameters:

N - 新的值类型

Parameters:

mapper - 映射方法

Returns:

EntryStream实例

map

public <R> EasyStream<R> map(Function<? super Map.Entry<K,V>,? extends R> mapper)

返回与指定函数将元素作为参数执行的结果组成的流 这是一个无状态中间操作

Type Parameters:

R - 函数执行后返回流中元素的类型

Parameters:

mapper - 指定的函数

Returns:

返回叠加操作后的流

map

public <N> EasyStream<N> map(BiFunction<? super K,? super V,? extends N> mapper)

将实例转为根据键值对生成的单对象Stream实例

Type Parameters:

N - 函数执行后返回流中元素的类型

Parameters:

mapper - 映射方法

Returns:

映射后的单对象组成的流

flatMap

public <R> EasyStream<R> flatMap(Function<? super Map.Entry<K,V>,? extends Stream<? extends R>> mapper)

扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流 这是一个无状态中间操作 例如，将users里所有user的id和parentId组合在一起，形成一个新的流:

     FastStream<Long> ids = FastStream.of(users).flatMap(user -> FastStream.of(user.getId(), user.getParentId()));
 

Type Parameters:

R - 拆分后流的元素类型

Parameters:

mapper - 操作，返回流

Returns:

返回叠加拆分操作后的流

flatMapKey

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

将原有流的键执行mapper操作映射为流，流中的所有所有元素仍然对应原本的值， 然后再返回由这些流中所有元素组成的流新EntryStream串行流。 效果类似：

 // unwrap = [{a = 1}, {b = 2}, {c = 3}]
 unwrap.flatMapKey(data -> Stream.of(data + "1", data + "2"));
 // unwrap = [{a1 = 1}, {a2 = 1}, {b1 = 2}, {b2 = 2}, {c1 = 3}, {c2 = 3}]
 

Type Parameters:

N - 新的键类型

Parameters:

keyMapper - 值转映射方法

Returns:

返回叠加拆分操作后的流

flatMapValue

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

将原有流的值执行mapper操作映射为流，流中的所有所有元素仍然对应原本的键， 然后再返回由这些流中所有元素组成的流新EntryStream串行流。 效果类似：

 // unwrap = [{a = 1}, {b = 2}, {c = 3}]
 unwrap.flatMapValue(num -> Stream.of(num, num+1));
 // unwrap = [{a = 1}, {a = 2}, {b = 2}, {b = 3}, {c = 3}, {c = 4}]
 

Type Parameters:

N - 新的值类型

Parameters:

valueMapper - 值转映射方法

Returns:

返回叠加拆分操作后的流

toMap

public Map<K,V> toMap(Supplier<Map<K,V>> mapFactory,
 BinaryOperator<V> operator)

转为Map集合

Parameters:

mapFactory - 获取集合的工厂方法

operator - 当存在重复键时的处理

Returns:

集合

See Also:

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

toMap

public Map<K,V> toMap(Supplier<Map<K,V>> mapFactory)

转为Map集合

Parameters:

mapFactory - 获取集合的工厂方法

Returns:

集合

See Also:

• Collectors.toMap(Function, Function, BinaryOperator)

toMap

public Map<K,V> toMap()

转为HashMap集合

Returns:

集合

Throws:

IllegalArgumentException - 当键重复时抛出

See Also:

• Collectors.toMap(Function, Function)

toTable

public <N> Table<N,K,V> toTable(BiFunction<? super K,? super V,? extends N> rowKeyMapper,
 Supplier<Map<K,V>> colMapFactory,
 BinaryOperator<V> operator)

将键值对分组后再转为二维Map集合，最终返回一个Table集合

Type Parameters:

N - 父集合的键类型

Parameters:

rowKeyMapper - 将键映射为父集合中键的方法

colMapFactory - 创建子集合的工厂方法

operator - 当存在重复键时的处理

Returns:

集合

See Also:

• Collectors.groupingBy(Function, Supplier, Collector)

toTable

public <N> Table<N,K,V> toTable(BiFunction<? super K,? super V,? extends N> rowKeyMapper)

将键值对分组后再转为二维HashMap集合，最终返回一个Table集合

Type Parameters:

N - 父集合的键类型

Parameters:

rowKeyMapper - 创建父集合的工厂方法

Returns:

集合

Throws:

IllegalArgumentException - 当父集合或子集合中的键重复时抛出

toTableByKey

public <N> Table<N,K,V> toTableByKey(Function<? super K,? extends N> rowKeyMapper,
 Supplier<Map<K,V>> colMapFactory,
 BinaryOperator<V> operator)

将键值对按值分组后再转为二维Map集合，最终返回一个Table集合

Type Parameters:

N - 父集合的键类型

Parameters:

rowKeyMapper - 将键映射为父集合中键的方法

colMapFactory - 创建子集合的工厂方法

operator - 当存在重复键时的处理

Returns:

集合

toTableByKey

public <N> Table<N,K,V> toTableByKey(Function<? super K,? extends N> rowKeyMapper)

将键值对按键分组后再转为二维HashMap集合，最终返回一个Table集合

Type Parameters:

N - 父集合的键类型

Parameters:

rowKeyMapper - 创建父集合的工厂方法

Returns:

集合

Throws:

IllegalArgumentException - 当父集合或子集合中的键重复时抛出

toTableByValue

public <N> Table<N,K,V> toTableByValue(Function<? super V,? extends N> rowKeyMapper,
 Supplier<Map<K,V>> colMapFactory,
 BinaryOperator<V> operator)

将键值对按值分组后再转为二维Map集合，最终返回一个Table集合

Type Parameters:

N - 父集合的键类型

Parameters:

rowKeyMapper - 将键映射为父集合中键的方法

colMapFactory - 创建子集合的工厂方法

operator - 当存在重复键时的处理

Returns:

集合

toTableByValue

public <N> Table<N,K,V> toTableByValue(Function<? super V,? extends N> rowKeyMapper)

将键值对按键分组后再转为二维HashMap集合，最终返回一个Table集合

Type Parameters:

N - 父集合的键类型

Parameters:

rowKeyMapper - 创建父集合的工厂方法

Returns:

集合

Throws:

IllegalArgumentException - 当父集合或子集合中的键重复时抛出

groupByKey

public Map<K,List<V>> groupByKey()

将键值对按键分组

Returns:

集合

groupByKey

public <C extends Collection<V>> Map<K,C> groupByKey(Collector<V,?,C> collector)

将键值对按键分组

Type Parameters:

C - 值集合的类型

Parameters:

collector - 对具有相同键的值的收集器

Returns:

集合

groupByKey

public <C extends Collection<V>,
M extends Map<K,
C>>
M groupByKey(Supplier<M> mapFactory,
 Collector<V,?,C> collector)

将键值对按键分组

Type Parameters:

C - 值集合的类型

M - 返回的map集合类型

Parameters:

mapFactory - 创建map集合的工厂方法

collector - 对具有相同键的值的收集器

Returns:

集合

forEach

public void forEach(BiConsumer<K,V> consumer)

遍历键值对

Parameters:

consumer - 操作

inverse

public EntryStream<V,K> inverse()

将键值对翻转

Returns:

EntryStream实例

collectKeys

public <R> R collectKeys(Collector<K,?,R> collector)

收集键

Type Parameters:

R - 返回值类型

Parameters:

collector - 收集器

Returns:

收集容器

collectValues

public <R> R collectValues(Collector<V,?,R> collector)

收集值

Type Parameters:

R - 返回值类型

Parameters:

collector - 收集器

Returns:

收集容器

anyMatch

public boolean anyMatch(BiPredicate<? super K,? super V> predicate)

是否存在任意符合条件的键值对

Parameters:

predicate - 判断条件

Returns:

是否

allMatch

public boolean allMatch(BiPredicate<? super K,? super V> predicate)

所有键值对是否都符合条件

Parameters:

predicate - 判断条件

Returns:

是否

noneMatch

public boolean noneMatch(BiPredicate<? super K,? super V> predicate)

所有键值对是否都不符合条件

Parameters:

predicate - 判断条件

Returns:

是否

wrap

public EntryStream<K,V> wrap(Stream<Map.Entry<K,V>> stream)

根据一个原始的流，返回一个新包装类实例

Parameters:

stream - 流

Returns:

实现类