com.feilong.core.util

Class MapUtil

java.lang.Object

com.feilong.core.util.MapUtil

public final class MapUtil
extends Object

Map工具类.

hashCode与equals:

hashCode重要么?
对于List集合、数组而言,不重要,他就是一个累赘;
但是对于HashMap、HashSet、 Hashtable 而言,它变得异常重要.

在Java中hashCode的实现总是伴随着equals,他们是紧密配合的,你要是自己设计了其中一个,就要设计另外一个。

整个处理流程是:

1. 判断两个对象的hashcode是否相等,若不等,则认为两个对象不等,完毕,若相等,则比较equals。
2. 若两个对象的equals不等,则可以认为两个对象不等,否则认为他们相等。

关于 Map:

interface/class	说明
Map	An object that maps keys to values. A map cannot contain duplicate keys Takes the place of the Dictionary class
HashMap	Hash table based implementation of the Map interface. permits null values and the null key. makes no guarantees as to the order of the map 扩容: HashMap 初始容量 HashMap.DEFAULT_INITIAL_CAPACITY是16,DEFAULT_LOAD_FACTOR 是0.75 java.util.HashMap#addEntry 是 2 * table.length 2倍
LinkedHashMap	Hash table and linked list implementation of the Map interface, with predictable iteration order. Note that: insertion order is not affected if a key is re-inserted into the map.
TreeMap	A Red-Black tree based NavigableMap implementation sorted according to the natural ordering of its keys, or by a Comparator. 默认情况 key不能为null,如果传入了 NullComparator那么key 可以为null.
Hashtable	This class implements a hashtable, which maps keys to values. synchronized. Any non-null object can be used as a key or as a value.
Properties	The Properties class represents a persistent set of properties. can be saved to a stream or loaded from a stream. Each key and its corresponding value in the property list is a string.
IdentityHashMap	using reference-equality in place of object-equality when comparing keys (and values). 使用==代替equals()对key进行比较的散列表.专为特殊问题而设计的 注意:此类不是 通用 Map 实现！它有意违反 Map 的常规协定,此类设计仅用于其中需要引用相等性语义的罕见情况
WeakHashMap	A hashtable-based Map implementation with weak keys. 它对key实行"弱引用",如果一个key不再被外部所引用,那么该key可以被GC回收
EnumMap	A specialized Map implementation for use with enum type keys. Enum maps are maintained in the natural order of their keys 不允许空的key

Since:

1.0.0

Author:

feilong

See Also:

AbstractMap.SimpleEntry, MapUtils, "com.google.common.collect.Maps"

Method Summary

Methods

Modifier and Type	Method and Description
static <K,O,V> Map<K,V>	extractSubMap(Map<K,O> map, K[] includeKeys, String extractPropertyName) 以参数 map的key为key,以参数 mapvalue的指定extractPropertyName 属性值为值,拼装成新的map返回.
static <K,O,V> Map<K,V>	extractSubMap(Map<K,O> map, String extractPropertyName) 以参数 map的key为key,以参数 map value的指定extractPropertyName属性值为值,拼装成新的map返回.
static <K,V> Map.Entry<K,V>	get(Map<K,V> map, int index) 根据索引来获得map 的entry.
static <K,T> Map<K,T>	getSubMap(Map<K,T> map, Iterable<K> keys) 获得一个map 中,按照指定的keys 整理成新的map.
static <K,T> Map<K,T>	getSubMap(Map<K,T> map, K... keys) 获得一个map 中,按照指定的keys 整理成新的map.
static <K,T> Map<K,T>	getSubMapExcludeKeys(Map<K,T> map, Iterable<K> excludeKeys) 获得 sub map(排除指定的 excludeKeys).
static <K,T> Map<K,T>	getSubMapExcludeKeys(Map<K,T> map, K... excludeKeys) 获得 sub map(排除指定的 excludeKeys).
static <K,V> Map<V,K>	invertMap(Map<K,V> map) 将 map 的key和value互转.
static <K,V> ConcurrentHashMap<K,V>	newConcurrentHashMap() New concurrent hash map.
static <K,V> ConcurrentHashMap<K,V>	newConcurrentHashMap(int expectedSize) 创建 ConcurrentHashMap实例,拥有足够的 "initial capacity" 应该控制expectedSize elements without growth.
static <K,V> ConcurrentHashMap<K,V>	newConcurrentHashMap(Map<K,V> map) New concurrent hash map.
static <K,V> HashMap<K,V>	newHashMap() 创建 HashMap实例.
static <K,V> HashMap<K,V>	newHashMap(int expectedSize) 创建 HashMap实例,拥有足够的 "initial capacity" 应该控制expectedSize elements without growth.
static <K,V> HashMap<K,V>	newHashMap(Map<K,V> map) New hash map.
static <K,V> LinkedHashMap<K,V>	newLinkedHashMap() 创建 LinkedHashMap实例.
static <K,V> LinkedHashMap<K,V>	newLinkedHashMap(int expectedSize) 创建 LinkedHashMap实例,拥有足够的 "initial capacity" 应该控制expectedSize elements without growth.
static <K,V> LinkedHashMap<K,V>	newLinkedHashMap(Map<K,V> map) New linked hash map.
static <K extends Comparable,V> TreeMap<K,V>	newTreeMap() New tree map.
static <K extends Comparable,V> TreeMap<K,V>	newTreeMap(Map<K,V> map) New tree map.
static <K,V> void	putAllIfNotNull(Map<K,V> map, Map<? extends K,? extends V> m) 仅当 null != map && null != m,才会进行 map.putAll(m) 操作
static <K,V> void	putIfValueNotNull(Map<K,V> map, K key, V value) 仅当 null != map 并且 null != value才将key/value put到map中.
static <K,V> void	putIfValueNotNullOrEmpty(Map<K,V> map, K key, V value) 仅当 null != map 并且 isNotNullOrEmpty(value)才将key/value put到map中.
static <K,V> Map<K,List<V>>	putMultiValue(Map<K,List<V>> map, K key, V value) 往 map 中put 指定 key value(多值形式).
static <K> Map<K,BigDecimal>	putSumValue(Map<K,BigDecimal> map, K key, Number value) 将key和value 累加的形式put到 map中,如果map中存在key,那么累加value值;如果不存在那么直接put.
static <K> Map<K,Integer>	putSumValue(Map<K,Integer> map, K key, Integer value) 将key和value 累加的形式put到 map中,如果map中存在key,那么累加value值;如果不存在那么直接put.
static <K,V> Map<K,V>	removeKeys(Map<K,V> map, K... keys) 删除 map 的指定的 keys.
static <K> Map<K,String[]>	toArrayValueMap(Map<K,String> singleValueMap) 将单值的singleValueMap 转成多值的map.
static <K,V> Map<K,V>	toSingleValueMap(Map<K,V[]> arrayValueMap) 将多值的arrayValueMap 转成单值的map.

Methods inherited from class java.lang.Object

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

Method Detail

get

public static <K,V> Map.Entry<K,V> get(Map<K,V> map,
                       int index)

根据索引来获得map 的entry.

说明:

1. 传入的map 最好是 LinkedHashMap,EnumMap等自身有顺序的map,否则如 HashMap每次结果都不一样

示例:

场景: 获得下面bookSectionUrlMap 第一个entry value值

 
 public void createFile(Novel novel){
     Map<String, String> bookSectionUrlMap = parseBookSectionUrlMap(novel);
 
     if (isNullOrEmpty(bookSectionUrlMap)){
         LOGGER.warn("bookSectionUrlMap is null/empty,Perhaps you read the latest chapter");
         return;
     }
 
     //---------------------------------------------------------------
     String beginName = null; // 开始章节名称 
 
     for (Map.Entry<String, String> entry : bookSectionUrlMap.entrySet()){
         String sectionName = entry.getValue();
         if (isNullOrEmpty(beginName)){
             beginName = sectionName;//①这里纯粹只是为了获得 map 第一个 entry value 值
         }
         try{
 
             //do some big logic
 
         }catch (ChapterParseException e){
             break; //如果出现了异常 就跳出
         }
     }
 
     //---------------------------------------------------------------
     write(novel, beginName);
 
     // do something logic
 }
 
 

对于上述代码 ①处的代码,虽然只是寥寥几行,但是会减低代码的可读性,也不利于循环体代码抽取,通过sonar 扫描的时候,明显方法的复杂度很高

此时,你可以优化成:

 
 public void createFile(Novel novel){
     Map<String, String> bookSectionUrlMap = parseBookSectionUrlMap(novel);
 
     if (isNullOrEmpty(bookSectionUrlMap)){
         LOGGER.warn("bookSectionUrlMap is null/empty,Perhaps you read the latest chapter");
         return;
     }
 
     //---------------------------------------------------------------
 
     for (Map.Entry<String, String> entry : bookSectionUrlMap.entrySet()){
         try{
 
             //do some big logic
 
         }catch (ChapterParseException e){
             break; //如果出现了异常 就跳出
         }
     }
 
     //---------------------------------------------------------------
     write(novel, MapUtil.get(bookSectionUrlMap, 0).getValue());
 
     // do something logic
 }
 
 

Type Parameters:

K - the key type

V - the value type

Parameters:

map - 最好是 LinkedHashMap,EnumMap等自身有顺序的map,否则每次出来的结果都不一样

index - the index

Returns:

如果 map 是null,抛出 NullPointerException

Throws:

IndexOutOfBoundsException - if the index is invalid

Since:

1.10.1

See Also:

IterableUtils.get(Iterable, int), CollectionUtils.get(Map, int)

toSingleValueMap

public static <K,V> Map<K,V> toSingleValueMap(Map<K,V[]> arrayValueMap)

将多值的arrayValueMap 转成单值的map.

示例1:

 Map<String, String[]> arrayValueMap = new LinkedHashMap<>();
 
 arrayValueMap.put("province", new String[] { "江苏省" });
 arrayValueMap.put("city", new String[] { "南通市" });
 LOGGER.info(JsonUtil.format(ParamUtil.toSingleValueMap(arrayValueMap)));
 

返回:

 {
 "province": "江苏省",
 "city": "南通市"
 }
 

如果arrayValueMap其中有key的值是多值的数组,那么转换到新的map中的时候,value取第一个值,

示例2:

 Map<String, String[]> arrayValueMap = new LinkedHashMap<>();
 
 arrayValueMap.put("province", new String[] { "浙江省", "江苏省" });
 arrayValueMap.put("city", new String[] { "南通市" });
 LOGGER.info(JsonUtil.format(ParamUtil.toSingleValueMap(arrayValueMap)));
 

返回:

 {
 "province": "浙江省",
 "city": "南通市"
 }
 

说明:

1. 返回的map是 提取参数 arrayValueMap的key做为key,value数组的第一个元素做value
2. 返回的是 LinkedHashMap,保证顺序和参数 arrayValueMap顺序相同
3. 和该方法正好相反的是 toArrayValueMap(Map)

Type Parameters:

K - the key type

V - the value type

Parameters:

arrayValueMap - the array value map

Returns:

如果arrayValueMap是null或者empty,那么返回 Collections.emptyMap(),
如果arrayValueMap其中有key的值是多值的数组,那么转换到新的map中的时候,value取第一个值,
如果arrayValueMap其中有key的value是null,那么转换到新的map中的时候,value以 null替代

Since:

1.8.0 change type to generics

toArrayValueMap

public static <K> Map<K,String[]> toArrayValueMap(Map<K,String> singleValueMap)

将单值的singleValueMap 转成多值的map.

示例:

 Map<String, String> singleValueMap = new LinkedHashMap<>();
 
 singleValueMap.put("province", "江苏省");
 singleValueMap.put("city", "南通市");
 
 LOGGER.info(JsonUtil.format(ParamUtil.toArrayValueMap(singleValueMap)));
 

返回:

 {
 "province": ["江苏省"],
 "city": ["南通市"]
 }
 

说明:

1. 返回的是 LinkedHashMap,保证顺序和参数 singleValueMap顺序相同
2. 和该方法正好相反的是 toSingleValueMap(Map)

Type Parameters:

K - the key type

Parameters:

singleValueMap - the name and value map

Returns:

如果参数 singleValueMap 是null或者empty,那么返回 Collections.emptyMap()
否则迭代 singleValueMap 将value转成数组,返回新的 arrayValueMap

Since:

1.6.2

putIfValueNotNull

public static <K,V> void putIfValueNotNull(Map<K,V> map,
                           K key,
                           V value)

仅当 null != map 并且 null != value才将key/value put到map中.

说明:

1. 如果 map 是null,什么都不做
2. 如果 value 是null,也什么都不做
3. 如果 key 是null,依照map的key是否允许是null的 规则

Type Parameters:

K - the key type

V - the value type

Parameters:

map - the map to add to

key - the key

value - the value

Since:

1.4.0

See Also:

MapUtils.safeAddToMap(Map, Object, Object)

putAllIfNotNull

public static <K,V> void putAllIfNotNull(Map<K,V> map,
                         Map<? extends K,? extends V> m)

仅当 null != map && null != m,才会进行 map.putAll(m) 操作

重构:

对于以下代码:

 if (isNotNullOrEmpty(specialSignMap)){
     map.putAll(specialSignMap);
 }
 

可以重构成:

 MapUtil.putAllIfNotNull(map, specialSignMap)
 

Type Parameters:

K - the key type

V - the value type

Parameters:

map - the map

m - mappings to be stored in this map

Since:

1.6.3

See Also:

Map.putAll(Map)

putIfValueNotNullOrEmpty

public static <K,V> void putIfValueNotNullOrEmpty(Map<K,V> map,
                                  K key,
                                  V value)

仅当 null != map 并且 isNotNullOrEmpty(value)才将key/value put到map中.

说明:

1. 如果 map 是null,什么都不做
2. 如果 value 是null或者empty,也什么都不做
3. 如果 key 是null,依照map的key是否允许是null的规则

重构:

对于以下代码:

 
 if (isNotNullOrEmpty(taoBaoOAuthLoginForCodeEntity.getState())){
     nameAndValueMap.put("state", taoBaoOAuthLoginForCodeEntity.getState());
 }
 
 

可以重构成:

 MapUtil.putIfValueNotNullOrEmpty(nameAndValueMap, "state", taoBaoOAuthLoginForCodeEntity.getState());
 

Type Parameters:

K - the key type

V - the value type

Parameters:

map - the map

key - the key

value - the value

Since:

1.6.3

putSumValue

public static <K> Map<K,Integer> putSumValue(Map<K,Integer> map,
                             K key,
                             Integer value)

将key和value 累加的形式put到 map中,如果map中存在key,那么累加value值;如果不存在那么直接put.

示例:

 
 Map<String, Integer> map = new HashMap<>();
 MapUtil.putSumValue(map, "1000001", 5);
 MapUtil.putSumValue(map, "1000002", 5);
 MapUtil.putSumValue(map, "1000002", 5);
 LOGGER.debug(JsonUtil.format(map));
 
 

返回:

 {
 "1000001": 5,
 "1000002": 10
 }
 

重构:

对于以下代码:

 
 if (disadvantageMap.containsKey(disadvantageToken)){
     disadvantageMap.put(disadvantageToken, disadvantageMap.get(disadvantageToken) + 1);
 }else{
     disadvantageMap.put(disadvantageToken, 1);
 }
 
 

可以重构成:

 MapUtil.putSumValue(disadvantageMap, disadvantageToken, 1);
 

Type Parameters:

K - the key type

Parameters:

map - the map

key - the key

value - 数值,不能为null,可以是负数

Returns:

如果 map 是null,抛出 NullPointerException
如果 value 是null,抛出 NullPointerException

Since:

1.5.5

See Also:

HashBag, MutableInt, "java.util.Map#getOrDefault(Object, Object)", most-efficient-way-to- increment-a-map-value-in-java

putSumValue

public static <K> Map<K,BigDecimal> putSumValue(Map<K,BigDecimal> map,
                                K key,
                                Number value)

将key和value 累加的形式put到 map中,如果map中存在key,那么累加value值;如果不存在那么直接put.

常用于数据统计, 比如 AggregateUtil.groupSum(Iterable, String, String)

示例:

 
 Map<String, BigDecimal> map = new HashMap<>();
 MapUtil.putSumValue(map, "1000001", 5);
 MapUtil.putSumValue(map, "1000002", 5);
 MapUtil.putSumValue(map, "1000002", 5);
 LOGGER.debug(JsonUtil.format(map));
 
 

返回:

 {
 "1000001": 5,
 "1000002": 10
 }
 

Type Parameters:

K - the key type

Parameters:

map - the map

key - the key

value - 数值,不能为null,可以是负数

Returns:

如果 map 是null,抛出 NullPointerException
如果 value 是null,抛出 NullPointerException

Since:

1.13.2

See Also:

HashBag, "java.util.Map#getOrDefault(Object, Object)", most-efficient-way-to- increment-a-map-value-in-java

putMultiValue

public static <K,V> Map<K,List<V>> putMultiValue(Map<K,List<V>> map,
                                 K key,
                                 V value)

往 map 中put 指定 key value(多值形式).

说明:

1. map已经存在相同名称的key,那么value以list的形式累加.
2. 如果map中不存在指定名称的key,那么会构建一个ArrayList

示例:

 
 Map<String, List<String>> mutiMap = newLinkedHashMap(2);
 MapUtil.putMultiValue(mutiMap, "name", "张飞");
 MapUtil.putMultiValue(mutiMap, "name", "关羽");
 MapUtil.putMultiValue(mutiMap, "age", "30");
 
 LOGGER.debug(JsonUtil.format(mutiMap));
 
 

返回:

    {
            "name":         [
                "张飞",
                "关羽"
            ],
            "age": ["30"]
        }
 
 

对于下面的代码:

 
 private void putItemToMap(Map<String, List<Item>> map,String tagName,Item item){
     List<Item> itemList = map.get(tagName);
 
     if (isNullOrEmpty(itemList)){
         itemList = new ArrayList<Item>();
     }
     itemList.add(item);
     map.put(tagName, itemList);
 }
 
 

可以重构成:

 
 private void putItemToMap(Map<String, List<Item>> map,String tagName,Item item){
     com.feilong.core.util.MapUtil.putMultiValue(map, tagName, item);
 }
 

Type Parameters:

K - the key type

V - the value type

Parameters:

map - the map

key - the key

value - the value

Returns:

如果 map 是null,抛出 NullPointerException

Since:

1.6.2

See Also:

"com.google.common.collect.ArrayListMultimap", MultiValuedMap, IterableMap, MultiMapUtils, AbstractMultiValuedMap

getSubMap

@SafeVarargs
public static <K,T> Map<K,T> getSubMap(Map<K,T> map,
                                   K... keys)

获得一个map 中,按照指定的keys 整理成新的map.

说明:

1. 原 map 不变
2. 返回的map为 LinkedHashMap,key的顺序 按照参数 keys的顺序
3. 如果循环的 key不在map key里面,则忽略该key,并输出debug level log

示例:

 Map<String, Integer> map = new HashMap<>();
 map.put("a", 3007);
 map.put("b", 3001);
 map.put("c", 3001);
 map.put("d", 3003);
 LOGGER.debug(JsonUtil.format(MapUtil.getSubMap(map, "a", "c")));
 

返回:

 {
 "a": 3007,
 "c": 3001
 }
 

Type Parameters:

K - the key type

T - the generic type

Parameters:

map - the map

keys - 如果循环的 key不在map key里面,则忽略该key,并输出debug level log

Returns:

如果 map 是null或者empty,返回 Collections.emptyMap();
如果 keys 是null或者empty,直接返回 map
如果循环的 key不在map key里面,则忽略该key,并输出debug level log

getSubMap

public static <K,T> Map<K,T> getSubMap(Map<K,T> map,
                       Iterable<K> keys)

获得一个map 中,按照指定的keys 整理成新的map.

说明:

1. 原 map 不变
2. 返回的map为 LinkedHashMap,key的顺序 按照参数 keys的顺序
3. 如果循环的 key不在map key里面,则忽略该key,并输出debug level log

示例:

 Map<String, Integer> map = new HashMap<>();
 map.put("a", 3007);
 map.put("b", 3001);
 map.put("c", 3001);
 map.put("d", 3003);
 LOGGER.debug(JsonUtil.format(MapUtil.getSubMap(map,toList("a", "c"))));
 

返回:

 {
 "a": 3007,
 "c": 3001
 }
 

Type Parameters:

K - the key type

T - the generic type

Parameters:

map - the map

keys - 如果循环的 key不在map key里面,则忽略该key,并输出debug level log

Returns:

如果 map 是null或者empty,返回 Collections.emptyMap();
如果 keys 是null或者empty,直接返回 map
如果循环的 key不在map key里面,则忽略该key,并输出debug level log

Since:

1.10.4

getSubMapExcludeKeys

@SafeVarargs
public static <K,T> Map<K,T> getSubMapExcludeKeys(Map<K,T> map,
                                              K... excludeKeys)

获得 sub map(排除指定的 excludeKeys).

说明:

1. 原 map 不变
2. 此方法可以提取Collections.unmodifiableMap(Map)
3. 返回值为 LinkedHashMap,key的顺序按照参数 map的顺序

示例:

 Map<String, Integer> map = new LinkedHashMap<>();
 
 map.put("a", 3007);
 map.put("b", 3001);
 map.put("c", 3002);
 map.put("g", -1005);
 
 LOGGER.debug(JsonUtil.format(MapUtil.getSubMapExcludeKeys(map, "a", "g", "m")));
 

返回:

 {
 "b": 3001,
 "c": 3002
 }
 
 

Type Parameters:

K - the key type

T - the generic type

Parameters:

map - the map

excludeKeys - the keys

Returns:

如果 map 是null或者empty,返回 Collections.emptyMap();
如果 excludeKeys 是null或者empty,直接返回 map

Since:

1.0.9

getSubMapExcludeKeys

public static <K,T> Map<K,T> getSubMapExcludeKeys(Map<K,T> map,
                                  Iterable<K> excludeKeys)

获得 sub map(排除指定的 excludeKeys).

说明:

1. 原 map 不变
2. 此方法可以提取Collections.unmodifiableMap(Map)
3. 返回值为 LinkedHashMap,key的顺序按照参数 map的顺序

示例:

 Map<String, Integer> map = new LinkedHashMap<>();
 
 map.put("a", 3007);
 map.put("b", 3001);
 map.put("c", 3002);
 map.put("g", -1005);
 
 LOGGER.debug(JsonUtil.format(MapUtil.getSubMapExcludeKeys(map, toList("a", "g", "m"))));
 

返回:

 {
 "b": 3001,
 "c": 3002
 }
 
 

Type Parameters:

K - the key type

T - the generic type

Parameters:

map - the map

excludeKeys - the exclude keys

Returns:

如果 map 是null或者empty,返回 Collections.emptyMap();
如果 excludeKeys 是null或者empty,直接返回 map

Since:

1.10.4

removeKeys

@SafeVarargs
public static <K,V> Map<K,V> removeKeys(Map<K,V> map,
                                    K... keys)

删除 map 的指定的 keys.

注意:

1. 原 map会改变,

   如果你只是需要从原map中获取非指定的keys,你可以调用 getSubMapExcludeKeys(Map, Object...) 或者getSubMapExcludeKeys(Map, Iterable) 方法

2. 此方法删除不了 Collections.unmodifiableMap(Map)
3. 如果 map包含key,那么直接调用 Map.remove(Object)
4. 如果不包含,那么输出debug级别日志

示例:

 
 Map<String, String> map = newLinkedHashMap(3);
 
 map.put("name", "feilong");
 map.put("age", "18");
 map.put("country", "china");
 
 LOGGER.debug(JsonUtil.format(MapUtil.removeKeys(map, "country")));
 
 

返回:

 {
 "name": "feilong",
 "age": "18"
 }
 
 

Type Parameters:

K - the key type

V - the value type

Parameters:

map - the map

keys - the keys

Returns:

如果 map 是null,返回null
如果 keys 是null或者empty,直接返回 map

Since:

1.6.3

invertMap

public static <K,V> Map<V,K> invertMap(Map<K,V> map)

将 map 的key和value互转.

说明:

1. 这个操作map预先良好的定义.
2. 如果传过来的map,不同的key有相同的value,那么返回的map(key)只会有一个(value),其他重复的key被丢掉了

示例:

 Map<String, Integer> map = new HashMap<>();
 map.put("a", 3007);
 map.put("b", 3001);
 map.put("c", 3001);
 map.put("d", 3003);
 LOGGER.debug(JsonUtil.format(MapUtil.invertMap(map)));
 

返回:

 {
 "3001": "c",
 "3007": "a",
 "3003": "d"
 }
 

可以看出 b元素被覆盖了

Type Parameters:

K - the key type

V - the value type

Parameters:

map - the map

Returns:

如果map 是null,返回 null
如果map 是empty,返回 一个 new HashMap

Since:

1.2.2

See Also:

MapUtils.invertMap(Map)

extractSubMap

public static <K,O,V> Map<K,V> extractSubMap(Map<K,O> map,
                             String extractPropertyName)

以参数 map的key为key,以参数 map value的指定extractPropertyName属性值为值,拼装成新的map返回.

说明:

1. 返回map的顺序,按照参数 map key的顺序

示例:

 Map<Long, User> map = new LinkedHashMap<>();
 map.put(1L, new User(100L));
 map.put(2L, new User(200L));
 map.put(5L, new User(500L));
 map.put(4L, new User(400L));
 
 LOGGER.debug(JsonUtil.format(MapUtil.extractSubMap(map, "id")));
 

返回:

    {
        "1": 100,
        "2": 200,
        "5": 500,
        "4": 400
    }
 

Type Parameters:

K - key的类型

O - map value bean类型

V - map value bean相关 属性名称 extractPropertyName 的值类型

Parameters:

map - the map

extractPropertyName - 泛型O对象指定的属性名称,Possibly indexed and/or nested name of the property to be modified,参见 propertyName

Returns:

如果 map 是null或者empty,返回 Collections.emptyMap()
如果 extractPropertyName 是null,抛出 NullPointerException
如果 extractPropertyName 是blank,抛出 IllegalArgumentException

Since:

1.8.0 remove class param

extractSubMap

public static <K,O,V> Map<K,V> extractSubMap(Map<K,O> map,
                             K[] includeKeys,
                             String extractPropertyName)

以参数 map的key为key,以参数 mapvalue的指定extractPropertyName 属性值为值,拼装成新的map返回.

说明:

1. 如果在抽取的过程中,map没有某个 includeKeys,将会忽略该key的抽取,并输出 warn log
2. 如果参数 includeKeys是null或者 empty,那么会抽取map所有的key
3. 返回map的顺序,按照参数includeKeys的顺序(如果includeKeys是null,那么按照map key的顺序)

示例:

 Map<Long, User> map = new LinkedHashMap<>();
 map.put(1L, new User(100L));
 map.put(2L, new User(200L));
 map.put(53L, new User(300L));
 map.put(5L, new User(500L));
 map.put(6L, new User(600L));
 map.put(4L, new User(400L));
 
 Long[] includeKeys = { 5L, 4L };
 LOGGER.debug(JsonUtil.format(MapUtil.extractSubMap(map, includeKeys, "id")));
 

返回:

 {
 "5": 500,
 "4": 400
 }
 

典型示例:

 
 private Map<Long, Long> constructPropertyIdAndItemPropertiesIdMap(
                 String properties,
                 Map<Long, PropertyValueSubViewCommand> itemPropertiesIdAndPropertyValueSubViewCommandMap){
     Long[] itemPropertiesIds = StoCommonUtil.toItemPropertiesIdLongs(properties);
 
     Map<Long, Long> itemPropertiesIdAndPropertyIdMap = MapUtil
                     .extractSubMap(itemPropertiesIdAndPropertyValueSubViewCommandMap, itemPropertiesIds, "propertyId");
 
     return MapUtil.invertMap(itemPropertiesIdAndPropertyIdMap);
 }
 
 

Type Parameters:

K - key的类型

O - map value bean类型

V - map value bean相关 属性名称 extractPropertyName 的值类型

Parameters:

map - the map

includeKeys - the include keys

extractPropertyName - 泛型O对象指定的属性名称,Possibly indexed and/or nested name of the property to be modified,参见 propertyName

Returns:

如果 map 是null或者empty,返回 Collections.emptyMap()
如果 extractPropertyName 是null,抛出 NullPointerException
如果 extractPropertyName 是blank,抛出 IllegalArgumentException
如果 includeKeys 是null或者empty, then will extract map total keys

Since:

1.8.0 remove class param

newConcurrentHashMap

public static <K,V> ConcurrentHashMap<K,V> newConcurrentHashMap()

New concurrent hash map.

Type Parameters:

K - the key type

V - the value type

Returns:

a new, empty ConcurrentHashMap

Since:

1.10.7

newConcurrentHashMap

public static <K,V> ConcurrentHashMap<K,V> newConcurrentHashMap(Map<K,V> map)

New concurrent hash map.

Type Parameters:

K - the key type

V - the value type

Parameters:

map - the map

Returns:

如果 map 是null,抛出 NullPointerException

Since:

1.14.0

newConcurrentHashMap

public static <K,V> ConcurrentHashMap<K,V> newConcurrentHashMap(int expectedSize)

创建 ConcurrentHashMap实例,拥有足够的 "initial capacity" 应该控制expectedSize elements without growth.

This behavior cannot be broadly guaranteed, but it is observed to be true for OpenJDK 1.7.
It also can't be guaranteed that the method isn't inadvertently oversizing the returned map.

示例:

 Map<String, String> map = MapUtil.newConcurrentHashMap(3);
 map.put("name", "feilong");
 map.put("age", "18");
 map.put("address", "shanghai");
 

使用该方法的好处:

1. 简化代码书写方式

   以前你可能需要这么写代码:

    Map<String, Map<Long, List<String>>> map = new ConcurrentHashMap<String, Map<Long, List<String>>>(16);
    

   如果你是使用JDK1.7或者以上,你可以使用钻石符:

    Map<String, Map<Long, List<String>>> map = new ConcurrentHashMap<>(16);
    

   不过只要你是使用1.5+,你都可以写成:

    Map<String, Map<Long, List<String>>> map = MapUtil.newConcurrentHashMap(16);// 如果搭配static import 使用会更加简洁
    

2. 减少扩容次数

   如果你要一次性初始一个能存放100个元素的map,并且不需要扩容,提高性能的话,你需要

    Map<String, Map<Long, List<String>>> map = new ConcurrentHashMap<String, Map<Long, List<String>>>(100/0.75+1);
    

   使用这个方法,你可以直接写成:

    Map<String, Map<Long, List<String>>> map = MapUtil.newConcurrentHashMap(100);// 如果搭配static import 使用会更加简洁
    

Type Parameters:

K - the key type

V - the value type

Parameters:

expectedSize - the number of entries you expect to add to the returned map

Returns:

a new, empty ConcurrentHashMap with enough capacity to hold expectedSize entries without resizing

Throws:

IllegalArgumentException - 如果 expectedSize< 0

Since:

1.11.1

newTreeMap

public static <K extends Comparable,V> TreeMap<K,V> newTreeMap()

New tree map.

Type Parameters:

K - the key type

V - the value type

Returns:

a new, empty ConcurrentHashMap

Since:

1.10.7

newTreeMap

public static <K extends Comparable,V> TreeMap<K,V> newTreeMap(Map<K,V> map)

New tree map.

Type Parameters:

K - the key type

V - the value type

Parameters:

map - the map

Returns:

如果 map 是null,抛出 NullPointerException

Since:

1.14.0

newHashMap

public static <K,V> HashMap<K,V> newHashMap()

创建 HashMap实例.

示例:

 Map<String, String> newHashMap = MapUtil.newHashMap();
 newHashMap.put("name", "feilong");
 newHashMap.put("age", "18");
 newHashMap.put("address", "shanghai");
 

使用该方法的好处:

1. 简化代码书写方式

   以前你可能需要这么写代码:

    Map<String, Map<Long, List<String>>> map = new HashMap<String, Map<Long, List<String>>>();
    

   如果你是使用JDK1.7或者以上,你可以使用钻石符:

    Map<String, Map<Long, List<String>>> map = new HashMap<>();
    

   不过只要你是使用1.5+,你都可以写成:

    Map<String, Map<Long, List<String>>> map = MapUtil.newHashMap(); // 如果搭配static import 使用会更加简洁
    

Type Parameters:

K - the key type

V - the value type

Returns:

the hash map

Since:

1.10.7

See Also:

"com.google.common.collect.Maps#newHashMap()", HashMap.HashMap()

newHashMap

public static <K,V> HashMap<K,V> newHashMap(Map<K,V> map)

New hash map.

Type Parameters:

K - the key type

V - the value type

Parameters:

map - the map

Returns:

如果 map 是null,抛出 NullPointerException

Since:

1.14.0

newHashMap

public static <K,V> HashMap<K,V> newHashMap(int expectedSize)

创建 HashMap实例,拥有足够的 "initial capacity" 应该控制expectedSize elements without growth.

This behavior cannot be broadly guaranteed, but it is observed to be true for OpenJDK 1.7.
It also can't be guaranteed that the method isn't inadvertently oversizing the returned map.

示例:

 Map<String, String> newHashMap = MapUtil.newHashMap(3);
 newHashMap.put("name", "feilong");
 newHashMap.put("age", "18");
 newHashMap.put("address", "shanghai");
 

使用该方法的好处:

1. 简化代码书写方式

   以前你可能需要这么写代码:

    Map<String, Map<Long, List<String>>> map = new HashMap<String, Map<Long, List<String>>>(16);
    

   如果你是使用JDK1.7或者以上,你可以使用钻石符:

    Map<String, Map<Long, List<String>>> map = new HashMap<>(16);
    

   不过只要你是使用1.5+,你都可以写成:

    Map<String, Map<Long, List<String>>> map = MapUtil.newHashMap(16);// 如果搭配static import 使用会更加简洁
    

2. 减少扩容次数

   如果你要一次性初始一个能存放100个元素的map,并且不需要扩容,提高性能的话,你需要

    Map<String, Map<Long, List<String>>> map = new HashMap<String, Map<Long, List<String>>>(100/0.75+1);
    

   使用这个方法,你可以直接写成:

    Map<String, Map<Long, List<String>>> map = MapUtil.newHashMap(100);// 如果搭配static import 使用会更加简洁
    

Type Parameters:

K - the key type

V - the value type

Parameters:

expectedSize - the number of entries you expect to add to the returned map

Returns:

a new, empty HashMap with enough capacity to hold expectedSize entries without resizing

Throws:

IllegalArgumentException - 如果 expectedSize< 0

Since:

1.7.1

See Also:

"com.google.common.collect.Maps#newHashMapWithExpectedSize(int)", HashMap.HashMap(int)

newLinkedHashMap

public static <K,V> LinkedHashMap<K,V> newLinkedHashMap()

创建 LinkedHashMap实例.

示例:

 Map<String, String> map = MapUtil.newLinkedHashMap();
 map.put("name", "feilong");
 map.put("age", "18");
 map.put("address", "shanghai");
 

使用该方法的好处:

1. 简化代码书写方式

   以前你可能需要这么写代码:

    Map<String, Map<Long, List<String>>> map = new LinkedHashMap<String, Map<Long, List<String>>>();
    

   如果你是使用JDK1.7或者以上,你可以使用钻石符:

    Map<String, Map<Long, List<String>>> map = new LinkedHashMap<>();
    

   不过只要你是使用1.5+,你都可以写成:

    Map<String, Map<Long, List<String>>> map = MapUtil.newLinkedHashMap();// 如果搭配static import 使用会更加简洁
    

Type Parameters:

K - the key type

V - the value type

Returns:

the linked hash map

Since:

1.10.7

See Also:

"com.google.common.collect.Maps#newLinkedHashMapWithExpectedSize(int)", LinkedHashMap.LinkedHashMap()

newLinkedHashMap

public static <K,V> LinkedHashMap<K,V> newLinkedHashMap(Map<K,V> map)

New linked hash map.

Type Parameters:

K - the key type

V - the value type

Parameters:

map - the map

Returns:

如果 map 是null,抛出 NullPointerException

Since:

1.14.0

newLinkedHashMap

public static <K,V> LinkedHashMap<K,V> newLinkedHashMap(int expectedSize)

创建 LinkedHashMap实例,拥有足够的 "initial capacity" 应该控制expectedSize elements without growth.

This behavior cannot be broadly guaranteed, but it is observed to be true for OpenJDK 1.7.
It also can't be guaranteed that the method isn't inadvertently oversizing the returned map.

示例:

 Map<String, String> map = MapUtil.newLinkedHashMap(3);
 map.put("name", "feilong");
 map.put("age", "18");
 map.put("address", "shanghai");
 

使用该方法的好处:

1. 简化代码书写方式

   以前你可能需要这么写代码:

    Map<String, Map<Long, List<String>>> map = new LinkedHashMap<String, Map<Long, List<String>>>(16);
    

   如果你是使用JDK1.7或者以上,你可以使用钻石符:

    Map<String, Map<Long, List<String>>> map = new LinkedHashMap<>(16);
    

   不过只要你是使用1.5+,你都可以写成:

    Map<String, Map<Long, List<String>>> map = MapUtil.newLinkedHashMap(16);// 如果搭配static import 使用会更加简洁
    

2. 减少扩容次数

   如果你要一次性初始一个能存放100个元素的map,并且不需要扩容,提高性能的话,你需要

    Map<String, Map<Long, List<String>>> map = new LinkedHashMap<String, Map<Long, List<String>>>(100/0.75+1);
    

   使用这个方法,你可以直接写成:

    Map<String, Map<Long, List<String>>> map = MapUtil.newLinkedHashMap(100);// 如果搭配static import 使用会更加简洁
    

Type Parameters:

K - the key type

V - the value type

Parameters:

expectedSize - the number of entries you expect to add to the returned map

Returns:

a new, empty LinkedHashMap with enough capacity to hold expectedSize entries without resizing

Throws:

IllegalArgumentException - 如果 size< 0

Since:

1.7.1

See Also:

"com.google.common.collect.Maps#newLinkedHashMapWithExpectedSize(int)", LinkedHashMap.LinkedHashMap(int)