Map 工具 - MapUtil

简介

MapUtil 是 Hutool 提供的针对 Map 的一系列工具方法的封装，涵盖了从基本的 Map 操作到常用的转换、过滤、排序、合并等功能。它为开发者提供了更简便、高效的 Map 操作方式，尤其在需要进行快速转换、构建或过滤时非常实用。

1. 判断 Map 是否为空或非空

通过 isEmpty 和 isNotEmpty 方法，可以快速判断一个 Map 是否为空。空的定义为 null 或没有任何键值对。

示例：判断 Map 是否为空或非空

import cn.hutool.core.map.MapUtil;
import java.util.HashMap;
import java.util.Map;

public class MapUtilExample {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();

        // 判断是否为空
        boolean isEmpty = MapUtil.isEmpty(map);
        System.out.println("Map 是否为空: " + isEmpty); // true

        // 添加元素
        map.put("key", "value");

        // 判断是否非空
        boolean isNotEmpty = MapUtil.isNotEmpty(map);
        System.out.println("Map 是否非空: " + isNotEmpty); // true
    }
}

• 方法签名：
  • boolean isEmpty(Map<?, ?> map)：判断 Map 是否为空。
  • boolean isNotEmpty(Map<?, ?> map)：判断 Map 是否非空。
• 参数说明：
  • map: 需要判断的 Map 对象。
• 返回值：boolean，返回 true 表示 Map 为空或非空。
• 作用：用于快速判断 Map 是否为空，适用于需要进行前置检查的场景。
• 实际开发场景：在处理数据前，可以使用这些方法进行空判断，避免 null 引发的异常。

2. 快速创建 HashMap

通过 newHashMap 方法，可以快速创建多种类型的 HashMap 实例，支持指定初始容量。

示例：创建 HashMap 实例

import cn.hutool.core.map.MapUtil;
import java.util.HashMap;
import java.util.Map;

public class MapUtilExample {
    public static void main(String[] args) {
        // 创建一个空的 HashMap
        Map<String, String> map = MapUtil.newHashMap();

        // 创建一个指定初始容量的 HashMap
        Map<String, String> customMap = MapUtil.newHashMap(10);

        // 添加元素
        map.put("key1", "value1");
        customMap.put("key2", "value2");

        // 输出 Map 内容
        System.out.println("默认容量创建的 Map: " + map);
        System.out.println("指定初始容量创建的 Map: " + customMap);
    }
}

• 方法签名：
  • HashMap<K, V> newHashMap()：创建一个空的 HashMap。
  • HashMap<K, V> newHashMap(int initialCapacity)：创建一个指定初始容量的 HashMap。
• 参数说明：
  • initialCapacity: 指定的初始容量。
• 返回值：HashMap<K, V>，返回创建的 HashMap 实例。
• 作用：用于快速创建 HashMap 实例，特别是在需要自定义初始容量时更为方便。
• 实际开发场景：在频繁操作 Map 的场景中，使用这些方法可以简化代码。

3. 创建自定义 Map 实例

通过 createMap 方法，可以创建自定义类型的 Map 实例，支持多种 Map 实现，如 LinkedHashMap、TreeMap 等。

示例：创建自定义类型的 Map

import cn.hutool.core.map.MapUtil;
import java.util.LinkedHashMap;
import java.util.Map;

public class MapUtilExample {
    public static void main(String[] args) {
        // 创建一个 LinkedHashMap 实例
        Map<String, String> linkedMap = MapUtil.createMap(LinkedHashMap.class);

        // 添加元素
        linkedMap.put("a", "value1");
        linkedMap.put("b", "value2");

        // 输出 Map 内容
        System.out.println("自定义类型的 Map: " + linkedMap);
    }
}

• 方法签名：<K, V> Map<K, V> createMap(Class<? extends Map> mapClass)
• 参数说明：
  • mapClass: 自定义的 Map 类型，如 LinkedHashMap.class。
• 返回值：Map<K, V>，返回创建的自定义类型的 Map 实例。
• 作用：用于创建自定义类型的 Map，适用于需要特定 Map 行为的场景。
• 实际开发场景：在需要保持元素顺序、进行排序等特殊需求时，可以使用此方法创建特定类型的 Map。

4. 将键值对加入 Map

通过 of 方法，可以快速将多个键值对加入到一个新建的 Map 中。

示例：将键值对加入 Map

import cn.hutool.core.map.MapUtil;
import java.util.Map;

public class MapUtilExample {
    public static void main(String[] args) {
        // 使用二维数组初始化 Map
        Map<Object, Object> colorMap = MapUtil.of(new String[][]{
            {"RED", "#FF0000"},
            {"GREEN", "#00FF00"},
            {"BLUE", "#0000FF"}
        });

        // 输出 Map 内容
        System.out.println("颜色 Map: " + colorMap);
    }
}

• 方法签名：Map<Object, Object> of(Object[][] array)
• 参数说明：
  • array: 包含键值对的二维数组。
• 返回值：Map<Object, Object>，返回包含指定键值对的 Map。
• 作用：用于快速初始化包含多个键值对的 Map，简化代码书写。
• 实际开发场景：在初始化配置项、颜色代码等固定数据时，可以使用此方法快速生成 Map。

5. 行转列：合并相同键的值为列表

通过 toListMap 方法，可以将 Map 列表中的相同键的值合并为列表，适用于需要按键聚合数据的场景。

示例：行转列操作

import cn.hutool.core.map.MapUtil;

import java.util.List;
import java.util.Map;

public class MapUtilExample {
    public static void main(String[] args) {
        // 初始化 Map 列表
        List<Map<String, Object>> list = List.of(
            MapUtil.of(new Object[][]{{"a", 1}, {"b", 1}, {"c", 1}}),
            MapUtil.of(new Object[][]{{"a", 2}, {"b", 2}}),
            MapUtil.of(new Object[][]{{"a", 3}, {"b", 3}}),
            MapUtil.of(new Object[][]{{"a", 4}})
        );

        // 行转列操作
        Map<String, List<Object>> resultMap = MapUtil.toListMap(list);

        // 输出结果
        System.out.println("行转列结果: " + resultMap);
    }
}

• 方法签名：Map<String, List<Object>> toListMap(Iterable<Map<String, ?>> maps)
• 参数说明：
  • maps: 包含多个 Map 的集合。
• 返回值：Map<String, List<Object>>，返回合并后的 Map。
• 作用：将多个 Map 的相同键的值合并为列表，适用于需要聚合数据的场景。
• 实际开发场景：在处理分布式数据、日志数据时，通常需要将相同键的数据聚合到一起。

6. 列转行：拆分列表值为多个 Map

通过 toMapList 方法，可以将 Map 中的值列表按其位置与键组成新的 Map，适用于将聚合数据还原为逐行数据的场景。

示例：列转行操作

import cn.hutool.core.map.MapUtil;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MapUtilExample {
    public static void main(String[] args) {
        // 初始化一个包含列转行的 Map
        Map<String, List<Object>> listMap = new HashMap<>();
        listMap.put("a", List.of(1, 2, 3, 4));
        listMap.put("b", List.of(1, 2, 3));
        listMap.put("c", List.of(1));

        // 列转行操作
        List<Map<String, Object>> resultList = MapUtil.toMapList(listMap);

        // 输出结果
        System.out.println("列转行结果: " + resultList);
    }
}

• 方法签名：List<Map<String, Object>> toMapList(Map<String, ? extends Iterable<?>> map)
• 参数说明：
  • map: 包含多个列表的 Map，列表中的值将被逐行拆分为多个 Map。
• 返回值：List<Map<String, Object>>，返回拆分后的 Map 列表。
• 作用：将包含列表值的 Map 转换为多个逐行形式的 Map，适用于还原数据的场景。
• 实际开发场景：在数据处理或数据导出时，通常需要将聚合数据还原为独立的记录。

7. 将 Map 转换为字符串

通过 join、joinIgnoreNull 和 sortJoin 方法，可以将 Map 按照指定的分隔符转换为字符串，常用于生成签名或构建请求参数。

示例：将 Map 转换为字符串

import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.StrUtil;

import java.util.HashMap;
import java.util.Map;

public class MapUtilExample {
    public static void main(String[] args) {
        // 初始化一个 Map
        Map<String, String> map = MapUtil.builder(new HashMap<String, String>())
            .put("key1", "value1")
            .put("key3", "value3")
            .put("key2", "value2")
            .build();

        // 使用 sortJoin 方法进行排序并连接
        String joinedString = MapUtil.sortJoin(map, StrUtil.EMPTY, StrUtil.EMPTY, false);
        System.out.println("排序后拼接的字符串: " + joinedString); // key1value1key2value2key3value3

        // 在拼接结果后附加自定义字符串
        String joinedWithSuffix = MapUtil.sortJoin(map, StrUtil.EMPTY, StrUtil.EMPTY, false, "123");
        System.out.println("附加字符串后的结果: " + joinedWithSuffix); // key1value1key2value2key3value3123
    }
}

• 方法签名：
  • String join(Map<?, ?> map, CharSequence separator, CharSequence keyValueSeparator)
  • String joinIgnoreNull(Map<?, ?> map, CharSequence separator, CharSequence keyValueSeparator)
  • String sortJoin(Map<?, ?> map, CharSequence separator, CharSequence keyValueSeparator, boolean isOrderByKey, CharSequence... suffix)
• 参数说明：
  • map: 需要转换的 Map。
  • separator: 键值对之间的分隔符。
  • keyValueSeparator: 键和值之间的分隔符。
  • isOrderByKey: 是否按照键排序。
  • suffix: 可选的附加字符串，用于在拼接结果后附加额外内容。
• 返回值：String，返回拼接后的字符串。
• 作用：将 Map 转换为指定格式的字符串，适用于生成签名、构建请求参数等场景。
• 实际开发场景：在支付签名、接口请求中，常需要将 Map 的内容按照特定规则拼接为字符串。

8. 筛选和修改 Map

通过 filter 方法可以筛选出符合条件的键值对，通过 map 方法可以根据指定规则修改 Map 的值。

示例：筛选和修改 Map

import cn.hutool.core.convert.Convert;
import cn.hutool.core.map.MapUtil;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

public class MapUtilExample {
    public static void main(String[] args) {
        // 初始化一个 Map
        Map<String, String> map = MapUtil.newHashMap();
        map.put("a", "1");
        map.put("b", "2");
        map.put("c", "3");
        map.put("d", "4");

        // 筛选出值为偶数的键值对
        Map<String, String> filteredMap = MapUtil.filter(map, (Entry<String, String> entry) -> Convert.toInt(entry.getValue()) % 2 == 0);
        System.out.println("筛选后的 Map: " + filteredMap); // {b=2, d=4}

        // 修改 Map 的值，在值后附加说明
        Map<String, String> mappedMap = MapUtil.map(map, (key, value) -> value + " - number");
        System.out.println("修改后的 Map: " + mappedMap); // {a=1 - number, b=2 - number, c=3 - number, d=4 - number}
    }
}

• 方法签名：
  • Map<K, V> filter(Map<K, V> map, Filter<Entry<K, V>> filter)
  • Map<K, V> map(Map<K, V> map, BiFunction<? super K, ? super V, ? extends V> mapper)
• 参数说明：
  • map: 需要筛选或修改的 Map。
  • filter: 筛选条件，返回 true 的键值对会保留。
  • mapper: 修改规则，用于生成新的值。
• 返回值：Map<K, V>，返回筛选或修改后的 Map。
• 作用：用于根据指定条件筛选或修改 Map 内容，适用于动态调整数据的场景。
• 实际开发场景：在数据清洗、过滤无效数据、生成自定义内容时，可以使用这些方法。

9. 键值互换

通过 reverse 方法，可以将 Map 的键和值进行互换操作。

示例：键值互换

import cn.hutool.core.map.MapUtil;

import java.util.Map;

public class MapUtilExample {
    public static void main(String[] args) {
        // 初始化一个 Map
        Map<String, String> map = MapUtil.newHashMap();
        map.put("a", "1");
        map.put("b", "2");
        map.put("c", "3");
        map.put("d", "4");

        // 键值互换
        Map<String, String> reversedMap = MapUtil.reverse(map);
        System.out.println("键值互换后的 Map: " + reversedMap); // {1=a, 2=b, 3=c, 4=d}
    }
}

• 方法签名：Map<V, K> reverse(Map<K, V> map)
• 参数说明：
  • map: 需要互换键值的 Map。
• 返回值：Map<V, K>，返回键值互换后的 Map。
• 作用：将 Map 的键和值进行互换，适用于需要根据值快速查找键的场景。
• 实际开发场景：在处理映射关系、需要逆向查找时，可以使用此方法。

10. 排序、获取部分键值对和其他操作

• sort: 排序 Map，支持按键或按值排序。
• getAny: 获取 Map 中部分键值对，返回一个新的 Map。
• get, getXXX: 获取 Map 中指定类型的值，简化类型转换操作。