EntryStream (hutool 6.0.0-M20 API)

java.lang.Object
- org.dromara.hutool.core.stream.AbstractEnhancedWrappedStream<Map.Entry<K,V>,EntryStream<K,V>>
- - org.dromara.hutool.core.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 AbstractEnhancedWrappedStream<Map.Entry<K,V>,EntryStream<K,V>>
```
参考StreamEx的EntryStream与vavr的Map，是针对键值对对象Map.Entry特化的单元素增强流实现。
本身可视为一个元素类型为Map.Entry的Stream，用于支持流式处理Map集合中的、或其他键值对类型的数据。

Since:

6.0.0

Author:

huangchengxing

Nested Class Summary
- Nested classes/interfaces inherited from interface java.util.stream.Stream
  Stream.Builder<T>

Field Summary
- Fields inherited from class org.dromara.hutool.core.stream.AbstractEnhancedWrappedStream
  stream
- Fields inherited from interface org.dromara.hutool.core.stream.WrappedStream
  NOT_FOUND_ELEMENT_INDEX

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and 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组合在一起，形成一个新的流: `FastStream<Long> ids = FastStream.of(users).flatMap(user -> FastStream.of(user.getId(), user.getParentId()));`
`<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>> Map<K,C>`	`groupByKey(Collector<V,?,C> collector)` 将键值对按键分组
`<C extends Collection<V>,M extends Map<K,C>> M`	`groupByKey(Supplier<M> mapFactory, 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`填充。
`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`实例本身。
`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)` 包装一个已有的流，若入参为空则返回一个空的串行流。
`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.dromara.hutool.core.stream.AbstractEnhancedWrappedStream
equals, exec, hashCode, toString, unwrap

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.dromara.hutool.core.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.dromara.hutool.core.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.dromara.hutool.core.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

Methods inherited from interface java.util.stream.Stream
builder, concat, generate, iterate

- Method Detail
  - 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(key -> Stream.of(key + "1", key + "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:
    
    实现类

Class EntryStream<K,V>

Nested Class Summary

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

Field Summary

Fields inherited from class org.dromara.hutool.core.stream.AbstractEnhancedWrappedStream

Fields inherited from interface org.dromara.hutool.core.stream.WrappedStream

Method Summary

Methods inherited from class org.dromara.hutool.core.stream.AbstractEnhancedWrappedStream

Methods inherited from class java.lang.Object

Methods inherited from interface org.dromara.hutool.core.stream.TerminableWrappedStream

Methods inherited from interface org.dromara.hutool.core.stream.TransformableWrappedStream

Methods inherited from interface org.dromara.hutool.core.stream.WrappedStream

Methods inherited from interface java.util.stream.Stream

Method Detail

merge

of

of

of

of

empty

distinctByKey

distinctByValue

filter

filterByKey

filterByValue

nonNullKeyValue

nonNullKey

nonNullValue

peekKey

peekValue

sortByKey

sortByValue

push

unshift

append

prepend

toValueStream

toKeyStream

mapKeys

mapValues

map

map

flatMap

flatMapKey

flatMapValue

toMap

toMap

toMap

toTable

toTable

toTableByKey

toTableByKey

toTableByValue

toTableByValue

groupByKey

groupByKey

groupByKey

forEach

inverse

collectKeys

collectValues

anyMatch

allMatch

noneMatch

wrap