如何对比两个对象并找出变更属性？求Java通用实现方案

嘿，我懂你现在的困扰——你需要一个能找出两个对象（包括嵌套复杂类型）中属性变更的通用方法，而且不能依赖重写equals()/hashCode()。你的当前代码只能处理Student的直接字段，遇到Address这种嵌套对象就没法深入检查内部属性了对吧？

问题根源 #

你的现有代码只遍历了Student的直接字段，对于引用类型（比如Address），直接调用equals()会比较对象的内存引用，而不是它们的属性内容。哪怕两个Address实例的属性只有一个不同，只要是不同的对象，equals()就会返回false，但我们需要的是精准定位到具体变更的嵌套属性。

解决方案：递归遍历+属性路径追踪 #

我们可以写一个通用的递归方法，自动处理所有字段（包括嵌套对象的字段），同时构建完整的属性路径（比如Student.address.hno）。下面是完整实现：

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

class Student {
    public String name;
    public Address address;
    public int age;
}

class Address {
    public String hno;
    public String street;
    public int pin;
}

public class Test {
    public static void main(String... arg) throws IllegalAccessException {
        Student s1 = new Student();
        s1.name = "Krishna";
        s1.age = 30;
        s1.address = new Address();
        s1.address.hno = "2-2-22";
        s1.address.street = "somewhere";
        s1.address.pin = 123;

        Student s2 = new Student();
        s2.name = "Krishna";
        s2.age = 20;
        s2.address = new Address();
        s2.address.hno = "1-1-11";
        s2.address.street = "nowhere";
        s2.address.pin = 123;

        List<String> differences = findDifferences(s1, s2);
        // 输出预期结果：[Student.age, Student.address.hno, Student.address.street]
        System.out.println(differences);
    }

    private static List<String> findDifferences(Object obj1, Object obj2) throws IllegalAccessException {
        return findDifferences(obj1, obj2, obj1.getClass().getSimpleName());
    }

    private static List<String> findDifferences(Object obj1, Object obj2, String currentPath) throws IllegalAccessException {
        List<String> differences = new ArrayList<>();

        // 如果两个对象类型不一致，直接返回（根据需求可调整逻辑）
        if (obj1.getClass() != obj2.getClass()) {
            differences.add(currentPath + ": 类型不一致");
            return differences;
        }

        Class<?> clazz = obj1.getClass();
        // 获取所有字段（包括私有字段，需设置可访问）
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true); // 允许访问私有字段
            Object value1 = field.get(obj1);
            Object value2 = field.get(obj2);

            String fieldPath = currentPath + "." + field.getName();

            // 处理null情况
            if (value1 == null && value2 != null) {
                differences.add(fieldPath);
                continue;
            }
            if (value1 != null && value2 == null) {
                differences.add(fieldPath);
                continue;
            }
            if (value1 == null && value2 == null) {
                continue; // 都为null，无变更
            }

            // 判断是否为基本类型、包装类或String
            if (isBasicTypeOrWrapper(value1.getClass()) || value1 instanceof String) {
                if (!value1.equals(value2)) {
                    differences.add(fieldPath);
                }
            } else {
                // 递归处理嵌套对象
                List<String> nestedDifferences = findDifferences(value1, value2, fieldPath);
                differences.addAll(nestedDifferences);
            }
        }

        return differences;
    }

    // 判断是否为基本类型或其包装类
    private static boolean isBasicTypeOrWrapper(Class<?> clazz) {
        return clazz.isPrimitive()
                || clazz == Integer.class
                || clazz == Long.class
                || clazz == Double.class
                || clazz == Float.class
                || clazz == Boolean.class
                || clazz == Byte.class
                || clazz == Short.class
                || clazz == Character.class;
    }
}

关键细节说明 #

1. 递归遍历：对于非基本/非String的引用类型，递归调用findDifferences方法，深入检查嵌套对象的属性。
2. 属性路径构建：每次递归都会把当前字段名追加到路径前缀中，最终得到完整的属性路径（比如Student.address.street）。
3. null处理：单独判断字段值为null的情况，避免空指针异常，同时识别“从null变为非null”或“从非null变为null”的变更。
4. 访问私有字段：通过field.setAccessible(true)可以处理私有字段，让方法更通用（你的例子里是public字段，但实际项目中私有字段更常见）。
5. 类型一致性检查：如果两个对象类型不同，直接标记为变更（可根据需求调整逻辑）。

注意事项 #

• 循环引用：如果对象之间存在循环引用（比如Student包含Address，Address又包含Student），递归会导致栈溢出。可以添加一个Set<Object>参数记录已处理的对象，避免重复递归。
• 集合类型：当前代码未处理集合（比如List、Map），如果需要支持集合，可以扩展逻辑，遍历集合元素进行比较。
• 性能：反射操作有一定性能开销，如果是高频调用场景，可以考虑缓存字段信息。

运行上面的测试代码，你会得到预期的结果：[Student.age, Student.address.hno, Student.address.street]，完美符合需求。

内容的提问来源于stack exchange，提问作者Krishna Chaitanya