【Java】通过 getter 方法引用，来比较两个对象是否相等

已于 2022-04-10 10:38:53 修改
阅读量3k 收藏 2
点赞数
分类专栏： Java 文章标签： java
于 2022-04-09 19:58:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ly1414725328/article/details/124066266
版权
背景

编写代码时，会经常需要编写两个对象是否相等的逻辑，一般会有如下做法

  1. 直接写在业务代码中；
  2. 单独写个方法，业务代码中调用；
  3. 重写 equals 方法；

上面这些做法，都比较复杂，如果属性太多或复杂点（如果是 list 和 map 就更复杂了），就需要编写更多的判断逻辑代码了。

想法

如果能只需要提供比较的方法引用列表，有个地方能自动方法引用取值，并比较就好了。

思路 1
  1. 在 java8 中可以使用方法引用，如：People::getName；
  2. 可以将所有要比较的 Getter 保存到列表中；
  3. 在 比较的时候，根据 方法引用获取具体的值进行比较；
  4. 全部比较都相等了，就认为是相等的。
思路 2
  1. 思路 1 适用于需要比较的字段少时，有一种情况是，需要比较的字段多，只想排除掉少量字段
  2. 通过注解来忽略指定的字段
  3. 获取全部字段，过滤掉忽略的字段，通过反射比较字段对应的值。
举个例子 1(改造前)
@Getter
@Setter
public class EqualDemo implements Equable {

    private Integer id;
    private Integer age;
    private String username;
    private Date createTime;
    private Date updateTime;
    private List<EqualDemo> list;
    private Map<String, EqualDemo> map;

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof EqualDemo) {
            if (!Objects.equals(((EqualDemo) obj).getId(), this.getId())) {
                return false;
            }

            if (!Objects.equals(((EqualDemo) obj).getAge(), this.getAge())) {
                return false;
            }

            if (!Objects.equals(((EqualDemo) obj).getUsername(), this.getUsername())) {
                return false;
            }
            final List<EqualDemo> list1 = ((EqualDemo) obj).getList();
            final List<EqualDemo> list2 = this.getList();
            // todo 比较 list1 和 list2

            final Map<String, EqualDemo> map1 = ((EqualDemo) obj).getMap();
            final Map<String, EqualDemo> map2 = this.getMap();
            // todo 比较 map1 和 map2


            return true;
        }
        return Objects.equals(this, obj);
    }
}

// 使用
public class EqualDemoTest {
    @Test
    public void testSimpleTrue() {
        final EqualDemo s1 = new EqualDemo();
        s1.setId(1);
        s1.setUsername("bob");

        final EqualDemo s2 = new EqualDemo();
        s2.setId(1);
        s2.setUsername("bob");

        // // s1 和 s2 相等
        assert s1.equals(s2);
    }
}
举个例子 2(改造后-指定需要比较的字段的 Getter 方法引用)
@Getter
@Setter
public class OnlyEqualDemo implements Equable {

    private Integer id;

    private Integer age;

    private String username;
    private Date createTime;
    private Date updateTime;
    private List<OnlyEqualDemo> list;
    private Map<String, OnlyEqualDemo> map;


    @SuppressWarnings("unchecked")
    @Override
    public List<EqualGetter<OnlyEqualDemo>> listOnlyEqualsToGetter() {
        final EqualGetter<OnlyEqualDemo> getId = OnlyEqualDemo::getId;
        return Arrays.asList(
                getId,
                OnlyEqualDemo::getAge,
                OnlyEqualDemo::getUsername,
                OnlyEqualDemo::getList,
                OnlyEqualDemo::getMap
        );
    }
}


// 使用
public class OnlyEqualDemoTest {


    @Test
    public void testSimpleTrue() {
        final OnlyEqualDemo s1 = new OnlyEqualDemo();
        s1.setId(1);
        s1.setUsername("bob");

        final OnlyEqualDemo s2 = new OnlyEqualDemo();
        s2.setId(1);
        s2.setUsername("bob");

        // // s1 和 s2 相等
        assert s1.onlyEqualsTo(s2);
    }
}
举个例子 3(改造后-排除少量字段)
@Getter
@Setter
public class IgnoreEqualDemo implements Equable {

    private Integer id;

    @EqualIgnored
    private Integer age;

    private String username;

    @EqualIgnored
    private Date createTime;

    @EqualIgnored
    private Date updateTime;

    private List<IgnoreEqualDemo> list;
    private Map<String, IgnoreEqualDemo> map;
}

// 使用
public class IgnoreEqualDemoTest {


    @Test
    public void testSimpleTrue() {
        final IgnoreEqualDemo s1 = new IgnoreEqualDemo();
        s1.setId(1);
        s1.setUsername("bob");
        s1.setCreateTime(new Date());

        final IgnoreEqualDemo s2 = new IgnoreEqualDemo();
        s2.setId(1);
        s2.setUsername("bob");

        // // s1 和 s2 相等
        assert s1.ignoreEqualsTo(s2);
    }
}

这样就简洁很多了，由于 ignoreEqualsTo 和 onlyEqualsTo 方法是 Equable 接口中的默认方法，具体逻辑全封装起来了（包括 object, collection 和 map 的处理），不需要重写就可以直接使用，具体实现看下面的源码。

源码

import lombok.SneakyThrows;

import java.beans.PropertyDescriptor;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.*;
import java.util.function.BiFunction;
import java.util.stream.Collectors;

/**
 * 比较两个对象是否相等
 *
 * @author lilou
 * @date 2022/4/9 9:30
 * <p>
 * @see Equable#onlyEqualsTo(Equable) 方法1：通过 Getter方法引用 来指定需要比较的字段（场景：字段总量多，但是只需要比较少量字段时）
 * @see Equable#ignoreEqualsTo(Equable) 方法2：通过忽略注解({@code EqualIgnored})来指定忽略比较的字段，未标识的字段会全部参与比较（场景：字段总量多，但是只需要排除少量字段时）
 * 注意：onlyEqualsTo 和 ignoreEqualsTo 不要混用
 */
public interface Equable extends Serializable {
    long serialVersionUID = 1L;

    /**
     * 使用方法引用来比较，只比较指定的 Getter 方法引用。
     * 使用此方法：重写 listOnlyEqualsToGetter 方法，指定需要比较的字段的Getter方法引用
     *
     * @param other 另一个 model
     * @return 结果
     */
    default boolean onlyEqualsTo(Equable other) {
        final List<EqualGetter<Equable>> getterList = listOnlyEqualsToGetter();

        // getter方法引用列表中没有需要比较的 getter，直接比较对象
        if (getterList == null || getterList.isEmpty()) {
            return Objects.equals(other, this);
        }

        // 列表有值，计算两个对象在列表中 getter 值，并比较是否相等
        for (EqualGetter<Equable> equalGetter : getterList) {
            Object o1 = equalGetter.apply(this);
            Object o2 = equalGetter.apply(other);

            // 对于属性中也有实现了 Equable 接口的，递归调用
            if (o1 instanceof Equable && o2 instanceof Equable) return ((Equable) o1).onlyEqualsTo((Equable) o2);

            // equalTo collection
            if (o1 instanceof Collection && o2 instanceof Collection) {
                // 判断不相等
                if (notEqualsCollection((Collection<?>) o1, (Collection<?>) o2, Equable::onlyEqualsTo)) return false;

                // 列表已经判断完了，开始下一个属性
                continue;
            }

            // equalTo map
            if (o1 instanceof Map && o2 instanceof Map) {
                if (notEqualsMap((Map<?, ?>) o1, (Map<?, ?>) o2, Equable::onlyEqualsTo)) return false;
                // 列表已经判断完了，开始下一个属性
                continue;
            }

            if (!Objects.equals(o1, o2)) {
                return false;
            }
        }
        return true;
    }

    default boolean notEqualsMap(Map<?, ?> o1, Map<?, ?> o2, BiFunction<Equable, Equable, Boolean> biFunc) {
        // 比较 key
        final Collection<?> set1 = o1.keySet();
        final Collection<?> set2 = o2.keySet();
        if (notEqualsCollection(set1, set2, biFunc)) return true;

        // 比较 value
        final Collection<?> values1 = o1.values();
        final Collection<?> values2 = o2.values();
        return notEqualsCollection(values1, values2, biFunc);
    }

    /**
     * 判断 collection 是否不相等
     *
     * @param o1 第一个 collection
     * @param o2 第二个 collection
     * @return 是否不相等
     */
    default boolean notEqualsCollection(Collection<?> o1, Collection<?> o2, BiFunction<Equable, Equable, Boolean> biFunc) {
        if (Objects.isNull(o1) && Objects.isNull(o2)) {
            return false;
        }

        if (Objects.isNull(o1) || Objects.isNull(o2)) {
            return true;
        }

        if (o1.isEmpty() && o2.isEmpty()) {
            return false;
        }

        if (o1.size() != o2.size()) {
            return true;
        }

        // 根据 hashCode 来排序
        o1 = o1.stream().sorted(Comparator.comparingInt(Object::hashCode)).collect(Collectors.toList());
        o2 = o2.stream().sorted(Comparator.comparingInt(Object::hashCode)).collect(Collectors.toList());


        // 逐个比较
        final Iterator<?> iterator1 = o1.iterator();
        final Iterator<?> iterator2 = o2.iterator();
        while (iterator1.hasNext() && iterator2.hasNext()) {
            final Object next1 = iterator1.next();
            final Object next2 = iterator2.next();
            if (next1 instanceof Equable && next2 instanceof Equable) {
                if (!biFunc.apply((Equable) next1, (Equable) next2)) {
                    return true;
                }
            } else {
                return !Objects.equals(next1, next2);
            }
        }
        return false;
    }

    /**
     * 需重写
     * <p>
     * 需要比较的 Getter 方法列表（原理是通过Getter 的 apply 方法得到实际的值，再进行比较）
     *
     * @param <T> 泛型
     * @return getter 方法列表
     */
    default <T extends Equable> List<EqualGetter<T>> listOnlyEqualsToGetter() {
        return Collections.emptyList();
    }

    /**
     * getter方法接口定义
     */
    @FunctionalInterface
    interface EqualGetter<T extends Equable> extends Serializable {
        Object apply(T source);
    }


    /**
     * IgnoreEqual 注解+反射来实现 equal 逻辑
     *
     * @param other 另一个 model
     * @return 结果
     */
    @SneakyThrows
    default boolean ignoreEqualsTo(Equable other) {
        if (Objects.equals(this, other)) {
            return true;
        }

        final Class<? extends Equable> aClass1 = this.getClass();
        final Class<? extends Equable> aClass2 = other.getClass();
        if (!Objects.equals(aClass1, aClass2)) {
            return false;
        }

        final Field[] declaredFields = aClass1.getDeclaredFields();
        for (Field declaredField : declaredFields) {

            // 字段是否被标记忽略
            final EqualIgnored isIgnored = declaredField.getAnnotation(EqualIgnored.class);
            if (Objects.nonNull(isIgnored)) {
                continue;
            }

            final PropertyDescriptor propertyDescriptor = new PropertyDescriptor(declaredField.getName(), aClass1);
            final Method readMethod = propertyDescriptor.getReadMethod();

            final Object o1 = readMethod.invoke(this);
            final Object o2 = readMethod.invoke(other);

            // 对于属性中也有实现了 Equable 接口的，递归调用
            if (o1 instanceof Equable && o2 instanceof Equable) return ((Equable) o1).ignoreEqualsTo((Equable) o2);

            // equalTo collection
            if (o1 instanceof Collection && o2 instanceof Collection) {
                // 判断不相等
                if (notEqualsCollection((Collection<?>) o1, (Collection<?>) o2, Equable::ignoreEqualsTo)) return false;

                // 列表已经判断完了，开始下一个属性
                continue;
            }

            // equalTo map
            if (o1 instanceof Map && o2 instanceof Map) {

                if (notEqualsMap((Map<?, ?>) o1, (Map<?, ?>) o2, Equable::ignoreEqualsTo)) return false;

                // 列表已经判断完了，开始下一个属性
                continue;
            }

            if (!Objects.equals(o1, o2)) {
                return false;
            }
        }

        return true;
    }

}


@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface EqualIgnored {
}
单元测试

方法 1：

https://github.com/lyloou/component/blob/master/component-dto/src/test/java/com/lyloou/component/dto/OnlyEqualDemoTest.java
Equable_20220410103323_2022-04-10-10-33-24

方法 2：

https://github.com/lyloou/component/blob/master/component-dto/src/test/java/com/lyloou/component/dto/IgnoreEqualDemoTest.java
Equable_20220410103408_2022-04-10-10-34-09

参考资源

  • https://github.com/lyloou/component/blob/master/component-dto/src/main/java/com/lyloou/component/dto/Equable.java
  • https://github.com/lyloou/component/blob/master/component-dto/src/main/java/com/lyloou/component/dto/field/FieldUtil.java
lyloou
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java实现List中对象排序的方法
09-03
比较器是一个接口，定义了比较两个对象的逻辑。在这个例子中，我们要根据`hits`属性的值进行排序，所以需要提供一个自定义的`Comparator<News>`实现： ```java Collections.sort(list, new Comparator() { @...
Java对象的比较方式.doc
10-10
`Comparator`接口位于`java.util`包中，它提供了一个`compare(T o1, T o2)`方法，用于比较两个对象。`Comparator`的优势在于它可以在运行时动态地创建和改变比较规则，而不必修改类的源代码。例如，我们可以创建一个...
判断两个引用对象相等的通用方法(除内存地址外，其余均相同即为相等)
Soap_Leutenant的博客
07-10 1346
判断两个引用对象相等的通用方法(除内存地址外，其余均相同即为相等)问题：两个对象：        Student stu1 = new Student（1，“s1”）;    Student stu 2= new Student（1，“s1”）;如果用Object的equal（）方法判断是否相等，stu1 ！= stu2的。如何希望stu1和stu2相等呢？其实很多时候我们并不想考虑他们内存的问题...
关于Java多态的一个疑问：setter和getter方法
ZYQ_JP的博客
08-20 205
Java中的setter和getter貌似不简单。
JAVA 基本布尔类型的Getter方法
七七的博客
01-22 975
基本布尔类型的Getter方法 对于所有的数据类型，Getter都必须叫getXxx，Setter都必须叫setXxx，但是有一个特例: 如果基本数据类型当中的boolean值，那么setXxx规则不变，而getXxx需要写成isXxx的形式 public class Person { private String name; //姓名 private int age;//年龄 priv...
java中getter和setter方法的使用
热门推荐
柠檬精
11-18 1万+
使用了private对属性进行了封装，要访问私有属性，按照java的设计原则必须提供以下两种方法： 1. setter方法：主要用于进行属性内容的设置与修改 2. getter方法：主要用于属性内容的取得 private实现封装的最大特征在于：只允许本类访问，而不允许外部类访问。 class Person { private int age; private String name; public void setName(String n) { ...
java如何使用getter_java – getter方法vs直接使用输入参数
weixin_39654903的博客
03-02 328
我在我被分配到的项目中遇到过这个代码(当然简化了).方法选项1public myType getSomething(final int pTeamId) {this.teamId = pTeamId;final ClassABC classABC = new ClassABC(pTeamId);...return myType;}请注意输入参数pTeamId如何在方法的第一行中分配给私有数据成员t...
java面向对象.doc
01-26
使用`==`比较的是两个字符串对象是否指向同一块内存空间，即它们是否为同一个实例。而`equals()`方法比较的是字符串内容是否相等，这是开发中更推荐的做法。 **This关键字** 在Java中，`this`关键字用来引用当前...
Java hashCode() 方法详细解读
09-02
如果哈希值相同，说明可能存在哈希冲突，此时会进一步调用`equals()`方法来检查这两个对象是否真正相等。如果两个对象的`equals()`返回`true`，那么它们的`hashCode()`必须相同，这是哈希表正确工作的基础。 `...
java面向对象程序设计习题集.doc
最新发布
06-28
- **字符串比较**：如何正确地比较两个字符串是否相等。 #### 第四章：数组 这部分题目涵盖了数组的基本操作和高级用法。 **知识点**： - **数组的声明与初始化**：如何声明和初始化一维数组或多维数组。 - **...
Java判断对象是否相同的优化
QPiker的博客
09-27 323
1.eqlaus(对象1，对象2):先做非空判断，然后在执行equals做比较。平时正常用对象1.eqlaus（对象2）做比较时，如果对象1为null那么此时会报空指针异常，为了更方便的解决这个问题，可以使用Objects.eqlaus(对象1，对象2)方法。Objects是一个对象的工具类，提供一下操作对象的方法，常见的方法有以下三种。2.isNull：用来判断对象是否为空。3.nonNull：判断对象是否不为空。
如何使用JAVA的Getter和Setter？
绿薄荷的博客
01-19 1107
private关键字的用途？ 使用IDEA如何快速生成Getter/Setter?
Java中动态调用setter以及getter
王嘟嘟的博客
02-09 2621
对于非专业程序员的安全人员来说，因为没有代码项目的积累，很多知识体系都不完善，所以有必要在一些常用的内容进行学习的总结。在很多的调用链中都会用到**“动态调用setter以及getter”**这个知识点，比如经典的CB链，fastjson调用链等。为了避免进行重复的分析，所以单独拎出来这个进行详解，查漏补缺，如有遗漏或者错误的地方，还请斧正。
Java的getter_java动态调用getter方法
weixin_36016360的博客
02-20 452
不知道反射能不能满足你的需求package test;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;public class Test {private int value;public void setValue(int value) {this.value = value;}...
Java8新特性之二：方法引用
f1766的博客
08-24 125
上一节介绍了Java8新特性中的Lambda表达式， 本小节继续讲解Java8的新特性之二：方法引用。方法引用其实也离不开Lambda表达式。 我们用Lambda表达式来实现匿名方法。 但有些情况下，我们用Lambda表达式仅仅是调用一些已经存在的方法，除了调用动作外，没有其他任何多余的动作。 在这种情况下，我们倾向于通过方法名来调用它，而Lambda表达式可以帮助我们实现这一要求，它使得Lambda在调用那些已经拥有方法名的方法的代码更简洁、更容易理解。方法引用可以理解为Lambda表达式的另外一种表现
java8-getter and setter
zsysingapore的博客
07-03 595
1:类的属性一般设置为private getter 添加一个方法，用来读取属性的值 setter 添加一个方法，用来设置属性的值 例子 hello的主函数： package my; public class Hello { public static void main(String[] args) { Example ex=new Example(); ex.setNumber(123); System.out.println("the res
java getter返回值_Java 8 getter应该返回可选类型吗？
weixin_39660408的博客
03-01 157
将 Optional 添加到Java的原因是因为：return Arrays.asList(enclosingInfo.getEnclosingClass().getDeclaredMethods()).stream().filter(m -> Objects.equals(m.getName(), enclosingInfo.getName()).filter(m -> Array...
java中定义Getter和Setter方法 语法 原理
weixin_74774974的博客
04-22 1961
通过定义Getter和Setter方法，我们可以控制属性的访问权限，同时还可以在Getter和Setter方法中添加额外的逻辑，例如数据验证、计算等。此外，如果我们将Setter方法的返回类型定义为int，那么就会导致Getter和Setter方法的返回类型不一致，从而增加代码的复杂性。Setter方法用于设置属性的值，它通常接受一个参数，该参数是要设置的属性值。Setter方法通常不需要返回值，因为它的作用是设置属性的值，而不是返回属性的值。因此，Setter方法的返回类型通常为void。
JavaBasic-Getter and Setter 方法
qq_41736477的博客
09-08 277
Getter and Setter 在java中，为了保证数据的安全性，我们会把数据定义为private等（私有、封装），如果想要调用就会用到set()方法与get方法或者构造函数方法。这里说的是第一种方法，set()与get()，既然说到这个，就得说一下封装的概念。 封装: private私有化成员属性，提供公开public的getter/setter Setter: 赋值 Getter:取值，在哪儿用：在构造方法中初始化属性值的用！！！！！或者对象名.set/get()进行使用！！！ 好处: 隐藏内部实
java两个不同对象属性比较
09-05
在Java中，可以使用"=="运算符来比较两个对象是否具有相同的引用，即是否指向同一个对象。而如果我们想要比较两个对象的属性是否相等，需要使用equals()方法。 首先，我们需要在对象的类中重写equals()方法。重写...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值