开发者

Java反射实现多属性去重与分组功能

目录
  • 一、开发环境与基础组件准备
    • 1.环境配置:
    • 2. 代码结构说明:
  • 二、基础反射工具:BeanUtils 的设计与实现
    • 1. 用户实体类:User.Java
    • 2. 反射工具类:BeanUtils 的核心能力
  • 三、基于反射的 List 集合去重:原理与实现
    • 1. 核心工具类:CollectionUtils 的去重逻辑
    • 2 功能测试与结果分析
  • 四、基于反射的 List 集合分组:场景与实现
    • 1. 分组工具方法:propertyGroupMap 的设计
    • 2. 应用场景测试
  • 五、总结

    一、开发环境与基础组件准备

    1.环境配置:

    • IDE:IntelliJ IDEA
    • JDK 版本:1.8
    • 核心组件:自定义工具类库(common模块)

    2. 代码结构说明:

    com.pearl.common/
    ├─ entity/        # 实体类模块
    │  └─ User.java   # 用户实体定义
    └─ spring/        # 工具类模块
       └─ BeanUtils.java # 反射工具类
    

    二、基础反射工具:BeanUtils 的设计与实现

    1. 用户实体类:User.java

    package com.pearl.common.entity;
    
    /**
     * 业务实体:用户信息模型
     * @author yyb
     * @since 2025/05/06
     * @apiNote 包含基础属性及Java Bean规范的访问器方法
     */
    public class User {
    
        /**
         * id
         */
        private String id;
        /**
         * 姓名
         */
        private String name;
        /**
         * 年龄
         */
        private Integer age;
    
        public String getId() {
            return id;
        }
    
        public void setId(String id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public User(String id, String name, Integer age) {
            this.id = id;
            this.name = name;
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id='" + id + ''' +
                    ", name='" + name + ''' +
                    ", age=" + age +
                    '}';
        }
    }
    
    

    2. 反射工具类:BeanUtils 的核心能力

    package com.pearl.common.spring;
    
    import com.pearl.common.entity.User;
    import java.lang.reflect.InvocationTargetException;
    
    /**
     * Bean对象反射操作工具类
     * @author yyb
     * @since 2025/05/06
     * @apiNote 提供基于方法名反射的属性值获取能力
     */
    public class BeanUtils {
        private static final String GET_PREFIX = "get";  // getter方法前缀
        private static final String SET_PREFIX = "set";  // setter方法前缀
    
        /**
         * 通过反射调用对象的Getter方法获取属性值
         * @param target 对象实例
         * @param fieldName 目标字段名(驼峰命名,如"userName")
         * @param <T> 泛型约束(需为Java Bean规范类)
         * @return 字段值字符串表示,异常时返回空字符串
         * @throws SecurityException 反射权限异常
         * @example 获取user对象的name属性:getMethodValue(user, "name")
         */
        public static <T> String getMethodValue(T target, String fieldName) {
            String methodName = GET_PREFIX + 
                fieldName.substring(0, 1).toUpperCase() + 
                fieldName.substring(1);  // 拼接方法名(如"getName")
            
            try {
                // 反射调用方法并转换为字符串
                return String.valueOf(target.getClass()
                    .getMethod(methodName)
                    .invoke(target));
            } catch (NoSuchMethodException | IllegalAccessException | 
                     Inv编程客栈ocationTargetException e) {
                e.printStackTrace();  // 生产环境建议日志记录
                return "";
            }
        }
    
        // main方法测试
        public static void main(Str编程客栈ing[] args) {
            //根据对象和字段名称获取get方法返回值
            User user = new User("1", "张三", 18);
            String nameVale = getMethodValue(user, "name");
            System.out.printf("name:" + nameVale);
    
        }
    }
    

    三、基于反射的 List 集合去重:原理与实现

    1. 核心工具类:CollectionUtils 的去重逻辑

    package com.pearl.common.util;
    
    import com.pearl.common.spring.BeanUtils;
    import java.util.*;
    import java.util.stream.Collectors;
    
    /**
     * 集合操作工具类
     * @author yyb
     * @since 2025/05/06
     * @apiNote 提供基于反射的复杂去重与分组功能
     */
    public class CollectionUtils {
        private static final String SEPARATOR = ",";  // 默认分隔符
    
        /**
         * 多属性组合去重:基于TreeSet的自然排序特性
         * @param sourceList 原始集合(支持nulpythonl,但返回空集合)
         * @param fieldNames 参与去重的属性名数组(如["name", "age"])
         * @param <T> 泛型约束(需为Java Bean规范类)
         * @return 去重后的ArrayList集合,保留首次出现的元素
         * @implNote 通过拼接属性值为唯一标识,利用TreeSet的唯一性实现去重
         */
        public static <T> List<T> listDistinct(List<T> sourceList, String... fieldNames) {
            if (sourceList == null || sourceList.isEmpty()) {
                return new ArrayList<>();  // 防御性编程:空集合返回空列表
            }
    
            return sourceList.stream()
                .collect(Collectors.collectingAndThen(
                    Collectors.toCollection(() -> new TreeSet<>(
                        Comparator.comparing(o -> buildKey(o, fieldNames, SEPARATOR))
                    )), 
                    ArrayList::new
                ));
        }
    
        // 辅助方法:拼接属性值为唯一键
        private static <T> String buildKey(T object, String[] fields, String separator) {
            StringBuilder keyBuilder = new StringBuilder();
            for (String field : fields) {
                keyBuilder.append(BeanUtils.getMethodValue(object, field))
                          .append(separator);
            }编程客栈
            // 移除末尾多余分隔符(如"name,age,"处理为"name,age")
            return keyBuilder.length() > 0 ? 
                keyBuilder.deleteCharAt(keyBuilder.length() - 1).toString() : 
                "";
        }
    }
    

    2 功能测试与结果分析

    测试用例设计

    public class CollectionTest {
        public static void main(String[] args) {
            // 构造测试数据(包含重复属性组合)
            List<User> userList = Arrays.asList(
                new User("1", "张三", 18),
                new User("3", "李四", 18),
                new User("5", "王五", 18),
                new User("2", "张三", 20),  // 与第一个用户name重复,但age不同
                new User("4", "李四", 18)   // 与第二个用户name+age均重复
            );
    
            // 单属性去重(按姓名)
            List<User> singleDistinct = CollectionUtils.listDistinct(userList, "name");
            System.out.println("单属性去重(name)结果:" + singleDistinct);
            // 输出:[User{id='1', name='张三', age=18}, User{id='3', name='李四', age=18}, User{id='5', name='王五', age=18}]
    
            // 多属性去重(按name+age)
            List<User> multiDistinct = CollectionUtils.listDistinct(userList, "name", "age");
            System.out.println("多属性去重(name+age)结果:" + multiDistinct);
            // 输出:[User{id='1', name='张三', age=18}, User{id='3', name='李四', age=18}, User{id='2', name='张三', age=20}, User{id='5', name='王五', age=18}]
        }
    }
    

    去重原理解析

    • 单属性去重:将每个对象的目标属性值(如name)作为唯一标识,相同值的对象仅保留第一个。
    • 多属性去重:通过SEPARATOR拼接多个属性值(如"张三,18"),形成复合唯一键,确保只有属性组合完全相同的对象才会被去重。
    • 性能优化点:使用TreeSet结合自定义比较器,利用其内部红黑树结构实现 O (n log n) 时间复杂度的去重,优于传统双重循环的 O (n²) 复杂度。

    四、基于反射的 List 集合分组:场景与实现

    1. 分组工具方法:propertyGroupMap 的设计

    public statphpic <T> Map<String, List<T>> propertyGroupMap(
        List<T> sourceList, 
        String separator, 
        String... fieldNames) {
    
        Map<String, List<T>> groupMap = new HashMap<>();
        if (sourceList == null || sourceList.isEmpty()) {
            return groupMap;
        }
    
        for (T item : sourceList) {
            // 构建分组键(支持自定义分隔符,如"name-age")
            String groupKey = buildKey(item, fieldNames, separator);
            
            // 分组逻辑:同一键对应列表添加元素
            groupMap.computeIfAbsent(groupKey, k -> new ArrayList<>())
                    .add(item);
        }
        return groupMap;
    }
    

    2. 应用场景测试

    场景 1:单属性分组(按姓名统计用户)

    Map<String, List<User>> nameGroup = 
        CollectionUtils.propertyGroupMap(userList, "", "name");
    
    // 输出结果:
    // {
    //   张三=[User{id='1', name='张三', age=18}, User{id='2', name='张三', age=20}],
    //   李四=[User{id='3', name='李四', age=18}, User{id='4', name='李四', age=18}],
    //   王五=[User{id='5', name='王五', age=18}]
    // }
    

    场景 2:多属性分组(按姓名 + 年龄分类)

    Map<String, List<User>> nameAgeGroup = 
        CollectionUtils.propertyGroupMap(userList, "-", "name", "age");
    
    // 输出结果:
    // {
    //   张三-18=[User{id='1', name='张三', age=18}],
    //   李四-18=[User{id='3', name='李四', age=18}, User{id='4', name='李四', age=18}],
    //   张三-20=[User{id='2', name='张三', age=20}],
    //   王五-18=[User{id='5', name='王五', age=18}]
    // }
    

    分组优势分析

    • 动态扩展性:通过可变参数fieldNames支持任意属性组合,无需为不同实体类编写重复分组代码。
    • 分隔符灵活性:通过separator参数可自定义键格式(如",""-"),适配不同业务场景的键存储需求。
    • 性能表现:基于 HashMap 的单次遍历分组,时间复杂度为 O (n),适用于大规模数据集。

    五、总结

    通过BeanUtilsCollectionUtils的组合,实现了基于反射的 Java 集合动态去重与分组功能,显著提升了代码的通用性和可维护性。实际开发中,可进一步结合 Spring 框架的BeanWrapper或 MapStruct 工具,优化反射操作的性能与可读性。

    以上就是Java反射实现多属性去重与分组功能的详细内容,更多关于Java多属性去重与分组的资料请关注编程客栈(www.devze.com)其它相关文章!

    0

    上一篇:

    下一篇:

    精彩评论

    暂无评论...
    验证码 换一张
    取 消

    最新开发

    开发排行榜