Map工具类

import java.io.*;
import java.util.*;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;

/**
 * Description：Map的工具类
 *
 * @author sswh
 * @since 2023/2/16
 */
public class MapUtils {

    /**
     * 利用序列化实现 HashMap 的深克隆
     *
     * @param source 源HashMap
     * @return 克隆后的HashMap
     */
    public static <K, V> Map<K, V> clone(Map<K, V> source) {
        try {
            // 通过序列化和反序列化实现深克隆
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            objectOutputStream.writeObject(source);
            objectOutputStream.close();

            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
            ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
            @SuppressWarnings("unchecked")
            HashMap<K, V> cloned = (HashMap<K, V>) objectInputStream.readObject();
            objectInputStream.close();

            return cloned;
        } catch (IOException | ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 对Map的values集合进行排序，并且返回values对应的List对象
     *
     * @param map        需要排序的Map集合
     * @param comparator 排序器
     * @param <K>        Map的键类型
     * @param <V>        Map的值类型
     * @return 排序后的values集合
     */
    public static <K, V> List<V> sortMapValues(Map<K, V> map, Comparator<V> comparator) {
        List<V> valuesList = new ArrayList<>(map.values());
        valuesList.sort(comparator);
        return valuesList;
    }

    /**
     * Map拆分 (指定分组大小)
     *
     * @param map  Map
     * @param size 每个分组的大小 (>=1)
     * @param <K>  Key
     * @param <V>  Value
     * @return 子Map列表
     */
    public static <K, V> List<Map<K, V>> partition(Map<K, V> map, int size) {
        if (Objects.isNull(map) || map.isEmpty() || size < 1) {
            //空map或者分组大小<1，无法拆分
            return Collections.emptyList();
        }

        int mapSize = map.size(); //键值对总数
        int groupSize = mapSize / size + (mapSize % size == 0 ? 0 : 1); //计算分组个数
        List<Map<K, V>> list = Lists.newArrayListWithCapacity(groupSize); //子Map列表

        if (size >= mapSize) { //只能分1组的情况
            list.add(map);
            return list;
        }

        int count = 0; //每个分组的组内计数
        Map<K, V> subMap = Maps.newHashMapWithExpectedSize(size); //子Map

        for (Map.Entry<K, V> entry : map.entrySet()) {
            if (count < size) {
                //给每个分组放chunkSize个键值对，最后一个分组可能会装不满
                subMap.put(entry.getKey(), entry.getValue());
                count++; //组内计数+1
            } else {
                //结束上一个分组
                list.add(subMap); //当前分组装满了->加入列表

                //开始下一个分组
                subMap = Maps.newHashMapWithExpectedSize(size); //新的分组
                subMap.put(entry.getKey(), entry.getValue()); //添加当前键值对
                count = 1; //组内计数重置为1
            }
        }

        list.add(subMap);  //添加最后一个分组
        return list;
    }

}