Package org.aoju.bus.core.toolkit

Class MapKit

java.lang.Object
org.aoju.bus.core.toolkit.MapKit
public class MapKit extends Object
Map相关工具类
Since:
Java 17+
Author:
Kimi Liu

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static final int
    DEFAULT_INITIAL_CAPACITY
    默认初始大小
    static final float
    DEFAULT_LOAD_FACTOR
    默认增长因子,当Map的size达到 容量*增长因子时,开始扩充Map

  • Constructor Summary

    Constructors
    Constructor
    Description
    MapKit()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    static <K, V> MapBuilder<K,V>
    builder()
    创建链接调用map
    static <K, V> MapBuilder<K,V>
    builder(Map<K,V> map)
    创建链接调用map
    static <K, V> MapBuilder<K,V>
    builder(K k, V v)
    创建链接调用map
    static void
    clear(Map<?,?>... maps)
    清除一个或多个Map集合内的元素，每个Map调用clear()方法
    static <K, V> V
    computeIfAbsent(Map<K,V> map, K key, Function<? super K,? extends V> mappingFunction)
    如果 key 对应的 value 不存在，则使用获取 mappingFunction 重新计算后的值，并保存为该 key 的 value，否则返回 value。 方法来自Dubbo，解决使用ConcurrentHashMap.computeIfAbsent导致的死循环问题。（issues#2349） A temporary workaround for Java 8 specific performance issue JDK-8161372 .
    static <K, V> Map<K,V>
    createMap(Class<?> mapType)
    创建Map 传入抽象MapAbstractMap和Map类将默认创建HashMap
    static MapProxy
    createProxy(Map<?,?> map)
    创建代理Map MapProxy对Map做一次包装，提供各种getXXX方法
    static <K, V> Map<K,V>
    edit(Map<K,V> map, UnaryOperator<Map.Entry<K,V>> editor)
    编辑Map 编辑过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能：
    static <K, V> Map<K,V>
    empty()
    返回一个空Map
    static <K, V, T extends Map<K, V>>
    T
    empty(Class<?> mapClass)
    根据传入的Map类型不同，返回对应类型的空Map
    static <K, V> Map.Entry<K,V>
    entry(K key, V value)
    将键和值转换为AbstractMap.SimpleImmutableEntry 返回的Entry不可变
    static <K, V> Map.Entry<K,V>
    entry(K key, V value, boolean isImmutable)
    将键和值转换为AbstractMap.SimpleEntry 或者 AbstractMap.SimpleImmutableEntry
    static <K, V> Map<K,V>
    filter(Map<K,V> map, Predicate<Map.Entry<K,V>> predicate)
    过滤 过滤过程通过传入的Editor实现来返回需要的元素内容,这个Editor实现可以实现以下功能：
    static <K, V> Map<K,V>
    filter(Map<K,V> map, K... keys)
    过滤Map保留指定键值对，如果键不存在跳过
    static <T> T
    get(Map<?,?> map, Object key, Class<T> type)
    获取Map指定key的值，并转换为指定类型
    static <T> T
    get(Map<?,?> map, Object key, Class<T> type, T defaultValue)
    获取Map指定key的值，并转换为指定类型
    static <T> T
    get(Map<?,?> map, Object key, Types<T> type)
    获取Map指定key的值，并转换为指定类型
    static <T> T
    get(Map<?,?> map, Object key, Types<T> type, T defaultValue)
    获取Map指定key的值，并转换为指定类型
    static <K, V> Map<K,V>
    getAny(Map<K,V> map, K... keys)
    获取Map的部分key生成新的Map
    static Boolean
    getBool(Map<?,?> map, Object key)
    获取Map指定key的值，并转换为Bool
    static Boolean
    getBool(Map<?,?> map, Object key, Boolean defaultValue)
    获取Map指定key的值，并转换为Bool
    static Character
    getChar(Map<?,?> map, Object key)
    获取Map指定key的值，并转换为Character
    static Character
    getChar(Map<?,?> map, Object key, Character defaultValue)
    获取Map指定key的值，并转换为Character
    static Date
    getDate(Map<?,?> map, Object key)
    获取Map指定key的值，并转换为Date
    static Date
    getDate(Map<?,?> map, Object key, Date defaultValue)
    获取Map指定key的值，并转换为Date
    static Double
    getDouble(Map<?,?> map, Object key)
    获取Map指定key的值，并转换为Double
    static Double
    getDouble(Map<?,?> map, Object key, Double defaultValue)
    获取Map指定key的值，并转换为Double
    static Float
    getFloat(Map<?,?> map, Object key)
    获取Map指定key的值，并转换为Float
    static Float
    getFloat(Map<?,?> map, Object key, Float defaultValue)
    获取Map指定key的值，并转换为Float
    static Integer
    getInt(Map<?,?> map, Object key)
    获取Map指定key的值，并转换为Integer
    static Integer
    getInt(Map<?,?> map, Object key, Integer defaultValue)
    获取Map指定key的值，并转换为Integer
    static Long
    getLong(Map<?,?> map, Object key)
    获取Map指定key的值，并转换为Long
    static Long
    getLong(Map<?,?> map, Object key, Long defaultValue)
    获取Map指定key的值，并转换为Long
    static <T> T
    getQuietly(Map<?,?> map, Object key, Class<T> type, T defaultValue)
    获取Map指定key的值，并转换为指定类型，此方法在转换失败后不抛异常，返回null。
    static <T> T
    getQuietly(Map<?,?> map, Object key, Types<T> type, T defaultValue)
    获取Map指定key的值，并转换为指定类型，转换失败后返回null，不抛异常
    static Short
    getShort(Map<?,?> map, Object key)
    获取Map指定key的值，并转换为Short
    static Short
    getShort(Map<?,?> map, Object key, Short defaultValue)
    获取Map指定key的值，并转换为Short
    static String
    getString(Map<?,?> map, Object key)
    获取Map指定key的值，并转换为字符串
    static String
    getString(Map<?,?> map, Object key, String defaultValue)
    获取Map指定key的值，并转换为字符串
    static <K, V> Map<K,List<V>>
    grouping(Iterable<Map.Entry<K,V>> entries)
    根据给定的entry列表，根据entry的key进行分组;
    static <K, V> Map<V,K>
    inverse(Map<K,V> map)
    Map的键和值互换 互换键值对不检查值是否有重复，如果有则后加入的元素替换先加入的元素 值的顺序在HashMap中不确定，所以谁覆盖谁也不确定，在有序的Map中按照先后顺序覆盖，保留最后的值
    static boolean
    isEmpty(Map<?,?> map)
    Map是否为空
    static boolean
    isNotEmpty(Map<?,?> map)
    Map是否为非空
    static <K, V> String
    join(Map<K,V> map, String separator, String keyValueSeparator, boolean isIgnoreNull, String... otherParams)
    将map转成字符串
    static <K, V> String
    join(Map<K,V> map, String separator, String keyValueSeparator, String... otherParams)
    将map转成字符串
    static <K, V> String
    join(Map<K,V> map, String separator, String keyValueSeparator, Predicate<Map.Entry<K,V>> predicate, String... otherParams)
    将map转成字符串
    static <K, V> String
    joinIgnoreNull(Map<K,V> map, String separator, String keyValueSeparator, String... otherParams)
    将map转成字符串，忽略null的键和值
    static <K, V, R> Map<K,R>
    map(Map<K,V> map, BiFunction<K,V,R> biFunction)
    通过biFunction自定义一个规则，此规则将原Map中的元素转换成新的元素，生成新的Map返回 变更过程通过传入的 BiFunction 实现来返回一个值可以为不同类型的 Map
    static <K, V> HashMap<K,V>
    newHashMap()
    新建一个HashMap
    static <K, V> HashMap<K,V>
    newHashMap(boolean isLinked)
    新建一个HashMap
    static <K, V> HashMap<K,V>
    newHashMap(int size)
    新建一个HashMap
    static <K, V> HashMap<K,V>
    newHashMap(int size, boolean isLinked)
    新建一个HashMap
    static <K, V> Map<K,V>
    newIdentityMap(int size)
    创建键不重复Map
    static <K, V> ConcurrentHashMap<K,V>
    newSafeHashMap()
    新建一个初始容量为DEFAULT_INITIAL_CAPACITY 的SafeHashMap
    static <K, V> ConcurrentHashMap<K,V>
    newSafeHashMap(int size)
    新建一个SafeHashMap
    static <K, V> ConcurrentHashMap<K,V>
    newSafeHashMap(Map<K,V> map)
    传入一个Map将其转化为SafeHashMap类型
    static <K, V> TreeMap<K,V>
    newTreeMap(Comparator<? super K> comparator)
    新建TreeMap，Key有序的Map
    static <K, V> TreeMap<K,V>
    newTreeMap(Map<K,V> map, Comparator<? super K> comparator)
    新建TreeMap，Key有序的Map
    static <K, V> HashMap<K,V>
    of(Iterable<Map.Entry<K,V>> entryIter)
    将Entry集合转换为HashMap
    static HashMap<Object,Object>
    of(Object[] array)
    将数组转换为Map(HashMap),支持数组元素类型为：
    static <K, V> HashMap<K,V>
    of(Iterator<Map.Entry<K,V>> entryIter)
    将Entry集合转换为HashMap
    static <K, V> Map<K,V>
    of(Map.Entry<K,V>... entries)
    根据给定的Pair数组创建Map对象
    static <K, V> HashMap<K,V>
    of(K key, V value)
    将单一键值对转换为Map
    static <K, V> HashMap<K,V>
    of(K key, V value, boolean isOrder)
    将单一键值对转换为Map
    static <T, K, V> Map<K,V>
    putAll(Map<K,V> resultMap, Iterable<T> iterable, Function<T,K> keyMapper, Function<T,V> valueMapper)
    将列表按照给定的键生成器规则和值生成器规则，加入到给定的Map中
    static <K, V> Map<K,V>
    putAll(Map<K,V> resultMap, Iterable<V> iterable, Function<V,K> keyMapper)
    将列表按照给定的键生成器规则和值生成器规则，加入到给定的Map中
    static <T, K, V> Map<K,V>
    putAll(Map<K,V> resultMap, Iterator<T> iterator, Function<T,K> keyMapper, Function<T,V> valueMapper)
    将列表按照给定的键生成器规则和值生成器规则，加入到给定的Map中
    static <K, V> Map<K,V>
    putAll(Map<K,V> resultMap, Iterator<V> iterator, Function<V,K> keyMapper)
    将列表按照给定的键生成器规则和值生成器规则，加入到给定的Map中
    static <K, V> Map<K,V>
    removeAny(Map<K,V> map, K... keys)
    去掉Map中指定key的键值对，修改原Map
    static <K, V> Map<K,V>
    removeNullValue(Map<K,V> map)
    去除Map中值为null的键值对 注意：此方法在传入的Map上直接修改。
    static <K, V> Map<K,V>
    renameKey(Map<K,V> map, K oldKey, K newKey)
    重命名键 实现方式为一处然后重新put,当旧的key不存在直接返回 当新的key存在,抛出IllegalArgumentException 异常
    static <T> Map<T,T>
    reverse(Map<T,T> map)
    Map的键和值互换 互换键值对不检查值是否有重复，如果有则后加入的元素替换先加入的元素 值的顺序在HashMap中不确定，所以谁覆盖谁也不确定，在有序的Map中按照先后顺序覆盖，保留最后的值
    static <K, V> TreeMap<K,V>
    sort(Map<K,V> map)
    排序已有Map，Key有序的Map，使用默认Key排序方式（字母顺序）
    static <K, V extends Comparable<? super V>>
    Map<K,V>
    sort(Map<K,V> map, boolean isDesc)
    按照值排序，可选是否倒序
    static <K, V> TreeMap<K,V>
    sort(Map<K,V> map, Comparator<? super K> comparator)
    排序已有Map，Key有序的Map
    static String
    sortJoin(Map<?,?> params, String separator, String keyValueSeparator, boolean isIgnoreNull, String... otherParams)
    根据参数排序后拼接为字符串，常用于签名
    static <K, V> Map<K,V>
    toCamelCaseMap(Map<K,V> map)
    将已知Map转换为key为驼峰风格的Map 如果KEY为非String类型,保留原值
    static <K, V> Map<K,List<V>>
    toListMap(Iterable<? extends Map<K,V>> mapList)
    行转列,合并相同的键,值合并为列表 将Map列表中相同key的值组成列表做为Map的value 是toMapList(Map)的逆方法 比如传入数据：
    static <K, V> List<Map<K,V>>
    toMapList(Map<K,? extends Iterable<V>> listMap)
    列转行 将Map中值列表分别按照其位置与key组成新的map 是toListMap(Iterable)的逆方法 比如传入数据：
    static Object[][]
    toObjectArray(Map<?,?> map)
    将键值对转换为二维数组,第一维是key,第二纬是value
    static <K, V> ArrayList<V>
    valuesOfKeys(Map<K,V> map, Iterable<K> keys)
    从Map中获取指定键列表对应的值列表 如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
    static <K, V> ArrayList<V>
    valuesOfKeys(Map<K,V> map, Iterator<K> keys)
    从Map中获取指定键列表对应的值列表 如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
    static <K, V> ArrayList<V>
    valuesOfKeys(Map<K,V> map, K... keys)
    从Map中获取指定键列表对应的值列表 如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
    static <K, V> Map<K,V>
    view(Map<K,V> map)
    将对应Map转换为不可修改的Map
    static <K, V> MapWrapper<K,V>
    wrap(Map<K,V> map)
    创建Map包装类MapWrapper MapWrapper对Map做一次包装
    static <K, V> Map<K,V>
    zero()
    返回一个初始大小为0的HashMap(初始为0，可加入元素)

    Methods inherited from class java.lang.Object

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

  • Field Details

    • DEFAULT_INITIAL_CAPACITY

      public static final int DEFAULT_INITIAL_CAPACITY
      默认初始大小
      See Also:

    • DEFAULT_LOAD_FACTOR

      public static final float DEFAULT_LOAD_FACTOR
      默认增长因子,当Map的size达到 容量*增长因子时,开始扩充Map
      See Also:

  • 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:
      是否为非空

    • 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)
      新建一个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(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(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

    • newSafeHashMap

      public static <K, V> ConcurrentHashMap<K,V> newSafeHashMap()
      新建一个初始容量为DEFAULT_INITIAL_CAPACITY 的SafeHashMap
      Type Parameters:
      K - key的类型
      V - value的类型
      Returns:
      SafeHashMap

    • newIdentityMap

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

    • newSafeHashMap

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

    • newSafeHashMap

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

    • 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实例

    • 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

    • of

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

    • of

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

    • of

      public static <K, V> HashMap<K,V> of(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实现来返回需要的元素内容,这个Editor实现可以实现以下功能： 
       1、过滤出需要的对象,如果返回null表示这个元素对象抛弃
 2、修改元素对象,返回集合中为修改后的对象
      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 - key的类型
      V - value的类型
      R - 新的，修改后的value的类型
      Parameters:
      map - 原有的map
      biFunction - lambda，参数包含key,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 - 键列表
      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

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

    • 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:

    • 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 - key
      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> Map<K,V> removeAny(Map<K,V> map, K... keys)
      去掉Map中指定key的键值对，修改原Map
      Type Parameters:
      K - Key类型
      V - Value类型
      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

    • 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

    • 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

    • getString

      public static String getString(Map<?,?> map, Object key)
      获取Map指定key的值，并转换为字符串
      Parameters:
      map - Map
      key - 键
      Returns:
      值

    • getString

      public static String getString(Map<?,?> map, Object key, String defaultValue)
      获取Map指定key的值，并转换为字符串
      Parameters:
      map - Map
      key - 键
      defaultValue - 默认值
      Returns:
      值

    • getInt

      public static Integer getInt(Map<?,?> map, Object key)
      获取Map指定key的值，并转换为Integer
      Parameters:
      map - Map
      key - 键
      Returns:
      值

    • getInt

      public static Integer getInt(Map<?,?> map, Object key, Integer defaultValue)
      获取Map指定key的值，并转换为Integer
      Parameters:
      map - Map
      key - 键
      defaultValue - 默认值
      Returns:
      值

    • getDouble

      public static Double getDouble(Map<?,?> map, Object key)
      获取Map指定key的值，并转换为Double
      Parameters:
      map - Map
      key - 键
      Returns:
      值

    • getDouble

      public static Double getDouble(Map<?,?> map, Object key, Double defaultValue)
      获取Map指定key的值，并转换为Double
      Parameters:
      map - Map
      key - 键
      defaultValue - 默认值
      Returns:
      值

    • getFloat

      public static Float getFloat(Map<?,?> map, Object key)
      获取Map指定key的值，并转换为Float
      Parameters:
      map - Map
      key - 键
      Returns:
      值

    • getFloat

      public static Float getFloat(Map<?,?> map, Object key, Float defaultValue)
      获取Map指定key的值，并转换为Float
      Parameters:
      map - Map
      key - 键
      defaultValue - 默认值
      Returns:
      值

    • getShort

      public static Short getShort(Map<?,?> map, Object key)
      获取Map指定key的值，并转换为Short
      Parameters:
      map - Map
      key - 键
      Returns:
      值

    • getShort

      public static Short getShort(Map<?,?> map, Object key, Short defaultValue)
      获取Map指定key的值，并转换为Short
      Parameters:
      map - Map
      key - 键
      defaultValue - 默认值
      Returns:
      值

    • getBool

      public static Boolean getBool(Map<?,?> map, Object key)
      获取Map指定key的值，并转换为Bool
      Parameters:
      map - Map
      key - 键
      Returns:
      值

    • getBool

      public static Boolean getBool(Map<?,?> map, Object key, Boolean defaultValue)
      获取Map指定key的值，并转换为Bool
      Parameters:
      map - Map
      key - 键
      defaultValue - 默认值
      Returns:
      值

    • getChar

      public static Character getChar(Map<?,?> map, Object key)
      获取Map指定key的值，并转换为Character
      Parameters:
      map - Map
      key - 键
      Returns:
      值

    • getChar

      public static Character getChar(Map<?,?> map, Object key, Character defaultValue)
      获取Map指定key的值，并转换为Character
      Parameters:
      map - Map
      key - 键
      defaultValue - 默认值
      Returns:
      值

    • getLong

      public static Long getLong(Map<?,?> map, Object key)
      获取Map指定key的值，并转换为Long
      Parameters:
      map - Map
      key - 键
      Returns:
      值

    • getLong

      public static Long getLong(Map<?,?> map, Object key, Long defaultValue)
      获取Map指定key的值，并转换为Long
      Parameters:
      map - Map
      key - 键
      defaultValue - 默认值
      Returns:
      值

    • getDate

      public static Date getDate(Map<?,?> map, Object key)
      获取Map指定key的值，并转换为Date
      Parameters:
      map - Map
      key - 键
      Returns:
      值

    • getDate

      public static Date getDate(Map<?,?> map, Object key, Date defaultValue)
      获取Map指定key的值，并转换为Date
      Parameters:
      map - Map
      key - 键
      defaultValue - 默认值
      Returns:
      值

    • get

      public static <T> T get(Map<?,?> map, Object key, Class<T> type)
      获取Map指定key的值，并转换为指定类型
      Type Parameters:
      T - 目标值类型
      Parameters:
      map - Map
      key - 键
      type - 值类型
      Returns:
      值

    • get

      public static <T> T get(Map<?,?> map, Object key, Class<T> type, T defaultValue)
      获取Map指定key的值，并转换为指定类型
      Type Parameters:
      T - 目标值类型
      Parameters:
      map - Map
      key - 键
      type - 值类型
      defaultValue - 默认值
      Returns:
      值

    • getQuietly

      public static <T> T getQuietly(Map<?,?> map, Object key, Class<T> type, T defaultValue)
      获取Map指定key的值，并转换为指定类型，此方法在转换失败后不抛异常，返回null。
      Type Parameters:
      T - 目标值类型
      Parameters:
      map - Map
      key - 键
      type - 值类型
      defaultValue - 默认值
      Returns:
      值

    • get

      public static <T> T get(Map<?,?> map, Object key, Types<T> type)
      获取Map指定key的值，并转换为指定类型
      Type Parameters:
      T - 目标值类型
      Parameters:
      map - Map
      key - 键
      type - 值类型
      Returns:
      值

    • get

      public static <T> T get(Map<?,?> map, Object key, Types<T> type, T defaultValue)
      获取Map指定key的值，并转换为指定类型
      Type Parameters:
      T - 目标值类型
      Parameters:
      map - Map
      key - 键
      type - 值类型
      defaultValue - 默认值
      Returns:
      值

    • getQuietly

      public static <T> T getQuietly(Map<?,?> map, Object key, Types<T> type, T defaultValue)
      获取Map指定key的值，并转换为指定类型，转换失败后返回null，不抛异常
      Type Parameters:
      T - 目标值类型
      Parameters:
      map - Map
      key - 键
      type - 值类型
      defaultValue - 默认值
      Returns:
      值

    • 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:
      this map

    • computeIfAbsent

      public static <K, V> V computeIfAbsent(Map<K,V> map, K key, Function<? super K,? extends V> mappingFunction)
      如果 key 对应的 value 不存在，则使用获取 mappingFunction 重新计算后的值，并保存为该 key 的 value，否则返回 value。 方法来自Dubbo，解决使用ConcurrentHashMap.computeIfAbsent导致的死循环问题。（issues#2349） A temporary workaround for Java 8 specific performance issue JDK-8161372 . This class should be removed once we drop Java 8 support.
      Type Parameters:
      K - 键类型
      V - 值类型
      Parameters:
      map - Map，一般用于线程安全的Map
      key - 键
      mappingFunction - 值计算函数
      Returns:
      值
      See Also: