Package org.miaixz.bus.core.xyz

Class MapKit

java.lang.Object
org.miaixz.bus.core.center.map.MapGets
org.miaixz.bus.core.xyz.MapKit
public class MapKit extends MapGets
Map相关工具类
Since:
Java 17+
Author:
Kimi Liu

  • Constructor Details

    • MapKit

      public MapKit()

  • Method Details

    • isEmpty

      public static boolean isEmpty(Map<?,?> map)
      Map是否为空
      Parameters:
      map - 集合
      Returns:
      是否为空

    • isNotEmpty

      public static boolean isNotEmpty(Map<?,?> map)
      Map是否为非空
      Parameters:
      map - 集合
      Returns:
      是否为非空

    • emptyIfNull

      public static <K, V> Map<K,V> emptyIfNull(Map<K,V> set)
      如果提供的集合为null，返回一个不可变的默认空集合，否则返回原集合 空集合使用Collections.emptyMap()
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      set - 提供的集合，可能为null
      Returns:
      原集合，若为null返回空集合

    • defaultIfEmpty

      public static <T extends Map<K, V>, K, V> T defaultIfEmpty(T map, T defaultMap)
      如果给定Map为空，返回默认Map
      Type Parameters:
      T - 集合类型
      K - 键类型
      V - 值类型
      Parameters:
      map - Map
      defaultMap - 默认Map
      Returns:
      非空（empty）的原Map或默认Map

    • newHashMap

      public static <K, V> HashMap<K,V> newHashMap()
      新建一个HashMap
      Type Parameters:
      K - Key类型
      V - Value类型
      Returns:
      HashMap对象

    • newHashMap

      public static <K, V> HashMap<K,V> newHashMap(int size, boolean isLinked)
      新建一个HashMap
      Type Parameters:
      K - Key类型
      V - Value类型
      Parameters:
      size - 初始大小，由于默认负载因子0.75，传入的size会实际初始大小为size / 0.75 + 1
      isLinked - Map的Key是否有序，有序返回 LinkedHashMap，否则返回 HashMap
      Returns:
      HashMap对象

    • newHashMap

      public static <K, V> HashMap<K,V> newHashMap(int size)
      新建一个HashMap
      Type Parameters:
      K - Key类型
      V - Value类型
      Parameters:
      size - 初始大小，由于默认负载因子0.75，传入的size会实际初始大小为size / 0.75 + 1
      Returns:
      HashMap对象

    • newHashMap

      public static <K, V> HashMap<K,V> newHashMap(boolean isLinked)
      新建一个HashMap
      Type Parameters:
      K - Key类型
      V - Value类型
      Parameters:
      isLinked - Map的Key是否有序，有序返回 LinkedHashMap，否则返回 HashMap
      Returns:
      HashMap对象

    • newTreeMap

      public static <K, V> TreeMap<K,V> newTreeMap(Comparator<? super K> comparator)
      新建TreeMap，Key有序的Map
      Type Parameters:
      K - key的类型
      V - value的类型
      Parameters:
      comparator - Key比较器
      Returns:
      TreeMap

    • newTreeMap

      public static <K, V> TreeMap<K,V> newTreeMap(Map<K,V> map, Comparator<? super K> comparator)
      新建TreeMap，Key有序的Map
      Type Parameters:
      K - key的类型
      V - value的类型
      Parameters:
      map - Map
      comparator - Key比较器
      Returns:
      TreeMap

    • newIdentityMap

      public static <K, V> Map<K,V> newIdentityMap(int size)
      创建键不重复Map
      Type Parameters:
      K - key的类型
      V - value的类型
      Parameters:
      size - 初始容量
      Returns:
      IdentityHashMap

    • newSafeConcurrentHashMap

      public static <K, V> ConcurrentHashMap<K,V> newSafeConcurrentHashMap()
      新建一个初始容量为Normal._16 的SafeConcurrentHashMap
      Type Parameters:
      K - key的类型
      V - value的类型
      Returns:
      SafeConcurrentHashMap

    • newSafeConcurrentHashMap

      public static <K, V> ConcurrentHashMap<K,V> newSafeConcurrentHashMap(int size)
      新建一个SafeConcurrentHashMap
      Type Parameters:
      K - key的类型
      V - value的类型
      Parameters:
      size - 初始容量，当传入的容量小于等于0时，容量为Normal._16
      Returns:
      SafeConcurrentHashMap

    • newSafeConcurrentHashMap

      public static <K, V> ConcurrentHashMap<K,V> newSafeConcurrentHashMap(Map<K,V> map)
      传入一个Map将其转化为SafeConcurrentHashMap类型
      Type Parameters:
      K - key的类型
      V - value的类型
      Parameters:
      map - map
      Returns:
      SafeConcurrentHashMap

    • createMap

      public static <K, V> Map<K,V> createMap(Class<?> mapType)
      创建Map 传入抽象MapAbstractMap和Map类将默认创建HashMap
      Type Parameters:
      K - map键类型
      V - map值类型
      Parameters:
      mapType - map类型
      Returns:
      Map实例

    • createMap

      public static <K, V> Map<K,V> createMap(Class<?> mapType, Supplier<Map<K,V>> defaultMap)
      创建Map 传入抽象MapAbstractMap和Map类将默认创建HashMap
      Type Parameters:
      K - map键类型
      V - map值类型
      Parameters:
      mapType - map类型
      defaultMap - 如果通过反射创建失败或提供的是抽象Map，则创建的默认Map
      Returns:
      Map实例

    • of

      public static <K, V> HashMap<K,V> of(K key, V value)
      将单一键值对转换为Map
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      key - 键
      value - 值
      Returns:
      HashMap

    • of

      public static <K, V> HashMap<K,V> of(K key, V value, boolean isOrder)
      将单一键值对转换为Map
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      key - 键
      value - 值
      isOrder - 是否有序
      Returns:
      HashMap

    • ofKvs

      public static <K, V> Map<K,V> ofKvs(boolean isLinked, Object... keysAndValues)
      根据给定的键值对数组创建HashMap对象，传入参数必须为key,value,data,value...

      奇数参数必须为key，key最后会转换为String类型。

      偶数参数必须为value，可以为任意类型。

       LinkedHashMap map = MapKit.ofKvs(false,
        "RED", "#FF0000",
        "GREEN", "#00FF00",
        "BLUE", "#0000FF"
 );
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      isLinked - 是否使用LinkedHashMap
      keysAndValues - 键值对列表，必须奇数参数为key，偶数参数为value
      Returns:
      LinkedHashMap
      See Also:

    • ofEntries

      @SafeVarargs public static <K, V> Map<K,V> ofEntries(Map.Entry<K,V>... entries)
      根据给定的Pair数组创建Map对象
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      entries - 键值对
      Returns:
      Map
      See Also:

    • ofEntries

      public static <K, V> HashMap<K,V> ofEntries(Iterable<Map.Entry<K,V>> entryIter)
      将Entry集合转换为HashMap
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      entryIter - entry集合
      Returns:
      Map

    • ofEntries

      public static <K, V> HashMap<K,V> ofEntries(Iterator<Map.Entry<K,V>> entryIter)
      将Entry集合转换为HashMap
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      entryIter - entry集合
      Returns:
      Map

    • of

      public static HashMap<Object,Object> of(Object[] array)
      将数组转换为Map（HashMap），支持数组元素类型为： 
       Map.Entry
 长度大于1的数组（取前两个值），如果不满足跳过此元素
 Iterable 长度也必须大于1（取前两个值），如果不满足跳过此元素
 Iterator 长度也必须大于1（取前两个值），如果不满足跳过此元素
 
       Map<Object, Object> colorMap = MapKit.of(new String[][] {
    { "RED", "#FF0000" },
    { "GREEN", "#00FF00" },
    { "BLUE", "#0000FF" }
 });

      参考：commons-lang

      Parameters:
      array - 数组。元素类型为Map.Entry、数组、Iterable、Iterator
      Returns:
      HashMap

    • toListMap

      public static <K, V> Map<K,List<V>> toListMap(Iterable<? extends Map<K,V>> mapList)
      行转列，合并相同的键，值合并为列表 将Map列表中相同key的值组成列表做为Map的value 是toMapList(Map)的逆方法 比如传入数据： 
       [
  {a: 1, b: 1, c: 1}
  {a: 2, b: 2}
  {a: 3, b: 3}
  {a: 4}
 ]

      结果是： 

       {
   a: [1,2,3,4]
   b: [1,2,3,]
   c: [1]
 }
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      mapList - Map列表
      Returns:
      Map

    • toMapList

      public static <K, V> List<Map<K,V>> toMapList(Map<K,? extends Iterable<V>> listMap)
      列转行。将Map中值列表分别按照其位置与key组成新的map。 是toListMap(Iterable)的逆方法 比如传入数据： 
       {
   a: [1,2,3,4]
   b: [1,2,3,]
   c: [1]
 }

      结果是： 

       [
  {a: 1, b: 1, c: 1}
  {a: 2, b: 2}
  {a: 3, b: 3}
  {a: 4}
 ]
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      listMap - 列表Map
      Returns:
      Map列表

    • toCamelCaseMap

      public static <K, V> Map<K,V> toCamelCaseMap(Map<K,V> map)
      将已知Map转换为key为驼峰风格的Map 如果KEY为非String类型，保留原值
      Type Parameters:
      K - key的类型
      V - value的类型
      Parameters:
      map - 原Map
      Returns:
      驼峰风格Map

    • toObjectArray

      public static Object[][] toObjectArray(Map<?,?> map)
      将键值对转换为二维数组，第一维是key，第二维是value
      Parameters:
      map - map
      Returns:
      数组

    • join

      public static <K, V> String join(Map<K,V> map, String separator, String keyValueSeparator, String... otherParams)
      将map转成字符串
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      map - Map
      separator - entry之间的连接符
      keyValueSeparator - kv之间的连接符
      otherParams - 其它附加参数字符串（例如密钥）
      Returns:
      连接字符串

    • sortJoin

      public static String sortJoin(Map<?,?> params, String separator, String keyValueSeparator, boolean isIgnoreNull, String... otherParams)
      根据参数排序后拼接为字符串，常用于签名
      Parameters:
      params - 参数
      separator - entry之间的连接符
      keyValueSeparator - kv之间的连接符
      isIgnoreNull - 是否忽略null的键和值
      otherParams - 其它附加参数字符串（例如密钥）
      Returns:
      签名字符串

    • joinIgnoreNull

      public static <K, V> String joinIgnoreNull(Map<K,V> map, String separator, String keyValueSeparator, String... otherParams)
      将map转成字符串，忽略null的键和值
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      map - Map
      separator - entry之间的连接符
      keyValueSeparator - kv之间的连接符
      otherParams - 其它附加参数字符串（例如密钥）
      Returns:
      连接后的字符串

    • join

      public static <K, V> String join(Map<K,V> map, String separator, String keyValueSeparator, boolean isIgnoreNull, String... otherParams)
      将map转成字符串
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      map - Map，为空返回otherParams拼接
      separator - entry之间的连接符
      keyValueSeparator - kv之间的连接符
      isIgnoreNull - 是否忽略null的键和值
      otherParams - 其它附加参数字符串（例如密钥）
      Returns:
      连接后的字符串，map和otherParams为空返回""

    • join

      public static <K, V> String join(Map<K,V> map, String separator, String keyValueSeparator, Predicate<Map.Entry<K,V>> predicate, String... otherParams)
      将map转成字符串
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      map - Map，为空返回otherParams拼接
      separator - entry之间的连接符
      keyValueSeparator - kv之间的连接符
      predicate - 键值对过滤
      otherParams - 其它附加参数字符串（例如密钥）
      Returns:
      连接后的字符串，map和otherParams为空返回""

    • edit

      public static <K, V> Map<K,V> edit(Map<K,V> map, UnaryOperator<Map.Entry<K,V>> editor)
      编辑Map 编辑过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能： 
       1、过滤出需要的对象，如果返回null表示这个元素对象抛弃
 2、修改元素对象，返回集合中为修改后的对象
      Type Parameters:
      K - Key类型
      V - Value类型
      Parameters:
      map - Map
      editor - 编辑器接口
      Returns:
      编辑后的Map

    • filter

      public static <K, V> Map<K,V> filter(Map<K,V> map, Predicate<Map.Entry<K,V>> predicate)
      过滤 过滤过程通过传入的Editor实现来返回需要的元素内容，这个Filter实现可以实现以下功能： 
       1、过滤出需要的对象，如果返回null表示这个元素对象抛弃
      Type Parameters:
      K - Key类型
      V - Value类型
      Parameters:
      map - Map
      predicate - 过滤器接口，Predicate.test(Object)为true保留，null返回原Map
      Returns:
      过滤后的Map

    • map

      public static <K, V, R> Map<K,R> map(Map<K,V> map, BiFunction<K,V,R> biFunction)
      通过biFunction自定义一个规则，此规则将原Map中的元素转换成新的元素，生成新的Map返回 变更过程通过传入的 BiFunction 实现来返回一个值可以为不同类型的 Map
      Type Parameters:
      K - data的类型
      V - value的类型
      R - 新的，修改后的value的类型
      Parameters:
      map - 原有的map
      biFunction - lambda，参数包含data,value，返回值会作为新的value
      Returns:
      值可以为不同类型的 Map

    • filter

      public static <K, V> Map<K,V> filter(Map<K,V> map, K... keys)
      过滤Map保留指定键值对，如果键不存在跳过
      Type Parameters:
      K - Key类型
      V - Value类型
      Parameters:
      map - 原始Map
      keys - 键列表，null返回原Map
      Returns:
      Map 结果，结果的Map类型与原Map保持一致

    • reverse

      public static <T> Map<T,T> reverse(Map<T,T> map)
      Map的键和值互换 互换键值对不检查值是否有重复，如果有则后加入的元素替换先加入的元素 值的顺序在HashMap中不确定，所以谁覆盖谁也不确定，在有序的Map中按照先后顺序覆盖，保留最后的值
      Type Parameters:
      T - 键和值类型
      Parameters:
      map - Map对象，键值类型必须一致
      Returns:
      互换后的Map
      See Also:

    • inverse

      public static <K, V> Map<V,K> inverse(Map<K,V> map)
      Map的键和值互换 互换键值对不检查值是否有重复，如果有则后加入的元素替换先加入的元素 值的顺序在HashMap中不确定，所以谁覆盖谁也不确定，在有序的Map中按照先后顺序覆盖，保留最后的值
      Type Parameters:
      K - 键和值类型
      V - 键和值类型
      Parameters:
      map - Map对象
      Returns:
      互换后的Map

    • sort

      public static <K, V> TreeMap<K,V> sort(Map<K,V> map)
      排序已有Map，Key有序的Map，使用默认Key排序方式（字母顺序）
      Type Parameters:
      K - key的类型
      V - value的类型
      Parameters:
      map - Map
      Returns:
      TreeMap
      See Also:

    • sort

      public static <K, V> TreeMap<K,V> sort(Map<K,V> map, Comparator<? super K> comparator)
      排序已有Map，Key有序的Map
      Type Parameters:
      K - key的类型
      V - value的类型
      Parameters:
      map - Map，为null返回null
      comparator - Key比较器
      Returns:
      TreeMap，map为null返回null
      See Also:

    • sortByValue

      public static <K, V extends Comparable<? super V>> Map<K,V> sortByValue(Map<K,V> map, boolean isDesc)
      按照值排序，可选是否倒序
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      map - 需要对值排序的map
      isDesc - 是否倒序
      Returns:
      排序后新的Map

    • createProxy

      public static MapProxy createProxy(Map<?,?> map)
      创建代理Map MapProxy对Map做一次包装，提供各种getXXX方法
      Parameters:
      map - 被代理的Map
      Returns:
      MapProxy

    • wrap

      public static <K, V> MapWrapper<K,V> wrap(Map<K,V> map)
      创建Map包装类MapWrapper MapWrapper对Map做一次包装
      Type Parameters:
      K - key的类型
      V - value的类型
      Parameters:
      map - 被代理的Map
      Returns:
      MapWrapper

    • view

      public static <K, V> Map<K,V> view(Map<K,V> map)
      将对应Map转换为不可修改的Map
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      map - Map
      Returns:
      不修改Map

    • builder

      public static <K, V> MapBuilder<K,V> builder()
      创建链接调用map
      Type Parameters:
      K - Key类型
      V - Value类型
      Returns:
      map创建类

    • builder

      public static <K, V> MapBuilder<K,V> builder(Map<K,V> map)
      创建链接调用map
      Type Parameters:
      K - Key类型
      V - Value类型
      Parameters:
      map - 实际使用的map
      Returns:
      map创建类

    • builder

      public static <K, V> MapBuilder<K,V> builder(K k, V v)
      创建链接调用map
      Type Parameters:
      K - Key类型
      V - Value类型
      Parameters:
      k - data
      v - value
      Returns:
      map创建类

    • getAny

      public static <K, V> Map<K,V> getAny(Map<K,V> map, K... keys)
      获取Map的部分key生成新的Map
      Type Parameters:
      K - Key类型
      V - Value类型
      Parameters:
      map - Map
      keys - 键列表
      Returns:
      新Map，只包含指定的key

    • removeAny

      public static <K, V, T extends Map<K, V>> T removeAny(T map, K... keys)
      去掉Map中指定key的键值对，修改原Map
      Type Parameters:
      K - Key类型
      V - Value类型
      T - Map类型
      Parameters:
      map - Map
      keys - 键列表
      Returns:
      修改后的key

    • renameKey

      public static <K, V> Map<K,V> renameKey(Map<K,V> map, K oldKey, K newKey)
      重命名键 实现方式为移除然后重新put，当旧的key不存在直接返回 当新的key存在，抛出IllegalArgumentException 异常
      Type Parameters:
      K - key的类型
      V - value的类型
      Parameters:
      map - Map
      oldKey - 原键
      newKey - 新键
      Returns:
      map
      Throws:
      IllegalArgumentException - 新key存在抛出此异常

    • removeNullValue

      public static <K, V> Map<K,V> removeNullValue(Map<K,V> map)
      去除Map中值为null的键值对 注意：此方法在传入的Map上直接修改。
      Type Parameters:
      K - key的类型
      V - value的类型
      Parameters:
      map - Map
      Returns:
      map

    • removeByValue

      public static <K, V> Map<K,V> removeByValue(Map<K,V> map, V value)
      去除Map中值为指定值的键值对 注意：此方法在传入的Map上直接修改。
      Type Parameters:
      K - key的类型
      V - value的类型
      Parameters:
      map - Map
      value - 给定值
      Returns:
      map

    • removeIf

      public static <K, V> Map<K,V> removeIf(Map<K,V> map, Predicate<Map.Entry<K,V>> predicate)
      去除Map中值为null的键值对 注意：此方法在传入的Map上直接修改。
      Type Parameters:
      K - key的类型
      V - value的类型
      Parameters:
      map - Map
      predicate - 移除条件，当Predicate.test(Object)为true时移除
      Returns:
      map

    • empty

      public static <K, V> Map<K,V> empty()
      返回一个空Map
      Type Parameters:
      K - 键类型
      V - 值类型
      Returns:
      空Map
      See Also:

    • zero

      public static <K, V> Map<K,V> zero()
      返回一个初始大小为0的HashMap(初始为0，可加入元素)
      Type Parameters:
      K - 键类型
      V - 值类型
      Returns:
      初始大小为0的HashMap

    • empty

      public static <K, V, T extends Map<K, V>> T empty(Class<?> mapClass)
      根据传入的Map类型不同，返回对应类型的空Map，支持类型包括： 
           1. NavigableMap
     2. SortedMap
     3. Map
      Type Parameters:
      K - 键类型
      V - 值类型
      T - Map类型
      Parameters:
      mapClass - Map类型，null返回默认的Map
      Returns:
      空Map

    • clear

      public static void clear(Map<?,?>... maps)
      清除一个或多个Map集合内的元素，每个Map调用clear()方法
      Parameters:
      maps - 一个或多个Map

    • valuesOfKeys

      public static <K, V> ArrayList<V> valuesOfKeys(Map<K,V> map, K... keys)
      从Map中获取指定键列表对应的值列表 如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      map - Map
      keys - 键列表
      Returns:
      值列表

    • valuesOfKeys

      public static <K, V> ArrayList<V> valuesOfKeys(Map<K,V> map, Iterable<K> keys)
      从Map中获取指定键列表对应的值列表 如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      map - Map
      keys - 键列表
      Returns:
      值列表

    • valuesOfKeys

      public static <K, V> ArrayList<V> valuesOfKeys(Map<K,V> map, Iterator<K> keys)
      从Map中获取指定键列表对应的值列表 如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      map - Map
      keys - 键列表
      Returns:
      值列表

    • entry

      public static <K, V> Map.Entry<K,V> entry(K key, V value)
      将键和值转换为AbstractMap.SimpleImmutableEntry 返回的Entry不可变
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      key - 键
      value - 值
      Returns:
      AbstractMap.SimpleImmutableEntry

    • entry

      public static <K, V> Map.Entry<K,V> entry(K key, V value, boolean isImmutable)
      将键和值转换为AbstractMap.SimpleEntry 或者 AbstractMap.SimpleImmutableEntry
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      key - 键
      value - 值
      isImmutable - 是否不可变Entry
      Returns:
      AbstractMap.SimpleEntry 或者 AbstractMap.SimpleImmutableEntry

    • putAll

      public static <K, V> Map<K,V> putAll(Map<K,V> resultMap, Iterable<V> iterable, Function<V,K> keyMapper)
      将列表按照给定的键生成器规则和值生成器规则，加入到给定的Map中
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      resultMap - 结果Map，通过传入map对象决定结果的Map类型，如果为null，默认使用HashMap
      iterable - 值列表
      keyMapper - Map的键映射
      Returns:
      HashMap

    • putAll

      public static <T, K, V> Map<K,V> putAll(Map<K,V> resultMap, Iterable<T> iterable, Function<T,K> keyMapper, Function<T,V> valueMapper)
      将列表按照给定的键生成器规则和值生成器规则，加入到给定的Map中
      Type Parameters:
      T - 列表值类型
      K - 键类型
      V - 值类型
      Parameters:
      resultMap - 结果Map，通过传入map对象决定结果的Map类型
      iterable - 值列表
      keyMapper - Map的键映射
      valueMapper - Map的值映射
      Returns:
      HashMap

    • putAll

      public static <K, V> Map<K,V> putAll(Map<K,V> resultMap, Iterator<V> iterator, Function<V,K> keyMapper)
      将列表按照给定的键生成器规则和值生成器规则，加入到给定的Map中
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      resultMap - 结果Map，通过传入map对象决定结果的Map类型，如果为null，默认使用HashMap
      iterator - 值列表
      keyMapper - Map的键映射
      Returns:
      HashMap

    • putAll

      public static <T, K, V> Map<K,V> putAll(Map<K,V> resultMap, Iterator<T> iterator, Function<T,K> keyMapper, Function<T,V> valueMapper)
      将列表按照给定的键生成器规则和值生成器规则，加入到给定的Map中
      Type Parameters:
      T - 列表值类型
      K - 键类型
      V - 值类型
      Parameters:
      resultMap - 结果Map，通过传入map对象决定结果的Map类型，如果为null，默认使用HashMap
      iterator - 值列表
      keyMapper - Map的键映射
      valueMapper - Map的值映射
      Returns:
      HashMap

    • grouping

      public static <K, V> Map<K,List<V>> grouping(Iterable<Map.Entry<K,V>> entries)
      根据给定的entry列表，根据entry的key进行分组;
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      entries - entry列表
      Returns:
      entries

    • computeIfAbsentForJdk8

      public static <K, V> V computeIfAbsentForJdk8(Map<K,V> map, K key, Function<? super K,? extends V> mappingFunction)
      如果 data 对应的 value 不存在，则使用获取 mappingFunction 重新计算后的值，并保存为该 data 的 value，否则返回 value。 解决使用ConcurrentHashMap.computeIfAbsent导致的死循环问题 A temporary workaround for Java 8 specific performance issue JDK-8161372 . This class should be removed once we drop Java 8 support.

      注意此方法只能用于JDK8

      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      map - Map，一般用于线程安全的Map
      key - 键
      mappingFunction - 值计算函数
      Returns:
      值
      See Also:

    • partition

      public static <K, V> List<Map<K,V>> partition(Map<K,V> map, int size)
      将一个Map按照固定大小拆分成多个子Map
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      map - Map
      size - 子Map的大小
      Returns:
      子Map列表

    • firstMatchValue

      public static <K, V> V firstMatchValue(Map<K,V> map, Predicate<Map.Entry<K,V>> predicate)
      遍历Map，返回第一个匹配的value值
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      map - map
      predicate - 匹配条件
      Returns:
      value值

    • firstMatch

      public static <K, V> Map.Entry<K,V> firstMatch(Map<K,V> map, Predicate<Map.Entry<K,V>> predicate)
      遍历Map，返回第一个匹配的entry值
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      map - map
      predicate - 匹配条件
      Returns:
      entry