java 中的equals()示例代码

「爱情、让人受尽委屈。」 2023-10-04 23:04 6阅读 0赞

Java中的equals()是十分重要的，和==要区别开来

## **简述** ##

public boolean equals(Object obj)

作用：判断其他的对象是否和该对象相等

其比较规则为：当参数obj引用的对象与当前对象为同一个对象时，就返回true,否则返回false.

## **简单示例** ##

equals()方法在object类中定义：

public boolean equals(Object obj) \{

return (this == obj);

上边我们很明显看出是比较2个对象引用地址是否相同，比如以下两个对象animal1和animal2，引用不同的对象，因此用==或equals()方法比较的结果都为false;而animal1和animal3变量引用同一个Dog对象，因此用==或者equals()方法比较的结果都为true.

Animal animal1=new Dog();

Animal animal2=new Cat();

Animal animal3=animal1;

则animal1==animal2 (false)

animal1.equals(animal2)(false)

animal1==animal3(true)

animal1.equals(animal3)(true)

但是我们平时在调用String、Integer等封装类型时的equals方法时是比较的内容是否一致而不是地址一致，如果是地址一致，那所有的String比较都是相等的，所以JDK类中有一些类覆盖了oject类的equals()方法，比较规则为：如果两个对象的类型一致，并且内容一致，则返回true,这些类有：java.io.file,java.util.Date,java.lang.string,包装类(Integer,Double等)

如下简单示例：

public class Demo {
        public static void main(String[] args) {
            Integer int1=new Integer(1);
            Integer int2=new Integer(1);
            System.out.println(int1==int2); // false,因为不同对象
            System.out.println(int1.equals(int2));  // true
    
            String str1=new String("hello");
            String str2=new String("hello");
            System.out.println(str1==str2); // false
            System.out.println(str1.equals(str2));  // true
        }
    }

![ee735bec5aca49b88a4e8f90e7b7fb14.png][]

## **自定义类，重写equals()方法** ##

当然，可以自定义覆盖object类的equals()方法，重新定义比较规则。比如，下面Person类的equals()比较规则为：只要两个对象都是Person类，并且他们的属性name都相同，则比较结果为true,否则返回false

**Person类**

public class Person{
        private String name;
    
        public Person(String name)
        {
            this.name=name;
        }
    
        public boolean equals(Object o)
        {
    
            if (this==o) return true;
            /*
             * instanceof
             * 作用是：测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。
             * instanceof是Java中的二元运算符，左边是对象，右边是类；当对象是右边类或子类所创建对象时，返回true；否则，返回false。
             * */
            if (!(o instanceof Person)) return false;
    
            final Person other=(Person)o;
            if (this.name.equals(other.name))
                return true;
            else
                return false;
        }
    }

**main函数所在主类：**

public class Demo {
        public static void main(String[] args) {
            Person A = new Person("test");
            Person B = new Person("test");
            System.out.println(A == B); // false
            System.out.println(A.equals(B));  // true
        }
    }

![0aebc8a5a4f249e28adb771de15dd8bd.png][]

## **重写equals()方法注意内容** ##

要注意满足离散数学上的特性:

1、自反性 ：对任意引用值X，x.equals(x)的返回值一定为true.

2 、对称性： 对于任何引用值x,y,当且仅当y.equals(x)返回值为true时，x.equals(y)的返回值一定为true;

3 、传递性：如果x.equals(y)=true, y.equals(z)=true,则x.equals(z)=true

4、 一致性：如果参与比较的对象没任何改变，则对象比较的结果也不应该有任何改变

5 、非空性：任何非空的引用值X，x.equals(null)的返回值一定为false

## **示例(判断两个Integer是否相等)** ##

比较数值相等时，建议使用equals()

public class Demo {
        public static void main(String[] args) {
            Integer i_128_a = -128;
            Integer i_128_b = -128;
    
            Integer i127_a = 127;
            Integer i127_b = 127;
            System.out.println(i_128_a == i_128_b); // true
            System.out.println(i127_a == i127_b); // true
    
            // 可以看到，当Integer表示的值在[-128 ~ 127]之间，使用==时能达到我们的预期的。
            // IntegerCache缓存范围是[-128~127]，可以修改修改integer的缓存范围，但是治标不治本
            //可是一旦超过这个范围，结果就不是我们想要的了,如下：
    
            Integer i_129_a = -129;
            Integer i_129_b = -129;
    
            Integer i128_a = 128;
            Integer i128_b = 128;
            System.out.println(i_129_a == i_129_b); // false
            System.out.println(i128_a == i128_b); // false
    
            
            System.out.println("使用equals()方法");
            System.out.println(i_128_a == i_128_b); // true
            System.out.println(i127_a.equals(i127_b)); // true
            System.out.println(i_129_a.equals(i_129_b)); // true
            System.out.println(i128_a.equals(i128_b)); // true
        }
    }

![f69d47b2451b45838c13bd6b4b6bc026.png][]

## **示例(判断两个Map集合是否相等)** ##

Demo

import java.util.HashMap;
    import java.util.Map;
    
    public class Demo {
        public static void main(String[] args) {
            Map<String,Object> mapA = new HashMap<>();
            Map<String,Object> mapB = new HashMap<>();
    
            mapA.put("a",123);
            mapA.put("b",6.66);
            mapA.put(null,777);
            mapA.put(null,"888");
            mapA.put("c","999");
    
            mapB.put("a",123);
            mapB.put("b",6.66);
            mapB.put(null,777);
            mapB.put(null,"888");
            mapB.put("c","999");
    
            System.out.println(mapA.equals(mapB)); // true
    
            Map<String,Object> mapC = new HashMap<>();
            System.out.println(mapA.equals(mapC)); // false
        }
    }

![856d10b5d3d341ffadcf1f3b35de232e.png][]

## **示例(判断两个HashSet集合是否相等)** ##

import java.util.HashSet;
     
    public class Demo {
        public staticvoid main(String[] args) {
           HashSet<String> set1 = new HashSet<String>();
           HashSet<String> set2 = new HashSet<String>();
           System.out.println(set1.equals(set2));
           set1.add("a");
           set1.add("c");
            set1.add("b");
           System.out.println(set1.equals(set2));
           set2.add("a");
           set2.add("c");
           set2.add("b");
           System.out.println(set1.equals(set2));
        }
    }

![ae84957e1b44444da8e56989451b4f21.png][]

## **示例(判断两个List集合是否相等)** ##

import java.util.ArrayList;
    import java.util.List;
    
    public class Demo {
        public static void main(String[] args) {
            List<String> list1 = new ArrayList<>();
            List<String> list2 = new ArrayList<>();
            System.out.println(list1.equals(list2));
            list1.add("test");
            list1.add(1, "1111");
            System.out.println(list1);
            System.out.println(list1.equals(list2));
            list2.add("test");
            list2.add(1, "1111");
            System.out.println(list2);
            System.out.println(list1.equals(list2));
        }
    }

![5c9710c84aaa480a8aae4f8691d17abf.png][]

[ee735bec5aca49b88a4e8f90e7b7fb14.png]: https://img-blog.csdnimg.cn/img_convert/ee735bec5aca49b88a4e8f90e7b7fb14.png
[0aebc8a5a4f249e28adb771de15dd8bd.png]: https://img-blog.csdnimg.cn/img_convert/0aebc8a5a4f249e28adb771de15dd8bd.png
[f69d47b2451b45838c13bd6b4b6bc026.png]: https://img-blog.csdnimg.cn/img_convert/f69d47b2451b45838c13bd6b4b6bc026.png
[856d10b5d3d341ffadcf1f3b35de232e.png]: https://img-blog.csdnimg.cn/img_convert/856d10b5d3d341ffadcf1f3b35de232e.png
[ae84957e1b44444da8e56989451b4f21.png]: https://img-blog.csdnimg.cn/img_convert/ae84957e1b44444da8e56989451b4f21.png
[5c9710c84aaa480a8aae4f8691d17abf.png]: https://img-blog.csdnimg.cn/img_convert/5c9710c84aaa480a8aae4f8691d17abf.png