MapUtil (hutool-core 5.4.4 API)

java.lang.Object
- cn.hutool.core.map.MapUtil

```
public class MapUtil
extends Object
```
Map相关工具类

从以下版本开始:

3.1.1

作者:

Looly

字段概要

字段
限定符和类型	字段和说明
`static int`	`DEFAULT_INITIAL_CAPACITY` 默认初始大小
`static float`	`DEFAULT_LOAD_FACTOR` 默认增长因子，当Map的size达到容量*增长因子时，开始扩充Map

构造器概要

构造器
构造器和说明

MapUtil()

构造器
构造器和说明
`MapUtil()`

方法概要

所有方法静态方法具体方法
限定符和类型	方法和说明
`static <K,V> MapBuilder<K,V>`	`builder()` 创建链接调用map
`static <K,V> MapBuilder<K,V>`	`builder(K k, V v)` 创建链接调用map
`static <K,V> MapBuilder<K,V>`	`builder(Map<K,V> map)` 创建链接调用map
`static void`	`clear(Map<?,?>... maps)` 清除一个或多个Map集合内的元素，每个Map调用clear()方法
`static <K,V> Map<K,V>`	`createMap(Class<?> mapType)` 创建Map 传入抽象Map`AbstractMap`和`Map`类将默认创建`HashMap`
`static MapProxy`	`createProxy(Map<?,?> map)` 创建代理Map `MapProxy`对Map做一次包装，提供各种getXXX方法
`static <T extends Map<K,V>,K,V> T`	`defaultIfEmpty(T map, T defaultMap)` 如果给定Map为空，返回默认Map
`static <K,V> Map<K,V>`	`empty()` 返回一个空Map
`static <K,V,T extends Map<K,V>> T`	`empty(Class<?> mapClass)` 根据传入的Map类型不同，返回对应类型的空Map，支持类型包括： 1.
`static <K,V> Map<K,V>`	`emptyIfNull(Map<K,V> set)` 如果提供的集合为`null`，返回一个不可变的默认空集合，否则返回原集合空集合使用`Collections.emptyMap()`
`static <K,V> Map<K,V>`	`filter(Map<K,V> map, Editor<Map.Entry<K,V>> editor)` 过滤过滤过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能： 1、过滤出需要的对象，如果返回null表示这个元素对象抛弃 2、修改元素对象，返回集合中为修改后的对象
`static <K,V> Map<K,V>`	`filter(Map<K,V> map, Filter<Map.Entry<K,V>> filter)` 过滤过滤过程通过传入的Editor实现来返回需要的元素内容，这个Filter实现可以实现以下功能： 1、过滤出需要的对象，如果返回null表示这个元素对象抛弃
`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, TypeReference<T> type)` 获取Map指定key的值，并转换为指定类型
`static <T> T`	`get(Map<?,?> map, Object key, TypeReference<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 Short`	`getShort(Map<?,?> map, Object key)` 获取Map指定key的值，并转换为Short
`static Short`	`getShort(Map<?,?> map, Object key, Short defaultValue)` 获取Map指定key的值，并转换为Short
`static String`	`getStr(Map<?,?> map, Object key)` 获取Map指定key的值，并转换为字符串
`static String`	`getStr(Map<?,?> map, Object key, String defaultValue)` 获取Map指定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`	`joinIgnoreNull(Map<K,V> map, String separator, String keyValueSeparator, String... otherParams)` 将map转成字符串，忽略null的键和值
`static <K,V> ConcurrentHashMap<K,V>`	`newConcurrentHashMap()` 新建一个初始容量为`DEFAULT_INITIAL_CAPACITY` 的ConcurrentHashMap
`static <K,V> ConcurrentHashMap<K,V>`	`newConcurrentHashMap(int size)` 新建一个ConcurrentHashMap
`static <K,V> ConcurrentHashMap<K,V>`	`newConcurrentHashMap(Map<K,V> map)` 传入一个Map将其转化为ConcurrentHashMap类型
`static <K,V> HashMap<K,V>`	`newHashMap()` 新建一个HashMap
`static <K,V> HashMap<K,V>`	`newHashMap(boolean isOrder)` 新建一个HashMap
`static <K,V> HashMap<K,V>`	`newHashMap(int size)` 新建一个HashMap
`static <K,V> HashMap<K,V>`	`newHashMap(int size, boolean isOrder)` 新建一个HashMap
`static <K,V> Map<K,V>`	`newIdentityMap(int size)` 创建键不重复Map
`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(K key, V value)` 将单一键值对转换为Map
`static <K,V> HashMap<K,V>`	`of(K key, V value, boolean isOrder)` 将单一键值对转换为Map
`static HashMap<Object,Object>`	`of(Object[] array)` 将数组转换为Map（HashMap），支持数组元素类型为： Map.Entry 长度大于1的数组（取前两个值），如果不满足跳过此元素 Iterable 长度也必须大于1（取前两个值），如果不满足跳过此元素 Iterator 长度也必须大于1（取前两个值），如果不满足跳过此元素 Map<Object, Object> colorMap = MapUtil.of(new String[][] { { "RED", "#FF0000" }, { "GREEN", "#00FF00" }, { "BLUE", "#0000FF" } }); 参考：commons-lang
`static <K,V> Map<K,V>`	`of(Pair<K,V>... pairs)` 根据给定的Pair数组创建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> 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)`的逆方法比如传入数据： [ {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] }
`static <K,V> List<Map<K,V>>`	`toMapList(Map<K,? extends Iterable<V>> listMap)` 列转行。
`static Object[][]`	`toObjectArray(Map<?,?> map)` 将键值对转换为二维数组，第一维是key，第二纬是value
`static <K,V> Map<K,V>`	`unmodifiable(Map<K,V> map)` 将对应Map转换为不可修改的Map
`static <K,V> MapWrapper<K,V>`	`wrap(Map<K,V> map)` 创建Map包装类MapWrapper `MapWrapper`对Map做一次包装

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 字段详细资料
  - DEFAULT_INITIAL_CAPACITY
```
public static final int DEFAULT_INITIAL_CAPACITY
```
    默认初始大小
    
    另请参阅:
    
    常量字段值
  - DEFAULT_LOAD_FACTOR
```
public static final float DEFAULT_LOAD_FACTOR
```
    默认增长因子，当Map的size达到容量*增长因子时，开始扩充Map
    
    另请参阅:
    
    常量字段值
- 构造器详细资料
  - MapUtil
```
public MapUtil()
```
- 方法详细资料
  - isEmpty
```
public static boolean isEmpty(Map<?,?> map)
```
    Map是否为空
    
    参数:
    
    map - 集合
    
    返回:
    
    是否为空
  - isNotEmpty
```
public static boolean isNotEmpty(Map<?,?> map)
```
    Map是否为非空
    
    参数:
    
    map - 集合
    
    返回:
    
    是否为非空
  - emptyIfNull
```
public static <K,V> Map<K,V> emptyIfNull(Map<K,V> set)
```
    如果提供的集合为null，返回一个不可变的默认空集合，否则返回原集合
    空集合使用Collections.emptyMap()
    
    类型参数:
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    set - 提供的集合，可能为null
    
    返回:
    
    原集合，若为null返回空集合
    
    从以下版本开始:
    
    4.6.3
  - defaultIfEmpty
```
public static <T extends Map<K,V>,K,V> T defaultIfEmpty(T map,
                                                        T defaultMap)
```
    如果给定Map为空，返回默认Map
    
    类型参数:
    
    T - 集合类型
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    map - Map
    
    defaultMap - 默认Map
    
    返回:
    
    非空（empty）的原Map或默认Map
    
    从以下版本开始:
    
    4.6.9
  - newHashMap
```
public static <K,V> HashMap<K,V> newHashMap()
```
    新建一个HashMap
    
    类型参数:
    
    K - Key类型
    
    V - Value类型
    
    返回:
    
    HashMap对象
  - newHashMap
```
public static <K,V> HashMap<K,V> newHashMap(int size,
                                            boolean isOrder)
```
    新建一个HashMap
    
    类型参数:
    
    K - Key类型
    
    V - Value类型
    
    参数:
    
    size - 初始大小，由于默认负载因子0.75，传入的size会实际初始大小为size / 0.75 + 1
    
    isOrder - Map的Key是否有序，有序返回 LinkedHashMap，否则返回 HashMap
    
    返回:
    
    HashMap对象
    
    从以下版本开始:
    
    3.0.4
  - newHashMap
```
public static <K,V> HashMap<K,V> newHashMap(int size)
```
    新建一个HashMap
    
    类型参数:
    
    K - Key类型
    
    V - Value类型
    
    参数:
    
    size - 初始大小，由于默认负载因子0.75，传入的size会实际初始大小为size / 0.75 + 1
    
    返回:
    
    HashMap对象
  - newHashMap
```
public static <K,V> HashMap<K,V> newHashMap(boolean isOrder)
```
    新建一个HashMap
    
    类型参数:
    
    K - Key类型
    
    V - Value类型
    
    参数:
    
    isOrder - Map的Key是否有序，有序返回 LinkedHashMap，否则返回 HashMap
    
    返回:
    
    HashMap对象
  - newTreeMap
```
public static <K,V> TreeMap<K,V> newTreeMap(Comparator<? super K> comparator)
```
    新建TreeMap，Key有序的Map
    
    类型参数:
    
    K - key的类型
    
    V - value的类型
    
    参数:
    
    comparator - Key比较器
    
    返回:
    
    TreeMap
    
    从以下版本开始:
    
    3.2.3
  - newTreeMap
```
public static <K,V> TreeMap<K,V> newTreeMap(Map<K,V> map,
                                            Comparator<? super K> comparator)
```
    新建TreeMap，Key有序的Map
    
    类型参数:
    
    K - key的类型
    
    V - value的类型
    
    参数:
    
    map - Map
    
    comparator - Key比较器
    
    返回:
    
    TreeMap
    
    从以下版本开始:
    
    3.2.3
  - newIdentityMap
```
public static <K,V> Map<K,V> newIdentityMap(int size)
```
    创建键不重复Map
    
    类型参数:
    
    K - key的类型
    
    V - value的类型
    
    参数:
    
    size - 初始容量
    
    返回:
    
    IdentityHashMap
    
    从以下版本开始:
    
    4.5.7
  - newConcurrentHashMap
```
public static <K,V> ConcurrentHashMap<K,V> newConcurrentHashMap()
```
    新建一个初始容量为DEFAULT_INITIAL_CAPACITY 的ConcurrentHashMap
    
    类型参数:
    
    K - key的类型
    
    V - value的类型
    
    返回:
    
    ConcurrentHashMap
  - newConcurrentHashMap
```
public static <K,V> ConcurrentHashMap<K,V> newConcurrentHashMap(int size)
```
    新建一个ConcurrentHashMap
    
    类型参数:
    
    K - key的类型
    
    V - value的类型
    
    参数:
    
    size - 初始容量，当传入的容量小于等于0时，容量为DEFAULT_INITIAL_CAPACITY
    
    返回:
    
    ConcurrentHashMap
  - newConcurrentHashMap
```
public static <K,V> ConcurrentHashMap<K,V> newConcurrentHashMap(Map<K,V> map)
```
    传入一个Map将其转化为ConcurrentHashMap类型
    
    类型参数:
    
    K - key的类型
    
    V - value的类型
    
    参数:
    
    map - map
    
    返回:
    
    ConcurrentHashMap
  - createMap
```
public static <K,V> Map<K,V> createMap(Class<?> mapType)
```
    创建Map
    传入抽象MapAbstractMap和Map类将默认创建HashMap
    
    类型参数:
    
    K - map键类型
    
    V - map值类型
    
    参数:
    
    mapType - map类型
    
    返回:
    
    Map实例
  - of
```
public static <K,V> HashMap<K,V> of(K key,
                                    V value)
```
    将单一键值对转换为Map
    
    类型参数:
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    key - 键
    
    value - 值
    
    返回:
    
    HashMap
  - of
```
public static <K,V> HashMap<K,V> of(K key,
                                    V value,
                                    boolean isOrder)
```
    将单一键值对转换为Map
    
    类型参数:
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    key - 键
    
    value - 值
    
    isOrder - 是否有序
    
    返回:
    
    HashMap
  - of
```
@SafeVarargs
public static <K,V> Map<K,V> of(Pair<K,V>... pairs)
```
    根据给定的Pair数组创建Map对象
    
    类型参数:
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    pairs - 键值对
    
    返回:
    
    Map
    
    从以下版本开始:
    
    5.4.1
  - of
```
public static HashMap<Object,Object> of(Object[] array)
```
    将数组转换为Map（HashMap），支持数组元素类型为：
```
 Map.Entry
 长度大于1的数组（取前两个值），如果不满足跳过此元素
 Iterable 长度也必须大于1（取前两个值），如果不满足跳过此元素
 Iterator 长度也必须大于1（取前两个值），如果不满足跳过此元素
 
```
```
 Map<Object, Object> colorMap = MapUtil.of(new String[][] {
    { "RED", "#FF0000" },
    { "GREEN", "#00FF00" },
    { "BLUE", "#0000FF" }
 });
 
```
    参考：commons-lang
    参数:
    
    array - 数组。元素类型为Map.Entry、数组、Iterable、Iterator
    
    返回:
    
    HashMap
    
    从以下版本开始:
    
    3.0.8
  - 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]
 }
 
```
    类型参数:
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    mapList - Map列表
    
    返回:
    
    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}
 ]
 
```
    类型参数:
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    listMap - 列表Map
    
    返回:
    
    Map列表
  - toCamelCaseMap
```
public static <K,V> Map<K,V> toCamelCaseMap(Map<K,V> map)
```
    将已知Map转换为key为驼峰风格的Map
    如果KEY为非String类型，保留原值
    
    类型参数:
    
    K - key的类型
    
    V - value的类型
    
    参数:
    
    map - 原Map
    
    返回:
    
    驼峰风格Map
    
    从以下版本开始:
    
    3.3.1
  - toObjectArray
```
public static Object[][] toObjectArray(Map<?,?> map)
```
    将键值对转换为二维数组，第一维是key，第二纬是value
    
    参数:
    
    map - map
    
    返回:
    
    数组
    
    从以下版本开始:
    
    4.1.9
  - join
```
public static <K,V> String join(Map<K,V> map,
                                String separator,
                                String keyValueSeparator,
                                String... otherParams)
```
    将map转成字符串
    
    类型参数:
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    map - Map
    
    separator - entry之间的连接符
    
    keyValueSeparator - kv之间的连接符
    
    otherParams - 其它附加参数字符串（例如密钥）
    
    返回:
    
    连接字符串
    
    从以下版本开始:
    
    3.1.1
  - sortJoin
```
public static String sortJoin(Map<?,?> params,
                              String separator,
                              String keyValueSeparator,
                              boolean isIgnoreNull,
                              String... otherParams)
```
    根据参数排序后拼接为字符串，常用于签名
    
    参数:
    
    params - 参数
    
    separator - entry之间的连接符
    
    keyValueSeparator - kv之间的连接符
    
    isIgnoreNull - 是否忽略null的键和值
    
    otherParams - 其它附加参数字符串（例如密钥）
    
    返回:
    
    签名字符串
    
    从以下版本开始:
    
    5.0.4
  - joinIgnoreNull
```
public static <K,V> String joinIgnoreNull(Map<K,V> map,
                                          String separator,
                                          String keyValueSeparator,
                                          String... otherParams)
```
    将map转成字符串，忽略null的键和值
    
    类型参数:
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    map - Map
    
    separator - entry之间的连接符
    
    keyValueSeparator - kv之间的连接符
    
    otherParams - 其它附加参数字符串（例如密钥）
    
    返回:
    
    连接后的字符串
    
    从以下版本开始:
    
    3.1.1
  - join
```
public static <K,V> String join(Map<K,V> map,
                                String separator,
                                String keyValueSeparator,
                                boolean isIgnoreNull,
                                String... otherParams)
```
    将map转成字符串
    
    类型参数:
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    map - Map，为空返回otherParams拼接
    
    separator - entry之间的连接符
    
    keyValueSeparator - kv之间的连接符
    
    isIgnoreNull - 是否忽略null的键和值
    
    otherParams - 其它附加参数字符串（例如密钥）
    
    返回:
    
    连接后的字符串，map和otherParams为空返回""
    
    从以下版本开始:
    
    3.1.1
  - filter
```
public static <K,V> Map<K,V> filter(Map<K,V> map,
                                    Editor<Map.Entry<K,V>> editor)
```
    过滤
    过滤过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能：
```
 1、过滤出需要的对象，如果返回null表示这个元素对象抛弃
 2、修改元素对象，返回集合中为修改后的对象
 
```
    类型参数:
    
    K - Key类型
    
    V - Value类型
    
    参数:
    
    map - Map
    
    editor - 编辑器接口
    
    返回:
    
    过滤后的Map
  - filter
```
public static <K,V> Map<K,V> filter(Map<K,V> map,
                                    Filter<Map.Entry<K,V>> filter)
```
    过滤
    过滤过程通过传入的Editor实现来返回需要的元素内容，这个Filter实现可以实现以下功能：
```
 1、过滤出需要的对象，如果返回null表示这个元素对象抛弃
 
```
    类型参数:
    
    K - Key类型
    
    V - Value类型
    
    参数:
    
    map - Map
    
    filter - 编辑器接口
    
    返回:
    
    过滤后的Map
    
    从以下版本开始:
    
    3.1.0
  - filter
```
public static <K,V> Map<K,V> filter(Map<K,V> map,
                                    K... keys)
```
    过滤Map保留指定键值对，如果键不存在跳过
    
    类型参数:
    
    K - Key类型
    
    V - Value类型
    
    参数:
    
    map - 原始Map
    
    keys - 键列表
    
    返回:
    
    Map 结果，结果的Map类型与原Map保持一致
    
    从以下版本开始:
    
    4.0.10
  - reverse
```
public static <T> Map<T,T> reverse(Map<T,T> map)
```
    Map的键和值互换互换键值对不检查值是否有重复，如果有则后加入的元素替换先加入的元素
    值的顺序在HashMap中不确定，所以谁覆盖谁也不确定，在有序的Map中按照先后顺序覆盖，保留最后的值
    
    类型参数:
    
    T - 键和值类型
    
    参数:
    
    map - Map对象，键值类型必须一致
    
    返回:
    
    互换后的Map
    
    从以下版本开始:
    
    3.2.2
    
    另请参阅:
    
    inverse(Map)
  - inverse
```
public static <K,V> Map<V,K> inverse(Map<K,V> map)
```
    Map的键和值互换
    互换键值对不检查值是否有重复，如果有则后加入的元素替换先加入的元素
    值的顺序在HashMap中不确定，所以谁覆盖谁也不确定，在有序的Map中按照先后顺序覆盖，保留最后的值
    
    类型参数:
    
    K - 键和值类型
    
    V - 键和值类型
    
    参数:
    
    map - Map对象，键值类型必须一致
    
    返回:
    
    互换后的Map
    
    从以下版本开始:
    
    5.2.6
  - sort
```
public static <K,V> TreeMap<K,V> sort(Map<K,V> map)
```
    排序已有Map，Key有序的Map，使用默认Key排序方式（字母顺序）
    
    类型参数:
    
    K - key的类型
    
    V - value的类型
    
    参数:
    
    map - Map
    
    返回:
    
    TreeMap
    
    从以下版本开始:
    
    4.0.1
    
    另请参阅:
    
    newTreeMap(Map, Comparator)
  - sort
```
public static <K,V> TreeMap<K,V> sort(Map<K,V> map,
                                      Comparator<? super K> comparator)
```
    排序已有Map，Key有序的Map
    
    类型参数:
    
    K - key的类型
    
    V - value的类型
    
    参数:
    
    map - Map，为null返回null
    
    comparator - Key比较器
    
    返回:
    
    TreeMap，map为null返回null
    
    从以下版本开始:
    
    4.0.1
    
    另请参阅:
    
    newTreeMap(Map, Comparator)
  - createProxy
```
public static MapProxy createProxy(Map<?,?> map)
```
    创建代理Map
    MapProxy对Map做一次包装，提供各种getXXX方法
    
    参数:
    
    map - 被代理的Map
    
    返回:
    
    MapProxy
    
    从以下版本开始:
    
    3.2.0
  - wrap
```
public static <K,V> MapWrapper<K,V> wrap(Map<K,V> map)
```
    创建Map包装类MapWrapper
    MapWrapper对Map做一次包装
    
    类型参数:
    
    K - key的类型
    
    V - value的类型
    
    参数:
    
    map - 被代理的Map
    
    返回:
    
    MapWrapper
    
    从以下版本开始:
    
    4.5.4
  - unmodifiable
```
public static <K,V> Map<K,V> unmodifiable(Map<K,V> map)
```
    将对应Map转换为不可修改的Map
    
    类型参数:
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    map - Map
    
    返回:
    
    不修改Map
    
    从以下版本开始:
    
    5.2.6
  - builder
```
public static <K,V> MapBuilder<K,V> builder()
```
    创建链接调用map
    
    类型参数:
    
    K - Key类型
    
    V - Value类型
    
    返回:
    
    map创建类
  - builder
```
public static <K,V> MapBuilder<K,V> builder(Map<K,V> map)
```
    创建链接调用map
    
    类型参数:
    
    K - Key类型
    
    V - Value类型
    
    参数:
    
    map - 实际使用的map
    
    返回:
    
    map创建类
  - builder
```
public static <K,V> MapBuilder<K,V> builder(K k,
                                            V v)
```
    创建链接调用map
    
    类型参数:
    
    K - Key类型
    
    V - Value类型
    
    参数:
    
    k - key
    
    v - value
    
    返回:
    
    map创建类
  - getAny
```
public static <K,V> Map<K,V> getAny(Map<K,V> map,
                                    K... keys)
```
    获取Map的部分key生成新的Map
    
    类型参数:
    
    K - Key类型
    
    V - Value类型
    
    参数:
    
    map - Map
    
    keys - 键列表
    
    返回:
    
    新Map，只包含指定的key
    
    从以下版本开始:
    
    4.0.6
  - removeAny
```
public static <K,V> Map<K,V> removeAny(Map<K,V> map,
                                       K... keys)
```
    去掉Map中指定key的键值对，修改原Map
    
    类型参数:
    
    K - Key类型
    
    V - Value类型
    
    参数:
    
    map - Map
    
    keys - 键列表
    
    返回:
    
    修改后的key
    
    从以下版本开始:
    
    5.0.5
  - getStr
```
public static String getStr(Map<?,?> map,
                            Object key)
```
    获取Map指定key的值，并转换为字符串
    
    参数:
    
    map - Map
    
    key - 键
    
    返回:
    
    值
    
    从以下版本开始:
    
    4.0.6
  - getStr
```
public static String getStr(Map<?,?> map,
                            Object key,
                            String defaultValue)
```
    获取Map指定key的值，并转换为字符串
    
    参数:
    
    map - Map
    
    key - 键
    
    defaultValue - 默认值
    
    返回:
    
    值
    
    从以下版本开始:
    
    5.3.11
  - getInt
```
public static Integer getInt(Map<?,?> map,
                             Object key)
```
    获取Map指定key的值，并转换为Integer
    
    参数:
    
    map - Map
    
    key - 键
    
    返回:
    
    值
    
    从以下版本开始:
    
    4.0.6
  - getInt
```
public static Integer getInt(Map<?,?> map,
                             Object key,
                             Integer defaultValue)
```
    获取Map指定key的值，并转换为Integer
    
    参数:
    
    map - Map
    
    key - 键
    
    defaultValue - 默认值
    
    返回:
    
    值
    
    从以下版本开始:
    
    5.3.11
  - getDouble
```
public static Double getDouble(Map<?,?> map,
                               Object key)
```
    获取Map指定key的值，并转换为Double
    
    参数:
    
    map - Map
    
    key - 键
    
    返回:
    
    值
    
    从以下版本开始:
    
    4.0.6
  - getDouble
```
public static Double getDouble(Map<?,?> map,
                               Object key,
                               Double defaultValue)
```
    获取Map指定key的值，并转换为Double
    
    参数:
    
    map - Map
    
    key - 键
    
    defaultValue - 默认值
    
    返回:
    
    值
    
    从以下版本开始:
    
    5.3.11
  - getFloat
```
public static Float getFloat(Map<?,?> map,
                             Object key)
```
    获取Map指定key的值，并转换为Float
    
    参数:
    
    map - Map
    
    key - 键
    
    返回:
    
    值
    
    从以下版本开始:
    
    4.0.6
  - getFloat
```
public static Float getFloat(Map<?,?> map,
                             Object key,
                             Float defaultValue)
```
    获取Map指定key的值，并转换为Float
    
    参数:
    
    map - Map
    
    key - 键
    
    defaultValue - 默认值
    
    返回:
    
    值
    
    从以下版本开始:
    
    5.3.11
  - getShort
```
public static Short getShort(Map<?,?> map,
                             Object key)
```
    获取Map指定key的值，并转换为Short
    
    参数:
    
    map - Map
    
    key - 键
    
    返回:
    
    值
    
    从以下版本开始:
    
    4.0.6
  - getShort
```
public static Short getShort(Map<?,?> map,
                             Object key,
                             Short defaultValue)
```
    获取Map指定key的值，并转换为Short
    
    参数:
    
    map - Map
    
    key - 键
    
    defaultValue - 默认值
    
    返回:
    
    值
    
    从以下版本开始:
    
    5.3.11
  - getBool
```
public static Boolean getBool(Map<?,?> map,
                              Object key)
```
    获取Map指定key的值，并转换为Bool
    
    参数:
    
    map - Map
    
    key - 键
    
    返回:
    
    值
    
    从以下版本开始:
    
    4.0.6
  - getBool
```
public static Boolean getBool(Map<?,?> map,
                              Object key,
                              Boolean defaultValue)
```
    获取Map指定key的值，并转换为Bool
    
    参数:
    
    map - Map
    
    key - 键
    
    defaultValue - 默认值
    
    返回:
    
    值
    
    从以下版本开始:
    
    5.3.11
  - getChar
```
public static Character getChar(Map<?,?> map,
                                Object key)
```
    获取Map指定key的值，并转换为Character
    
    参数:
    
    map - Map
    
    key - 键
    
    返回:
    
    值
    
    从以下版本开始:
    
    4.0.6
  - getChar
```
public static Character getChar(Map<?,?> map,
                                Object key,
                                Character defaultValue)
```
    获取Map指定key的值，并转换为Character
    
    参数:
    
    map - Map
    
    key - 键
    
    defaultValue - 默认值
    
    返回:
    
    值
    
    从以下版本开始:
    
    5.3.11
  - getLong
```
public static Long getLong(Map<?,?> map,
                           Object key)
```
    获取Map指定key的值，并转换为Long
    
    参数:
    
    map - Map
    
    key - 键
    
    返回:
    
    值
    
    从以下版本开始:
    
    4.0.6
  - getLong
```
public static Long getLong(Map<?,?> map,
                           Object key,
                           Long defaultValue)
```
    获取Map指定key的值，并转换为Long
    
    参数:
    
    map - Map
    
    key - 键
    
    defaultValue - 默认值
    
    返回:
    
    值
    
    从以下版本开始:
    
    5.3.11
  - getDate
```
public static Date getDate(Map<?,?> map,
                           Object key)
```
    获取Map指定key的值，并转换为Date
    
    参数:
    
    map - Map
    
    key - 键
    
    返回:
    
    值
    
    从以下版本开始:
    
    4.1.2
  - getDate
```
public static Date getDate(Map<?,?> map,
                           Object key,
                           Date defaultValue)
```
    获取Map指定key的值，并转换为Date
    
    参数:
    
    map - Map
    
    key - 键
    
    defaultValue - 默认值
    
    返回:
    
    值
    
    从以下版本开始:
    
    4.1.2
  - get
```
public static <T> T get(Map<?,?> map,
                        Object key,
                        Class<T> type)
```
    获取Map指定key的值，并转换为指定类型
    
    类型参数:
    
    T - 目标值类型
    
    参数:
    
    map - Map
    
    key - 键
    
    type - 值类型
    
    返回:
    
    值
    
    从以下版本开始:
    
    4.0.6
  - get
```
public static <T> T get(Map<?,?> map,
                        Object key,
                        Class<T> type,
                        T defaultValue)
```
    获取Map指定key的值，并转换为指定类型
    
    类型参数:
    
    T - 目标值类型
    
    参数:
    
    map - Map
    
    key - 键
    
    type - 值类型
    
    defaultValue - 默认值
    
    返回:
    
    值
    
    从以下版本开始:
    
    5.3.11
  - get
```
public static <T> T get(Map<?,?> map,
                        Object key,
                        TypeReference<T> type)
```
    获取Map指定key的值，并转换为指定类型
    
    类型参数:
    
    T - 目标值类型
    
    参数:
    
    map - Map
    
    key - 键
    
    type - 值类型
    
    返回:
    
    值
    
    从以下版本开始:
    
    4.5.12
  - get
```
public static <T> T get(Map<?,?> map,
                        Object key,
                        TypeReference<T> type,
                        T defaultValue)
```
    获取Map指定key的值，并转换为指定类型
    
    类型参数:
    
    T - 目标值类型
    
    参数:
    
    map - Map
    
    key - 键
    
    type - 值类型
    
    defaultValue - 默认值
    
    返回:
    
    值
    
    从以下版本开始:
    
    5.3.11
  - renameKey
```
public static <K,V> Map<K,V> renameKey(Map<K,V> map,
                                       K oldKey,
                                       K newKey)
```
    重命名键
    实现方式为一处然后重新put，当旧的key不存在直接返回
    当新的key存在，抛出IllegalArgumentException 异常
    
    类型参数:
    
    K - key的类型
    
    V - value的类型
    
    参数:
    
    map - Map
    
    oldKey - 原键
    
    newKey - 新键
    
    返回:
    
    map
    
    抛出:
    
    IllegalArgumentException - 新key存在抛出此异常
    
    从以下版本开始:
    
    4.5.16
  - removeNullValue
```
public static <K,V> Map<K,V> removeNullValue(Map<K,V> map)
```
    去除Map中值为null的键值对
    注意：此方法在传入的Map上直接修改。
    
    类型参数:
    
    K - key的类型
    
    V - value的类型
    
    参数:
    
    map - Map
    
    返回:
    
    map
    
    从以下版本开始:
    
    4.6.5
  - empty
```
public static <K,V> Map<K,V> empty()
```
    返回一个空Map
    
    类型参数:
    
    K - 键类型
    
    V - 值类型
    
    返回:
    
    空Map
    
    从以下版本开始:
    
    5.3.1
    
    另请参阅:
    
    Collections.emptyMap()
  - empty
```
public static <K,V,T extends Map<K,V>> T empty(Class<?> mapClass)
```
    根据传入的Map类型不同，返回对应类型的空Map，支持类型包括：
```
     1. NavigableMap
     2. SortedMap
     3. Map
 
```
    类型参数:
    
    K - 键类型
    
    V - 值类型
    
    T - Map类型
    
    参数:
    
    mapClass - Map类型，null返回默认的Map
    
    返回:
    
    空Map
    
    从以下版本开始:
    
    5.3.1
  - clear
```
public static void clear(Map<?,?>... maps)
```
    清除一个或多个Map集合内的元素，每个Map调用clear()方法
    
    参数:
    
    maps - 一个或多个Map

类 MapUtil

字段概要

构造器概要

方法概要

从类继承的方法 java.lang.Object

字段详细资料

DEFAULT_INITIAL_CAPACITY

DEFAULT_LOAD_FACTOR

构造器详细资料

MapUtil

方法详细资料

isEmpty

isNotEmpty

emptyIfNull

defaultIfEmpty

newHashMap

newHashMap

newHashMap

newHashMap

newTreeMap

newTreeMap

newIdentityMap

newConcurrentHashMap

newConcurrentHashMap

newConcurrentHashMap

createMap

of

of

of

of

toListMap

toMapList

toCamelCaseMap

toObjectArray

join

sortJoin

joinIgnoreNull

join

filter

filter

filter

reverse

inverse

sort

sort

createProxy

wrap

unmodifiable

builder

builder

builder

getAny

removeAny

getStr

getStr

getInt

getInt

getDouble

getDouble

getFloat

getFloat

getShort

getShort

getBool

getBool

getChar

getChar

getLong

getLong

getDate

getDate

get

get

get

get

renameKey

removeNullValue

empty

empty

clear