public class MapUtil extends MapGetUtil
Modifier and Type | Field and Description |
---|---|
static int |
DEFAULT_INITIAL_CAPACITY
默认初始大小
|
static float |
DEFAULT_LOAD_FACTOR
默认增长因子,当Map的size达到 容量*增长因子时,开始扩充Map
|
Constructor and Description |
---|
MapUtil() |
Modifier and Type | Method and Description |
---|---|
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> V |
computeIfAbsentForJdk8(Map<K,V> map,
K key,
Function<? super K,? extends V> mappingFunction)
如果 key 对应的 value 不存在,则使用获取 mappingFunction 重新计算后的值,并保存为该 key 的 value,否则返回 value。
|
static <K,V> Map<K,V> |
createMap(Class<?> mapType)
|
static <K,V> Map<K,V> |
createMap(Class<?> mapType,
Supplier<Map<K,V>> defaultMap)
|
static MapProxy |
createProxy(Map<?,?> map)
创建代理Map
MapProxy 对Map做一次包装,提供各种getXXX方法 |
static <T extends Map<K,V>,K,V> |
defaultIfEmpty(T map,
T defaultMap)
如果给定Map为空,返回默认Map
|
static <K,V> Map<K,V> |
edit(Map<K,V> map,
UnaryOperator<Map.Entry<K,V>> editor)
编辑Map
编辑过程通过传入的Editor实现来返回需要的元素内容,这个Editor实现可以实现以下功能: 1、过滤出需要的对象,如果返回 null 表示这个元素对象抛弃
2、修改元素对象,返回集合中为修改后的对象
|
static <K,V> Map<K,V> |
empty()
返回一个空Map
|
static <K,V,T extends Map<K,V>> |
empty(Class<?> mapClass)
根据传入的Map类型不同,返回对应类型的空Map,支持类型包括:
1.
|
static <K,V> Map<K,V> |
emptyIfNull(Map<K,V> set)
|
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,
K... keys)
过滤Map保留指定键值对,如果键不存在跳过
|
static <K,V> Map<K,V> |
filter(Map<K,V> map,
Predicate<Map.Entry<K,V>> predicate)
过滤
过滤过程通过传入的Editor实现来返回需要的元素内容,这个Filter实现可以实现以下功能: 1、过滤出需要的对象,如果返回null表示这个元素对象抛弃 |
static <K,V> Map.Entry<K,V> |
firstMatch(Map<K,V> map,
Predicate<Map.Entry<K,V>> predicate)
遍历Map,返回第一个匹配的entry值
|
static <K,V> V |
firstMatchValue(Map<K,V> map,
Predicate<Map.Entry<K,V>> predicate)
遍历Map,返回第一个匹配的value值
|
static <K,V> void |
forEach(Map<K,V> map,
SerConsumer3<Integer,K,V> kvConsumer)
循环遍历Map,使用
SerConsumer3 接受遍历的每条数据,并针对每条数据做处理和JDK8中的map.forEach不同的是,此方法支持index |
static <K,V> Map<K,V> |
getAny(Map<K,V> map,
K... keys)
获取Map的部分key生成新的Map
|
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,
Predicate<Map.Entry<K,V>> predicate,
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,R> Map<K,R> |
map(Map<K,V> map,
BiFunction<K,V,R> biFunction)
|
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> |
newSafeConcurrentHashMap()
|
static <K,V> ConcurrentHashMap<K,V> |
newSafeConcurrentHashMap(int size)
|
static <K,V> ConcurrentHashMap<K,V> |
newSafeConcurrentHashMap(Map<K,V> map)
传入一个Map将其转化为
SafeConcurrentHashMap 类型 |
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> HashMap<K,V> |
ofEntries(Iterable<Map.Entry<K,V>> entryIter)
将Entry集合转换为HashMap
|
static <K,V> HashMap<K,V> |
ofEntries(Iterator<Map.Entry<K,V>> entryIter)
将Entry集合转换为HashMap
|
static <K,V> Map<K,V> |
ofEntries(Map.Entry<K,V>... entries)
根据给定的Pair数组创建Map对象
|
static <K,V> Map<K,V> |
ofKvs(boolean isLinked,
Object... keysAndValues)
根据给定的键值对数组创建HashMap对象,传入参数必须为key,value,key,value...
|
static <K,V> List<Map<K,V>> |
partition(Map<K,V> map,
int size)
将一个Map按照固定大小拆分成多个子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,T extends Map<K,V>> |
removeAny(T map,
K... keys)
去掉Map中指定key的键值对,修改原Map
|
static <K,V> Map<K,V> |
removeByValue(Map<K,V> map,
V value)
去除Map中值为指定值的键值对
注意:此方法在传入的Map上直接修改。 |
static <K,V> Map<K,V> |
removeIf(Map<K,V> map,
Predicate<Map.Entry<K,V>> predicate)
去除Map中值为
null 的键值对注意:此方法在传入的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)
|
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 <K,V extends Comparable<? super V>> |
sortByValue(Map<K,V> map,
boolean isDesc)
按照值排序,可选是否倒序
|
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> 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,可加入元素)
|
public static final int DEFAULT_INITIAL_CAPACITY
public static final float DEFAULT_LOAD_FACTOR
public static boolean isEmpty(Map<?,?> map)
map
- 集合public static boolean isNotEmpty(Map<?,?> map)
map
- 集合public static <K,V> Map<K,V> emptyIfNull(Map<K,V> set)
K
- 键类型V
- 值类型set
- 提供的集合,可能为nullpublic static <T extends Map<K,V>,K,V> T defaultIfEmpty(T map, T defaultMap)
T
- 集合类型K
- 键类型V
- 值类型map
- MapdefaultMap
- 默认Mappublic static <K,V> HashMap<K,V> newHashMap()
K
- Key类型V
- Value类型public static <K,V> HashMap<K,V> newHashMap(int size, boolean isLinked)
K
- Key类型V
- Value类型size
- 初始大小,由于默认负载因子0.75,传入的size会实际初始大小为size / 0.75 + 1isLinked
- Map的Key是否有序,有序返回 LinkedHashMap
,否则返回 HashMap
public static <K,V> HashMap<K,V> newHashMap(int size)
K
- Key类型V
- Value类型size
- 初始大小,由于默认负载因子0.75,传入的size会实际初始大小为size / 0.75 + 1public static <K,V> HashMap<K,V> newHashMap(boolean isLinked)
K
- Key类型V
- Value类型isLinked
- Map的Key是否有序,有序返回 LinkedHashMap
,否则返回 HashMap
public static <K,V> TreeMap<K,V> newTreeMap(Comparator<? super K> comparator)
K
- key的类型V
- value的类型comparator
- Key比较器public static <K,V> TreeMap<K,V> newTreeMap(Map<K,V> map, Comparator<? super K> comparator)
K
- key的类型V
- value的类型map
- Mapcomparator
- Key比较器public static <K,V> Map<K,V> newIdentityMap(int size)
K
- key的类型V
- value的类型size
- 初始容量IdentityHashMap
public static <K,V> ConcurrentHashMap<K,V> newSafeConcurrentHashMap()
K
- key的类型V
- value的类型SafeConcurrentHashMap
public static <K,V> ConcurrentHashMap<K,V> newSafeConcurrentHashMap(int size)
K
- key的类型V
- value的类型size
- 初始容量,当传入的容量小于等于0时,容量为DEFAULT_INITIAL_CAPACITY
SafeConcurrentHashMap
public static <K,V> ConcurrentHashMap<K,V> newSafeConcurrentHashMap(Map<K,V> map)
SafeConcurrentHashMap
类型K
- key的类型V
- value的类型map
- mapSafeConcurrentHashMap
public static <K,V> Map<K,V> createMap(Class<?> mapType)
K
- map键类型V
- map值类型mapType
- map类型Map
实例public static <K,V> Map<K,V> createMap(Class<?> mapType, Supplier<Map<K,V>> defaultMap)
K
- map键类型V
- map值类型mapType
- map类型defaultMap
- 如果通过反射创建失败或提供的是抽象Map,则创建的默认MapMap
实例public static <K,V> HashMap<K,V> of(K key, V value)
K
- 键类型V
- 值类型key
- 键value
- 值HashMap
public static <K,V> HashMap<K,V> of(K key, V value, boolean isOrder)
K
- 键类型V
- 值类型key
- 键value
- 值isOrder
- 是否有序HashMap
public static <K,V> Map<K,V> ofKvs(boolean isLinked, Object... keysAndValues)
奇数参数必须为key,key最后会转换为String类型。
偶数参数必须为value,可以为任意类型。
LinkedHashMap map = MapUtil.ofKvs(false, "RED", "#FF0000", "GREEN", "#00FF00", "BLUE", "#0000FF" );
K
- 键类型V
- 值类型isLinked
- 是否使用LinkedHashMap
keysAndValues
- 键值对列表,必须奇数参数为key,偶数参数为valueDict.ofKvs(Object...)
,
Dict.ofKvs(Object...)
@SafeVarargs public static <K,V> Map<K,V> ofEntries(Map.Entry<K,V>... entries)
K
- 键类型V
- 值类型entries
- 键值对entry(Object, Object)
public static <K,V> HashMap<K,V> ofEntries(Iterable<Map.Entry<K,V>> entryIter)
K
- 键类型V
- 值类型entryIter
- entry集合public static <K,V> HashMap<K,V> ofEntries(Iterator<Map.Entry<K,V>> entryIter)
K
- 键类型V
- 值类型entryIter
- entry集合public static HashMap<Object,Object> of(Object[] array)
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、IteratorHashMap
public static <K,V> Map<K,List<V>> toListMap(Iterable<? extends Map<K,V>> mapList)
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列表public static <K,V> List<Map<K,V>> toMapList(Map<K,? extends Iterable<V>> listMap)
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
- 列表Mappublic static <K,V> Map<K,V> toCamelCaseMap(Map<K,V> map)
K
- key的类型V
- value的类型map
- 原Mappublic static Object[][] toObjectArray(Map<?,?> map)
map
- mappublic static <K,V> String join(Map<K,V> map, String separator, String keyValueSeparator, String... otherParams)
K
- 键类型V
- 值类型map
- Mapseparator
- entry之间的连接符keyValueSeparator
- kv之间的连接符otherParams
- 其它附加参数字符串(例如密钥)public static String sortJoin(Map<?,?> params, String separator, String keyValueSeparator, boolean isIgnoreNull, String... otherParams)
params
- 参数separator
- entry之间的连接符keyValueSeparator
- kv之间的连接符isIgnoreNull
- 是否忽略null的键和值otherParams
- 其它附加参数字符串(例如密钥)public static <K,V> String joinIgnoreNull(Map<K,V> map, String separator, String keyValueSeparator, String... otherParams)
K
- 键类型V
- 值类型map
- Mapseparator
- entry之间的连接符keyValueSeparator
- kv之间的连接符otherParams
- 其它附加参数字符串(例如密钥)public static <K,V> String join(Map<K,V> map, String separator, String keyValueSeparator, boolean isIgnoreNull, String... otherParams)
K
- 键类型V
- 值类型map
- Map,为空返回otherParams拼接separator
- entry之间的连接符keyValueSeparator
- kv之间的连接符isIgnoreNull
- 是否忽略null的键和值otherParams
- 其它附加参数字符串(例如密钥)public static <K,V> String join(Map<K,V> map, String separator, String keyValueSeparator, Predicate<Map.Entry<K,V>> predicate, String... otherParams)
K
- 键类型V
- 值类型map
- Map,为空返回otherParams拼接separator
- entry之间的连接符keyValueSeparator
- kv之间的连接符predicate
- 键值对过滤otherParams
- 其它附加参数字符串(例如密钥)public static <K,V> Map<K,V> edit(Map<K,V> map, UnaryOperator<Map.Entry<K,V>> editor)
1、过滤出需要的对象,如果返回 null
表示这个元素对象抛弃
2、修改元素对象,返回集合中为修改后的对象
K
- Key类型V
- Value类型map
- Mapeditor
- 编辑器接口public static <K,V> Map<K,V> filter(Map<K,V> map, Predicate<Map.Entry<K,V>> predicate)
1、过滤出需要的对象,如果返回null表示这个元素对象抛弃
K
- Key类型V
- Value类型map
- Mappredicate
- 过滤器接口,Predicate.test(Object)
为true
保留,null
返回原Mappublic static <K,V,R> Map<K,R> map(Map<K,V> map, BiFunction<K,V,R> biFunction)
K
- key
的类型V
- value
的类型R
- 新的,修改后的value
的类型map
- 原有的mapbiFunction
- lambda
,参数包含key
,value
,返回值会作为新的value
Map
public static <K,V> Map<K,V> filter(Map<K,V> map, K... keys)
K
- Key类型V
- Value类型map
- 原始Mapkeys
- 键列表,null
返回原Mappublic static <T> Map<T,T> reverse(Map<T,T> map)
T
- 键和值类型map
- Map对象,键值类型必须一致inverse(Map)
public static <K,V> Map<V,K> inverse(Map<K,V> map)
K
- 键和值类型V
- 键和值类型map
- Map对象public static <K,V> TreeMap<K,V> sort(Map<K,V> map)
K
- key的类型V
- value的类型map
- MapnewTreeMap(Map, Comparator)
public static <K,V> TreeMap<K,V> sort(Map<K,V> map, Comparator<? super K> comparator)
K
- key的类型V
- value的类型map
- Map,为null返回nullcomparator
- Key比较器newTreeMap(Map, Comparator)
public static <K,V extends Comparable<? super V>> Map<K,V> sortByValue(Map<K,V> map, boolean isDesc)
K
- 键类型V
- 值类型map
- 需要对值排序的mapisDesc
- 是否倒序public static MapProxy createProxy(Map<?,?> map)
MapProxy
对Map做一次包装,提供各种getXXX方法map
- 被代理的MapMapProxy
public static <K,V> MapWrapper<K,V> wrap(Map<K,V> map)
MapWrapper
对Map做一次包装K
- key的类型V
- value的类型map
- 被代理的MapMapWrapper
public static <K,V> Map<K,V> view(Map<K,V> map)
K
- 键类型V
- 值类型map
- Mappublic static <K,V> MapBuilder<K,V> builder()
K
- Key类型V
- Value类型public static <K,V> MapBuilder<K,V> builder(Map<K,V> map)
K
- Key类型V
- Value类型map
- 实际使用的mappublic static <K,V> MapBuilder<K,V> builder(K k, V v)
K
- Key类型V
- Value类型k
- keyv
- valuepublic static <K,V> Map<K,V> getAny(Map<K,V> map, K... keys)
K
- Key类型V
- Value类型map
- Mapkeys
- 键列表public static <K,V,T extends Map<K,V>> T removeAny(T map, K... keys)
K
- Key类型V
- Value类型T
- Map类型map
- Mapkeys
- 键列表public static <K,V> Map<K,V> renameKey(Map<K,V> map, K oldKey, K newKey)
K
- key的类型V
- value的类型map
- MapoldKey
- 原键newKey
- 新键IllegalArgumentException
- 新key存在抛出此异常public static <K,V> Map<K,V> removeNullValue(Map<K,V> map)
null
的键值对K
- key的类型V
- value的类型map
- Mappublic static <K,V> Map<K,V> removeByValue(Map<K,V> map, V value)
K
- key的类型V
- value的类型map
- Mapvalue
- 给定值public static <K,V> Map<K,V> removeIf(Map<K,V> map, Predicate<Map.Entry<K,V>> predicate)
null
的键值对K
- key的类型V
- value的类型map
- Mappredicate
- 移除条件,当Predicate.test(Object)
为true
时移除public static <K,V> Map<K,V> empty()
K
- 键类型V
- 值类型Collections.emptyMap()
public static <K,V> Map<K,V> zero()
K
- 键类型V
- 值类型public static <K,V,T extends Map<K,V>> T empty(Class<?> mapClass)
1. NavigableMap 2. SortedMap 3. Map
K
- 键类型V
- 值类型T
- Map类型mapClass
- Map类型,null返回默认的Mappublic static void clear(Map<?,?>... maps)
maps
- 一个或多个Mappublic static <K,V> ArrayList<V> valuesOfKeys(Map<K,V> map, K... keys)
K
- 键类型V
- 值类型map
- Map
keys
- 键列表public static <K,V> ArrayList<V> valuesOfKeys(Map<K,V> map, Iterable<K> keys)
K
- 键类型V
- 值类型map
- Map
keys
- 键列表public static <K,V> ArrayList<V> valuesOfKeys(Map<K,V> map, Iterator<K> keys)
K
- 键类型V
- 值类型map
- Map
keys
- 键列表public static <K,V> Map.Entry<K,V> entry(K key, V value)
AbstractMap.SimpleImmutableEntry
K
- 键类型V
- 值类型key
- 键value
- 值AbstractMap.SimpleImmutableEntry
public static <K,V> Map.Entry<K,V> entry(K key, V value, boolean isImmutable)
AbstractMap.SimpleEntry
或者 AbstractMap.SimpleImmutableEntry
K
- 键类型V
- 值类型key
- 键value
- 值isImmutable
- 是否不可变EntryAbstractMap.SimpleEntry
或者 AbstractMap.SimpleImmutableEntry
public static <K,V> Map<K,V> putAll(Map<K,V> resultMap, Iterable<V> iterable, Function<V,K> keyMapper)
K
- 键类型V
- 值类型resultMap
- 结果Map,通过传入map对象决定结果的Map类型,如果为null
,默认使用HashMapiterable
- 值列表keyMapper
- Map的键映射public static <T,K,V> Map<K,V> putAll(Map<K,V> resultMap, Iterable<T> iterable, Function<T,K> keyMapper, Function<T,V> valueMapper)
T
- 列表值类型K
- 键类型V
- 值类型resultMap
- 结果Map,通过传入map对象决定结果的Map类型iterable
- 值列表keyMapper
- Map的键映射valueMapper
- Map的值映射public static <K,V> Map<K,V> putAll(Map<K,V> resultMap, Iterator<V> iterator, Function<V,K> keyMapper)
K
- 键类型V
- 值类型resultMap
- 结果Map,通过传入map对象决定结果的Map类型,如果为null
,默认使用HashMapiterator
- 值列表keyMapper
- Map的键映射public static <T,K,V> Map<K,V> putAll(Map<K,V> resultMap, Iterator<T> iterator, Function<T,K> keyMapper, Function<T,V> valueMapper)
T
- 列表值类型K
- 键类型V
- 值类型resultMap
- 结果Map,通过传入map对象决定结果的Map类型,如果为null
,默认使用HashMapiterator
- 值列表keyMapper
- Map的键映射valueMapper
- Map的值映射public static <K,V> Map<K,List<V>> grouping(Iterable<Map.Entry<K,V>> entries)
K
- 键类型V
- 值类型entries
- entry列表public static <K,V> V computeIfAbsentForJdk8(Map<K,V> map, K key, Function<? super K,? extends V> mappingFunction)
注意此方法只能用于JDK8
K
- 键类型V
- 值类型map
- Map,一般用于线程安全的Mapkey
- 键mappingFunction
- 值计算函数public static <K,V> List<Map<K,V>> partition(Map<K,V> map, int size)
K
- 键类型V
- 值类型map
- Mapsize
- 子Map的大小public static <K,V> V firstMatchValue(Map<K,V> map, Predicate<Map.Entry<K,V>> predicate)
K
- 键类型V
- 值类型map
- mappredicate
- 匹配条件public static <K,V> Map.Entry<K,V> firstMatch(Map<K,V> map, Predicate<Map.Entry<K,V>> predicate)
K
- 键类型V
- 值类型map
- mappredicate
- 匹配条件public static <K,V> void forEach(Map<K,V> map, SerConsumer3<Integer,K,V> kvConsumer)
SerConsumer3
接受遍历的每条数据,并针对每条数据做处理K
- Key类型V
- Value类型map
- Map
kvConsumer
- SerConsumer3
遍历的每条数据处理器Copyright © 2025. All rights reserved.