AI与工作场景(三)收集ids与List转成Map

在工作场景中,我们往往需要把 Entity 实体的列表收集成 ids,然后再使用此 List<String> ids (雪花算法产生的id) 或List<Long> ids去得到相关联的数据。再关联Set值时,利用Map的key的Hash特性,可以快速定位。于是我们需要两个功能的通用方法。通用方法的目的是为了支持泛型。

  • 收集ids
  • 把 List 根据 id 转出 Map,实际可以根据某一个field 转成 key

今天我们的提示词:Jdk25(可以不需要,主要是我现在全部采用最新的方式)。

  • 提示词:Jdk25, List 收集 ids 的通用方法

    代码里面任何一种方法基本都可行。

    import java.util.*;
    import java.util.function.Function;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
    
    /**
     * JDK 25 专属 List 收集 IDs 通用工具类
     * 适配任意实体、任意ID类型,支持JDK 25特性优化
     */
    public class GenericIdCollector {
    
        // ==================== 1. 基础通用:收集可变ID列表(ArrayList) ====================
        /**
         * 基础提取ID,返回可变ArrayList(支持后续增删操作)
         * @param entityList 实体列表(可传入null)
         * @param idExtractor ID提取器(如 User::getId)
         * @param <T> 实体类型
         * @param <ID> ID类型
         * @return 可变ID列表(ArrayList)
         */
        public static <T, ID> List<ID> collectMutableIds(List<T> entityList, Function<T, ID> idExtractor) {
            // JDK 25 优化:Objects.isNull 性能提升,空列表直接返回空ArrayList
            if (Objects.isNull(entityList)) {
                return new ArrayList<>();
            }
            return entityList.stream()
                    .filter(Objects::nonNull) // 过滤null实体(JDK 8+,JDK 25兼容优化)
                    .map(idExtractor)
                    .collect(Collectors.toCollection(ArrayList::new)); // 明确返回可变ArrayList
        }
    
        // ==================== 2. 安全通用:过滤所有空值,避免NPE ====================
        /**
         * 安全提取ID(过滤null列表、null实体、null ID)
         * @param entityList 实体列表
         * @param idExtractor ID提取器
         * @param <T> 实体类型
         * @param <ID> ID类型
         * @return 非空ID可变列表
         */
        public static <T, ID> List<ID> collectSafeIds(List<T> entityList, Function<T, ID> idExtractor) {
            if (Objects.isNull(entityList)) {
                return new ArrayList<>();
            }
            return entityList.stream()
                    .filter(Objects::nonNull) // 过滤null实体
                    .map(idExtractor)
                    .filter(Objects::nonNull) // 过滤null ID
                    .collect(Collectors.toCollection(ArrayList::new));
        }
    
        // ==================== 3. 通用去重:收集唯一不重复ID ====================
        /**
         * 提取并去重ID(基于对象equals方法,支持任意可比较ID类型)
         * @param entityList 实体列表
         * @param idExtractor ID提取器
         * @param <T> 实体类型
         * @param <ID> ID类型
         * @return 唯一ID可变列表
         */
        public static <T, ID> List<ID> collectUniqueIds(List<T> entityList, Function<T, ID> idExtractor) {
            if (Objects.isNull(entityList)) {
                return new ArrayList<>();
            }
            return entityList.stream()
                    .filter(Objects::nonNull)
                    .map(idExtractor)
                    .filter(Objects::nonNull)
                    .distinct() // JDK 25 对distinct()的哈希计算有性能优化
                    .collect(Collectors.toCollection(ArrayList::new));
        }
    
        
        // ==================== 4. JDK 25 专属:收集不可变ID列表(性能最优) ====================
        /**
         * 提取ID到不可变List(JDK 16+ toList(),JDK 25 优化内存占用与访问速度)
         * 不可变列表:不支持add/remove等修改操作,线程安全
         * @param entityList 实体列表
         * @param idExtractor ID提取器
         * @param <T> 实体类型
         * @param <ID> ID类型
         * @return 不可变ID列表
         */
        public static <T, ID> List<ID> collectImmutableIds(List<T> entityList, Function<T, ID> idExtractor) {
            if (Objects.isNull(entityList)) {
                return List.of(); // JDK 25 对List.of()空列表返回单例,节省内存
            }
            // JDK 25 优化:stream.toList() 比 Collectors.toList() 更高效,返回不可变List
            return entityList.stream()
                    .filter(Objects::nonNull)
                    .map(idExtractor)
                    .filter(Objects::nonNull)
                    .toList();
        }
    
        // ==================== 5. JDK 25 专属:海量数据收集(虚拟线程优化) ====================
        /**
         * 海量实体列表提取ID(使用JDK 25 虚拟线程提升并行处理效率)
         * 适合十万级以上数据量,小数据量无需使用
         * @param entityList 海量实体列表
         * @param idExtractor ID提取器
         * @param <T> 实体类型
         * @param <ID> ID类型
         * @return 可变ID列表
         */
        public static <T, ID> List<ID> collectBatchIdsWithVirtualThread(List<T> entityList, Function<T, ID> idExtractor) {
            if (Objects.isNull(entityList) || entityList.isEmpty()) {
                return new ArrayList<>();
            }
            // JDK 25 虚拟线程:parallelStream 默认使用虚拟线程池,无需手动创建虚拟线程
            return entityList.parallelStream()
                    .filter(Objects::nonNull)
                    .map(idExtractor)
                    .filter(Objects::nonNull)
                    .collect(Collectors.toCollection(ArrayList::new));
        }
    }
    
  • 提示词:Jdk25,List 根据 field 转成 Map的key, value 为List元素本身的通用方法

    代码里面任何一种方法基本都可行。

    import java.util.*;
    import java.util.function.Function;
    import java.util.stream.Collectors;
    
    /**
     * JDK 25 专属:List转Map(字段为Key,实体本身为Value)通用工具类
     * 适配任意实体、任意Key字段,支持多场景映射
     */
    public class ListToEntityMapConverter {
        // ==================== 1. 去重通用:Key重复时自定义保留策略 ====================
        /**
         * 去重映射:Key重复时保留第一个/最后一个实体,避免抛异常
         * @param entityList 实体列表
         * @param keyExtractor Key字段提取器
         * @param keepFirst 是否保留第一个出现的实体(true=保留第一个,false=保留最后一个)
         * @param <T> 实体类型
         * @param <K> Map Key类型
         * @return 可变HashMap<K, T>
         */
        public static <T, K> Map<K, T> toEntityMapWithDuplicateHandle(
                List<T> entityList,
                Function<T, K> keyExtractor,
                boolean keepFirst
        ) {
            if (Objects.isNull(entityList) || entityList.isEmpty()) {
                return new HashMap<>();
            }
            return entityList.stream()
                    .filter(Objects::nonNull)
                    .collect(Collectors.toMap(
                            keyExtractor,
                            entity -> entity,
                            // 冲突解决:保留第一个/最后一个实体
                            (existingEntity, newEntity) -> keepFirst ? existingEntity : newEntity,
                            HashMap::new
                    ));
        }
    
        // ==================== 2. 安全通用:过滤所有空值(避免NPE和无效Key) ====================
        /**
         * 安全映射:过滤null实体、null Key,避免空指针和无效映射
         * @param entityList 实体列表
         * @param keyExtractor Key字段提取器
         * @param <T> 实体类型
         * @param <K> Map Key类型
         * @return 可变HashMap<K, T>
         */
        public static <T, K> Map<K, T> toSafeEntityMap(
                List<T> entityList,
                Function<T, K> keyExtractor
        ) {
            if (Objects.isNull(entityList) || entityList.isEmpty()) {
                return new HashMap<>();
            }
            return entityList.stream()
                    .filter(Objects::nonNull) // 过滤null实体
                    .filter(entity -> Objects.nonNull(keyExtractor.apply(entity))) // 过滤null Key
                    .collect(Collectors.toMap(
                            keyExtractor,
                            entity -> entity,
                            (existingEntity, newEntity) -> newEntity, // 重复Key默认保留最后一个
                            HashMap::new
                    ));
        }
    
        
        // ==================== 3. 通用一对多:Key重复时收集多个实体(Map<K, List<T>>) ====================
        /**
         * 一对多映射:Key重复时,将多个实体收集到List中作为Value
         * @param entityList 实体列表
         * @param keyExtractor Key字段提取器
         * @param <T> 实体类型
         * @param <K> Map Key类型
         * @return 可变HashMap<K, List<T>>
         */
        public static <T, K> Map<K, List<T>> toMultiEntityMap(
                List<T> entityList,
                Function<T, K> keyExtractor
        ) {
            if (Objects.isNull(entityList) || entityList.isEmpty()) {
                return new HashMap<>();
            }
            // JDK 25 对Collectors.groupingBy()底层算法优化,大数据量更高效
            return entityList.stream()
                    .filter(Objects::nonNull)
                    .collect(Collectors.groupingBy(
                            keyExtractor,
                            HashMap::new, // 明确返回可变HashMap
                            Collectors.toCollection(ArrayList::new) // 实体收集为可变ArrayList
                    ));
        }
    
        // ==================== 4. JDK 25 专属:海量数据转Map(虚拟线程优化) ====================
        /**
         * 海量实体映射:使用JDK 25 虚拟线程提升并行处理效率(适合十万级以上数据)
         * @param entityList 海量实体列表
         * @param keyExtractor Key字段提取器
         * @param <T> 实体类型
         * @param <K> Map Key类型
         * @return 可变HashMap<K, T>
         */
        public static <T, K> Map<K, T> toEntityMapWithVirtualThread(
                List<T> entityList,
                Function<T, K> keyExtractor
        ) {
            if (Objects.isNull(entityList) || entityList.isEmpty()) {
                return new HashMap<>();
            }
            // JDK 25 虚拟线程:parallelStream 默认使用虚拟线程池,轻量无资源耗尽风险
            return entityList.parallelStream()
                    .filter(Objects::nonNull)
                    .collect(Collectors.toMap(
                            keyExtractor,
                            entity -> entity,
                            (existingEntity, newEntity) -> newEntity, // 重复Key保留最后一个
                            HashMap::new
                    ));
        }
    }
    
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值