package com.tudicloud.framework.common.core.util.core;
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.HashMap;
import java.util.Map;
/**
* Map工具类，提供常用的Map操作方法。
*
* @Author 孙达
* @Date 2025/11/14 14:08
* @Wechat sundaain
* @Email 18211102099@163.com
* @Copyright <a href="https://www.sundablog.com">孙达博客</a>
*/
public class MapUtils {
// ---------------------- empty check ----------------------
/**
* 判断给定的Map是否为空（null 或 size == 0）。
*
* @param map 要检查的Map对象
* @return 如果Map为null或没有元素则返回true；否则返回false
*/
public static boolean isEmpty(final Map<?,?> map) {
return map == null || map.isEmpty();
}
/**
* 判断给定的Map是否不为空。
*
* @param map 要检查的Map对象
* @return 如果Map不为null且至少有一个元素则返回true；否则返回false
*/
public static boolean isNotEmpty(final Map<?,?> map) {
return !isEmpty(map);
}
// ---------------------- type safe getter ----------------------
/**
* 获取指定键对应的字符串值。
*
* @param map 包含数据的Map
* @param key 键名
* @param <K> 泛型类型参数，表示键的类型
* @return 对应键的字符串形式值，如果不存在或为null则返回null
*/
public static <K> String getString(final Map<? super K, ?> map, final K key) {
if (map != null) {
final Object value = map.get(key);
if (value != null) {
return value.toString();
}
}
return null;
}
/**
* 获取指定键对应的布尔值。
*
* @param map 包含数据的Map
* @param key 键名
* @param <K> 泛型类型参数，表示键的类型
* @return 布尔类型的值。支持从Boolean、String、Number转换而来。
* 若无法解析或值为null，则返回null。
*/
public static <K> Boolean getBoolean(final Map<? super K, ?> map, final K key) {
if (map != null) {
final Object value = map.get(key);
if (value != null) {
if (value instanceof Boolean) {
return (Boolean) value;
}
if (value instanceof String) {
return Boolean.valueOf((String) value);
}
if (value instanceof Number) {
final Number n = (Number) value;
return n.intValue() != 0 ? Boolean.TRUE : Boolean.FALSE;
}
}
}
return null;
}
/**
* 获取指定键对应的数值(Number)值。
*
* @param map 包含数据的Map
* @param key 键名
* @param <K> 泛型类型参数，表示键的类型
* @return 数字类型的值。支持从Number和可解析的String中获取。
* 若无法解析或值为null，则返回null。
*/
public static <K> Number getNumber(final Map<? super K, ?> map, final K key) {
if (map != null) {
final Object value = map.get(key);
if (value != null) {
if (value instanceof Number) {
return (Number) value;
}
if (value instanceof String) {
try {
final String text = (String) value;
return NumberFormat.getInstance().parse(text);
} catch (final ParseException e) { // NOPMD
// failure means null is returned
}
}
}
}
return null;
}
/**
* 获取指定键对应的字节(Byte)值。
*
* @param map 包含数据的Map
* @param key 键名
* @param <K> 泛型类型参数，表示键的类型
* @return 字节类型的值。若原始值不是Byte类型但可以转成Number，
* 将通过Number.byteValue()进行转换。
* 若无法解析或值为null，则返回null。
*/
public static <K> Byte getByte(final Map<? super K, ?> map, final K key) {
final Number value = getNumber(map, key);
if (value == null) {
return null;
}
if (value instanceof Byte) {
return (Byte) value;
}
return Byte.valueOf(value.byteValue());
}
/**
* 获取指定键对应的短整型(Short)值。
*
* @param map 包含数据的Map
* @param key 键名
* @param <K> 泛型类型参数，表示键的类型
* @return 短整型的值。若原始值不是Short类型但可以转成Number，
* 将通过Number.shortValue()进行转换。
* 若无法解析或值为null，则返回null。
*/
public static <K> Short getShort(final Map<? super K, ?> map, final K key) {
final Number value = getNumber(map, key);
if (value == null) {
return null;
}
if (value instanceof Short) {
return (Short) value;
}
return Short.valueOf(value.shortValue());
}
/**
* 获取指定键对应的整数(Integer)值。
*
* @param map 包含数据的Map
* @param key 键名
* @param <K> 泛型类型参数，表示键的类型
* @return 整数类型的值。若原始值不是Integer类型但可以转成Number，
* 将通过Number.intValue()进行转换。
* 若无法解析或值为null，则返回null。
*/
public static <K> Integer getInteger(final Map<? super K, ?> map, final K key) {
final Number value = getNumber(map, key);
if (value == null) {
return null;
}
if (value instanceof Integer) {
return (Integer) value;
}
return Integer.valueOf(value.intValue());
}
/**
* 获取指定键对应的长整型(Long)值。
*
* @param map 包含数据的Map
* @param key 键名
* @param <K> 泛型类型参数，表示键的类型
* @return 长整型的值。若原始值不是Long类型但可以转成Number，
* 将通过Number.longValue()进行转换。
* 若无法解析或值为null，则返回null。
*/
public static <K> Long getLong(final Map<? super K, ?> map, final K key) {
final Number value = getNumber(map, key);
if (value == null) {
return null;
}
if (value instanceof Long) {
return (Long) value;
}
return Long.valueOf(value.longValue());
}
/**
* 获取指定键对应的浮点(Float)值。
*
* @param map 包含数据的Map
* @param key 键名
* @param <K> 泛型类型参数，表示键的类型
* @return 浮点类型的值。若原始值不是Float类型但可以转成Number，
* 将通过Number.floatValue()进行转换。
* 若无法解析或值为null，则返回null。
*/
public static <K> Float getFloat(final Map<? super K, ?> map, final K key) {
final Number value = getNumber(map, key);
if (value == null) {
return null;
}
if (value instanceof Float) {
return (Float) value;
}
return Float.valueOf(value.floatValue());
}
/**
* 获取指定键对应的双精度(Double)值。
*
* @param map 包含数据的Map
* @param key 键名
* @param <K> 泛型类型参数，表示键的类型
* @return 双精度类型的值。若原始值不是Double类型但可以转成Number，
* 将通过Number.doubleValue()进行转换。
* 若无法解析或值为null，则返回null。
*/
public static <K> Double getDouble(final Map<? super K, ?> map, final K key) {
final Number value = getNumber(map, key);
if (value == null) {
return null;
}
if (value instanceof Double) {
return (Double) value;
}
return Double.valueOf(value.doubleValue());
}
// ---------------------- new ----------------------
/**
* 创建一个新的HashMap实例。
*
* @param <K> 键的泛型类型
* @param <V> 值的泛型类型
* @return 新创建的HashMap实例
*/
public static <K, V> HashMap<K, V> newMap() {
return new HashMap<K, V>();
}
/**
* 构建一个包含单个键值对的新HashMap。
*
* @param k1 第一个键
* @param v1 第一个值
* @param <K> 键的泛型类型
* @param <V> 值的泛型类型
* @return 包含该键值对的HashMap实例
*/
public static <K, V> HashMap<K, V> newMap(K k1, V v1) {
HashMap<K, V> map = new HashMap<>();
map.put(k1, v1);
return map;
}
/**
* 构建一个包含两个键值对的新HashMap。
*
* @param k1 第一个键
* @param v1 第一个值
* @param k2 第二个键
* @param v2 第二个值
* @param <K> 键的泛型类型
* @param <V> 值的泛型类型
* @return 包含这两个键值对的HashMap实例
*/
public static <K, V> HashMap<K, V> newMap(K k1, V v1, K k2, V v2) {
HashMap<K, V> map = new HashMap<>();
map.put(k1, v1);
map.put(k2, v2);
return map;
}
/**
* 构建一个包含三个键值对的新HashMap。
*
* @param k1 第一个键
* @param v1 第一个值
* @param k2 第二个键
* @param v2 第二个值
* @param k3 第三个键
* @param v3 第三个值
* @param <K> 键的泛型类型
* @param <V> 值的泛型类型
* @return 包含这三个键值对的HashMap实例
*/
public static <K, V> HashMap<K, V> newMap(K k1, V v1, K k2, V v2, K k3, V v3) {
HashMap<K, V> map = new HashMap<>();
map.put(k1, v1);
map.put(k2, v2);
map.put(k3, v3);
return map;
}
/**
* 构建一个包含四个键值对的新HashMap。
*
* @param k1 第一个键
* @param v1 第一个值
* @param k2 第二个键
* @param v2 第二个值
* @param k3 第三个键
* @param v3 第三个值
* @param k4 第四个键
* @param v4 第四个值
* @param <K> 键的泛型类型
* @param <V> 值的泛型类型
* @return 包含这四个键值对的HashMap实例
*/
public static <K, V> HashMap<K, V> newMap(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
HashMap<K, V> map = new HashMap<>();
map.put(k1, v1);
map.put(k2, v2);
map.put(k3, v3);
map.put(k4, v4);
return map;
}
/**
* 构建一个包含五个键值对的新HashMap。
*
* @param k1 第一个键
* @param v1 第一个值
* @param k2 第二个键
* @param v2 第二个值
* @param k3 第三个键
* @param v3 第三个值
* @param k4 第四个键
* @param v4 第四个值
* @param k5 第五个键
* @param v5 第五个值
* @param <K> 键的泛型类型
* @param <V> 值的泛型类型
* @return 包含这五个键值对的HashMap实例
*/
public static <K, V> HashMap<K, V> newMap(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
HashMap<K, V> map = new HashMap<>();
map.put(k1, v1);
map.put(k2, v2);
map.put(k3, v3);
map.put(k4, v4);
map.put(k5, v5);
return map;
}
// ---------------------- other ----------------------
}
最后修改：2025 年 11 月 14 日
© 允许规范转载