精华内容
参与话题
问答
  • Java中equals()方法重写

    万次阅读 2012-08-23 15:17:41
    Java中的equals()方法是在Object类中定义,Object类是所有类的父类。换句话说,任何类都隐含地...重写equals()方法代码如下: /** *equlas()方法重写实例 */ class User { /** *方法描述:设置name值 *输

      Java中的equals()方法是在Object类中定义,Object类是所有类的父类。换句话说,任何类都隐含地继承了该方法。判断两个对象的内容是否相同,必须使用equals()方法,对于没有重写该方法的类,需要重写该方法。重写equals()方法代码如下:

    /**
     *equlas()方法重写实例
     */
    class User {
     /**
      *方法描述:设置name值
      *输入参数:String name
      *返回类型:void
      */
     public void setName(String name) {
      this.name = name;
     }
    
    /**
      *方法描述:获取name值
      *输入参数:
      *返回类型:String
      */
     public String getName() {
       return name;
     }
    
    /**
      *方法描述:重写equals()方法
      *输入参数:Object obj
      *返回类型:boolean
      */
    
    public boolean equals(Object obj) {
     if(this == obj) {
       return true;
     }
     if(null == obj) {
       return false;
     }
     if(getClass() != obj.getClass()) {
       return false;
     }
    
     User user = (User) obj;
     if(!name.equals(user.name)) {
      return false;
     }
      return true;
    }
     private String name;
    }
    
    public class EqualsDemo {
     public static void main(String[] args) {
      User userA = new User();
      userA.setName("王明");
      
      User userB = new User();
      userB.setName("王明");
    
      User userC = new User();
      userC.setName("王亮");
    
      System.out.println("userA equals userB:" + userA.equals(userB));
      System.out.println("userA equals userC:" + userA.equals(userC));
     }
    }

    运行结果如下所示:

      总结:

     1.对象内容的比较,需要使用equals()方法,若是对于已经重写该方法的类,例如String类,就无需再重写;若是没有重写,例如自定义的User类,就需要重写。

     2.Java语言中的“==”对于基本数据类型就是比较其值,而对于对象就是比较对象的引用。


     

    展开全文
  • 重写equals()方法

    万次阅读 多人点赞 2018-05-23 22:24:53
    多个字段组合作为联合主键,必须实现equals和hashcode方法equals()和hashCode()这两个方法属于Object类,而Object类是所有类的父类,因此所有的类都继承了这两个方法。其中有一些类重写了这两个方法。例如:O...


    1.如果想把持久类的实例放入set中(多值关联时,1对多),建议实现equals和hashcode

    2.想重用托管实例时,也要实现equals和hashcode

    3.多个字段组合作为联合主键,必须实现equals和hashcode方法

    equals()和hashCode()这两个方法属于Object类,而Object类是所有类的父类,因此所有的类都继承了这两个方法。其中有一些类重写了这两个方法。

    例如:Object类的equals()方法代码如下:
    public boolean equals(Object obj) {  
        return (this == obj);  
        }  

    这两个方法都来自于Object对象,根据API文档查看下原意。

    (1)public boolean equals(Objectobj),对于任何非空引用值 x 和 y,当且仅当 x 和 y 引用同一个对象时,此方法才返回 true;

    注意:当此方法被重写时,通常有必要重写 hashCode 方法,以维护 hashCode 方法的常规协定,该协定声明相等对象必须具有相等的哈希码。

    (2)public int hashCode() 返回该对象的哈希码值。支持该方法是为哈希表提供一些优点

        我们知道,如果不重写equals,那么比较的将是对象的引用是否指向同一块内存地址,重写之后目的是为了比较两个对象的value值是否相等。特别指出,此时,利用equals比较八大包装对象(如int,float等)和String类(因为该类已重写了equals和hashcode方法)对象时,默认比较的是值,在比较其它对象都是比较的引用地址。那产生了一个问题,为什么jdk中希望我们在重写equals时,非常有必要重写hashcode呢?

        我的理解是hashcode是用于散列数据的快速存取,如利用HashSet/HashMap/Hashtable类来存储数据时,都是根据存储对象的hashcode值来进行判断是否相同的。这样如果我们对一个对象重写了euqals,意思是只要对象的成员变量值都相等那么euqals就等于true,但不重写hashcode,那么我们再new一个新的对象,当原对象.equals(新对象)等于true时,两者的hashcode却是不一样的,由此将产生了理解的不一致,如在存储散列集合时(如Set类),将会存储了两个值一样的对象,导致混淆,因此,就也需要重写hashcode。

    在集合类(HashMap,HashSet等)中判断两个对象是否相等有如下规则:

    如果两个对象哈希值不同,那么这两个对象不相等。如果相同,则调用equals()方法判断,如果equals()方法返回true,则这两个对象相等,否则不相等。为了保证这种一致性,必须满足以下两个条件:
        (1)当obj1.equals(obj2)为true时,obj1.hashCode() == obj2.hashCode()必须为true

        (2)当obj1.hashCode() == obj2.hashCode()为false时,obj1.equals(obj2)必须为false

    在实体类中重写equals方法和hashcode方法:

    package org.test.entity;


    public class User {
    private int id;
    private String uname;
    private int age;
    private String sex;
    private String city;
    public int getId() {
    return id;
    }
    public void setId(int id) {
    this.id = id;
    }
    public String getUname() {
    return uname;
    }
    public void setUname(String uname) {
    this.uname = uname;
    }
    public int getAge() {
    return age;
    }
    public void setAge(int age) {
    this.age = age;
    }
    public String getSex() {
    return sex;
    }
    public void setSex(String sex) {
    this.sex = sex;
    }
    public String getCity() {
    return city;
    }
    public void setCity(String city) {
    this.city = city;
    }
    //重写Object类下的toString()方法
    public String toString(){
    return "User [id="+id+",uname="+uname+",age="+age+",sex="+sex+",city="+city+"]";
    }


    //第一步分析  
    /*@Override 
    public boolean equals(Object obj) { 
         *//** 
          * 这里要改进,根据这里的比较成员变量来决定返回true还是false 
          * 这里其实要比较的就是name,age和sex,city
          * 但是,name是String类型的,而String是引用类型的,所以,在这里不能直接用==比较, 
          * 应该用equals()比较 
          * this  -- s1 
          * obj -- s2 
          *//* 
         if(obj == null){ 
             return false; 
         } 
         //要使用的是用户类的特有成员,所以要向下转型 
         User s = (User)obj; // s -- obj -- s2 
         if(this.age == s.age && this.uname.equals(s.uname) && this.sex.equals(s.sex) && this.city.equals(s.city)){ 
                  return true; 
             }else{ 
                  return false; 
             } 
    }*/  
      
    //第二步优化  
    /*   @Override 
    public boolean equals(Object obj) { 
         //为了提高效率 
         if(this == obj){ 
             return true; 
         } 
          
         //为了提供程序的健壮性 
         //我先判断一下,obj是不是用户的一个对象,如果是,再做向下转型,如果不是,直接返回false 
         //这个时候,我们要判断的是对象是否是某个类的对象? 
         if (!(obj instanceof User)) { 
             return false; 
         } 
         //如果是就继续 
         User user = (User)obj; 
         System.out.println("同一个对象,还需要向下转型比较吗?"); 
         return this.uname.equals(s.uname) && this.age==s.age && this.sex.equals(s.sex)this.city.equals(s.city); 
    }*/  
      


    //重写equals要实现hachCode()  
    @Override  
    public int hashCode() {  
         final int prime = 31;  
         int result = 1;  
         result = prime * result + age;  
         result = prime * result + ((uname == null) ? 0 : uname.hashCode());  
         result = prime * result + ((sex == null) ? 0 : sex.hashCode());  
         result = prime * result + ((city == null) ? 0 : city.hashCode());  
         return result;  
    }  
    //第三步  
    @Override  
    public boolean equals(Object obj) {  
         if (this == obj)   //判断对象地址是否相等,如果是就不用判断,提高效率  
             return true;  
         if (obj == null)   //对象为空,则不往下走了  
             return false;  
         if (getClass() != obj.getClass())  //判断两个对象是否一样:class july.star.equals.Student--class july.star.equals.Student  
             return false;  
        User user = (User) obj;  //向下转型  
         /** 判断成员变量是否一样 */  
         if (age != user.age)     
             return false;  //判断年龄,int类型,直接比较
         //String类型,equals()比较
         if (uname == null) {  
             if (user.uname != null)  
                  return false;  
         } else if (!uname.equals(user.uname))  
             return false;  
         if (sex == null) {  
             if (user.sex != null)  
                  return false;  
         } else if (!sex.equals(user.sex))  
             return false;  
         if (city == null) {  
             if (user.city != null)  
                  return false;  
         } else if (!city.equals(user.city))  
             return false; 
         return true;  
    }


    }

    测试类:

    package org.test.demo;

    import org.hibernate.HibernateException;
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.Transaction;
    import org.hibernate.cfg.Configuration;
    import org.junit.After;
    import org.junit.Before;
    import org.junit.Test;
    import org.test.entity.User;


    public class UserTest {


      //定义变量


        Configuration config=null;


        SessionFactory sessionFactory=null;


        Session session=null;


        Transaction transaction=null;

    @Test



    public void equalsTest()
    {
    User user1=new User();
    User user2=new User();


    try {


      session=HibernateUtils.getSession();


      //4.开始事务


      transaction=session.beginTransaction();
    //5.操作
    user1=(User)session.get(User.class, 1);
     //6.提交事务


       transaction.commit();


       //7.关闭资源
       session.close();
       
    } catch (HibernateException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }


    try {


      session=HibernateUtils.getSession();


      //4.开始事务


      transaction=session.beginTransaction();
    //5.操作
    user2=(User)session.get(User.class, 1);

     //6.提交事务


       transaction.commit();


       //7.关闭资源
       session.close();


    } catch (HibernateException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
    System.out.println(user1==user2);//重写前:false        重写后: false
    System.out.println(user1.equals(user2));//false   true
    User user3 = user1;   //地址引用,指向同一个地址  
    System.out.println( user1 == user3);  //true      true
    //false:this==obj 也是对地址的比较,所以要重写equals  
    System.out.println(user1.equals(user3));  //true   true
    System.out.println(user1.equals(user2));  //false   true
      
    System.out.println("--------------");  
    User user4 = new User();  
    //重写后  
    System.out.println(user1.equals(user2));  //true  
    System.out.println(user1.equals(user3));    //true  
    System.out.println(user1.equals(user4));    //false  
    UserTest d = new UserTest ();  
    System.out.println(user1.equals(d));  //false 判断是否为同一个对象  
    }

    }

    在重写之前结果为:

    重写后结果为:






    展开全文
  • Java重写equals方法

    千次阅读 2016-10-08 17:00:08
    equals方法的特性 自反性:对于任意的引用值x,x.equals(x)一定为true 对称性:对于任意的引用值x 和 y,当x.equals(y)返回true,y.equals(x)也一定返回true 传递性:对于任意的引用值x、y和z,如果x.equals(y)返回...

    重写equals方法的注意点

    1. 自反性:对于任意的引用值x,x.equals(x)一定为true
    2. 对称性:对于任意的引用值x 和 y,当x.equals(y)返回true,y.equals(x)也一定返回true
    3. 传递性:对于任意的引用值x、y和z,如果x.equals(y)返回true,并且y.equals(z)也返回true,那么x.equals(z)也一定返回 true
    4. 一致性:对于任意的引用值x 和 y,如果用于equals比较的对象信息没有被修改,多次调用x.equals(y)要么一致地返回true,要么一致地返回false
    5. 非空性:对于任意的非空引用值x,x.equals(null)一定返回false

    重写equals方法的正确示例

    import org.apache.commons.lang3.builder.HashCodeBuilder;
    
    public class Person {
        private String name;
    
        public String getName() {
            return this.name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @override
        public boolean equals(Object obj) {
            if (obj == null || obj.getClass() != this.getClass()) {
                return false;
            }
    
            Person person = (Person)obj;
    
            if (this.name = null) {
                return person.getName() == null;
            } else {
                return this.name.equals(person.getName());
            }
        }
    
        @override
        public int hashCode() {
            return new HashCodeBuilder().append(name).toHashCode();
        }
    }

    说明:
    1. 在equals中使用getClass进行类型判断。因为instanceof在继承对象中可能会引起对称性的问题。
    2. 重写equals方法必须重写hashCode方法。如果不重写,那么诸如HashMap中对比的方法将会失效。

    展开全文
  • 为什么equals()方法重写

    千次阅读 2018-09-14 11:46:58
    为什么equals()方法要重写? 判断两个对象在逻辑上...我们向一个没有重复对象的集合中添加元素时,集合中存放的往往是对象,我们需要先判断集合中是否存在已知对象,这样就必须重写equals方法。 怎样重写equals()...

    为什么equals()方法要重写?

    判断两个对象在逻辑上是否相等,如根据类的成员变量来判断两个类的实例是否相等,而继承Object中的equals方法只能判断两个引用变量是否是同一个对象。这样我们往往需要重写equals()方法。

    我们向一个没有重复对象的集合中添加元素时,集合中存放的往往是对象,我们需要先判断集合中是否存在已知对象,这样就必须重写equals方法。

    怎样重写equals()方法?

    重写equals方法的要求:
    1、自反性:对于任何非空引用x,x.equals(x)应该返回true。
    2、对称性:对于任何引用x和y,如果x.equals(y)返回true,那么y.equals(x)也应该返回true。
    3、传递性:对于任何引用x、y和z,如果x.equals(y)返回true,y.equals(z)返回true,那么x.equals(z)也应该返回true。
    4、一致性:如果x和y引用的对象没有发生变化,那么反复调用x.equals(y)应该返回同样的结果。
    5、非空性:对于任意非空引用x,x.equals(null)应该返回false。

     

    1、自反性原则

        在JavaBean中,经常会覆写equals方法,从而根据实际业务情况来判断两个对象是否相等,比如我们写一个person类,根据姓名来判断两个person类实例对象是否相等。代码如下:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    public class Person {

        private String name;

      

        public Person(String name){

            this.name = name;

        }

      

        public String getName() {

            return name;

        }

      

        public void setName(String name) {

            this.name = name;

        }

      

        @Override

        public boolean equals(Object obj) {

            if (obj instanceof Person) {

                Person person= (Person) obj;

                return name.equalsIgnoreCase(person.getName().trim());

            }

            return false;

        }

        public static void main(String[] args){

            Person p1=new Person("张三");

            Person p2=new Person("张三    ");

            List<Person> list = new ArrayList<Person>();

            list.add(p1);

            list.add(p2);

            System.out.println("是否包含张三:"+list.contains(p1));

            System.out.println("是否包含张三:"+list.contains(p2));

        }

    }

        list中含有这个生成的person对象,结果应该为true,但是实际结果:    这里考虑了字符串空格的问题,去除前后的空格。

        是否包含张三:true

        是否包含张三:false

        第二个为什么会是false呢?原因在于list中检查是否含有元素时是通过调用对象的equals方法来判断的,也就是说 contains(p2)传递进去会依次执行p2.equals(p1)、p2.equals(p2),只要一个返回true,结果就是true。但是这里p2.equals(p2)返回的是false?由于我们对字符前后进行了空格的切割造成p2.equals(p2)的比较实际上是:“张三   ”.equals(“张三”),一个有空格,一个没有空格就出错了。

        这个违背了equals的自反性原则:对于任何非空引用x,x.equals(x)应该返回true。

        这里只要去掉trim方法就可以解决。

    2、对称性原则

        上面这个例子,还并不是很好,如果我们传入null值,会怎么样呢?增加一条语句:Person p2=new Person(null);

    结果:

    1

    2

    是否包含张三:true

    Exception in thread "main" java.lang.NullPointerException

    原因在执行p2.equals(p1)时,由于p2的name是一个null值,所以调用name.equalsIgnoreCase()方法时就会报空指针异常。

    这是在覆写equals方法时没有遵循对称性原则:对于任何应用x,y的情形,如果想x.equals(y)返回true,那么y.equals(x),也应该返回true。

    应该在equals方法里加上是否为null值的判断:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    @Override

        public boolean equals(Object obj) {

            if (obj instanceof Person) {

                Person person= (Person) obj;

                if (person.getName() == null || name == null) {

                    return false;

                }else{

                    return name.equalsIgnoreCase(person.getName());

                }

            }

            return false;

        }

    3、传递性原则  

    现在我们有一个Employee类继承自person类:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    public class Employee extends Person{

        private int id;

      

      

        public int getId() {

            return id;

        }

        public void setId(int id) {

            this.id = id;

        }

        public Employee(String name,int id) {

            super(name);

            this.id = id;

            // TODO Auto-generated constructor stub

        }

        @Override

        public boolean equals(Object obj) {

            if(obj instanceof Employee){

                Employee e = (Employee)obj;

                return super.equals(obj) && e.getId() == id;

            }

            return super.equals(obj);

        }

      

        public static void main(String[] args){

            Employee e1=new Employee("张三",12);

            Employee e2=new Employee("张三",123);

            Person p1 = new Person("张三");

      

            System.out.println(p1.equals(e1));

            System.out.println(p1.equals(e2));

            System.out.println(e1.equals(e2));

        }

    }

      只有在name和ID都相同的情况下才是同一个员工,避免同名同姓的。在main里定义了,两个员工和一个社会闲杂人员,虽然同名同姓但肯定不是同一个人。运行结果应该三个都是false才对。但是:

    true

    true

    false

        p1尽然等于e1,也等于e2,不是同一个类的实例也相等了?因为p1.equals(e1)是调用父类的equals方法进行判断的它使用instanceof关键字检查e1是否是person的实例,由于employee和person是继承关系,结果就是true了。但是放过来就不成立,e1,e2就不等于p1,这也是违反对称性原则的一个典型案例。

       e1竟然不等于e2?e1.equals(e2)调用的是Employee的equals方法,不仅要判断姓名相同还有判断工号相同,两者的工号不同,不相等时对的。但是p1等于e1,也等于e2,e1却不等于e2,这里就存在矛盾,等式不传递是因为违反了equals的传递性原则:对于实例对象x、y、z;如果x.equals(y)返回true,y.equals(z)返回true,那么x.equals(z)也应该返回true。

        上述情况会发生是因为父类使用instanceof关键字(是否是这个特定类或者是它的子类的一个实例),用来判断是否是一个类的实例对象的,这很容易让子类“钻空子”。想要解决也很简单,使用getClass进行类型的判断,person类的equals方法修改如下:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    @Override

        public boolean equals(Object obj) {

            if (obj != null && obj.getClass() == this.getClass()) {

                Person person= (Person) obj;

                if (person.getName() == null || name == null) {

                    return false;

                }else{

                    return name.equalsIgnoreCase(person.getName());

                }

            }

            return false;

        }


    4、必须覆写hashCode方法这样结果就是三个false。

    覆写equals方法就必须覆写hashCode方法,这是Javaer都知道的。原因就是HashMap的底层处理机制是以数组的方式保存map条目的,这其中的关键是这个数组下标的处理机制:依据传入元素的hashCode方法的返回值决定其数组的下标,如果该数组位置上已经有了map条目,且与传入的键值相等则不处理,若不相等则覆盖;如果数组位置没有条目,则插入,并加入到map条目的链表中。同理检查键是否存在也是根据哈希吗确定文职,然后遍历查找键值的。

    那么对象的hashCode方法返回的是什么呢?他是一个对象的哈希码,是有Object类的本地方法生成的,确保每个对象有一个哈希码。

    具体的可以看另一篇博文:http://www.cnblogs.com/silence-hust/p/4510574.html

     

    转载地址:https://www.cnblogs.com/silence-hust/p/4558701.html

    展开全文
  • 重写hashcode和equals方法

    万次阅读 多人点赞 2019-05-07 21:55:43
    一。前言 我们都知道,要比较两个对象是否相等时需要调用对象的equals()方法,即判断对象引用所指向的对象地址是否相等,对象地址相等...对象在不重写的情况下使用的是Object的equals方法和hashcode方法,从Object...
  • Java自定义类中重写equals方法

    千次阅读 2019-03-20 18:01:52
    equals方法的要求: a.自反性:对于任何非空的x,x.equals(x)都应该返回true b.对称性:对于任何引用x和y,当且仅当x.equals(y)返回true时,y.equals(x)也应该返回true c.传递性:对于任何引用x,y,z,如果x.equals(y)...
  • 1、首先我们看看对象默认的(Object)的equals方法和hashcode方法 public booleanequals(Object obj) ...对象在不重写的情况下使用的是Object的equals方法和hashcode方法,从Object类的源码我们知道,默认的equals...
  • 为什么重写equals方法,还必须要重写hashcode方法

    万次阅读 多人点赞 2019-04-18 16:35:14
    是为了提高效率,采取重写hashcode方法,先进行hashcode比较,如果不同,那么就没必要在进行equals的比较了,这样就大大减少了equals比较的次数,这对比需要比较的数量很大的效率提高是很明显的,一个很好的例子就是...
  • 假如我们创建了一个 People 类,并且重写了其中的 equals 方法 public class People { private Integer age; private String name; // getter/setter方法 .... @Override public boolean equals(Object obj...
  • java重写equals()方法和hashCode()方法

    万次阅读 多人点赞 2018-07-02 19:12:40
    equals方法用于比较两个对象是否相同,Object类中equals方法的实现是比较引用地址来判断的对象是否是同一个对象,通过覆盖该方法可以实现自定义的判断规则; hashCode是jdk根据对象的地址或者字符串或者数字计算...
  • [java]重写类的 equals()方法

    千次阅读 2019-06-29 18:53:44
    equals方法用于比较两个对象是否相同,Object类中equals方法的实现是比较引用地址来判断的对象是否是同一个对象,通过覆盖该方法可以实现自定义的判断规则; hashCode是jdk根据对象的地址或者字符串或者数字计算该...
  • Java语言规范要求equals方法具有下面的特性: 自反性:对于任何非空引用x,x.equals(x)应该返回true 对称性:对于任何引用x和y,当且仅当y.equals(x)返回true,x.equals(y)也应该返回true 传递性:对于任何引用x...
  • 为什么重写equals一定要重写hashcode

    万次阅读 多人点赞 2018-05-24 23:55:10
    为什么重写equals一定要重写hashcode,相信大家一定有这样的一个疑问。尤其是对于刚入门的Java学者来说,这个疑惑不解开就不得劲啊。
  • java编程里有关约定:如果两个对象根据equals方法比较是相等的,那么调用这两个对象的任意一个hashcode方法都必须产生相同的结果。 因为没有重写hashcode而导致违反了这一条约定。 举个栗子。 在学校中,是通过...
  • 为什么重写equals还要重写hashcode

    千次阅读 2019-05-18 21:05:04
    14、● 请你解释Object若不重写hashCode()的话,hashCode()如何计算出来的? 考点:基础 参考回答: Object 的 hashcode 方法是本地方法,也就是用 c 或 c++ 实现的,该方法直接返回对象的内存地址。 如果没有重写...
  • 有时候,或许会听到被人说,在重写equals方法的时候,记得重写hashcode方法。那么自然有这样的疑问,那么为什么这样?equals方法和hashCode方法是什么关系?不重写的时候会有什么危害?文章将从一下几个方面进行叙述...
  • 首先这两个方法都是Object超类中的两个方法,类 Object 是...可以明显看到equals方法比较的是内存地址,hashcode方法是一个native方法,native方法的具体实现是用C语言实现的,因为jdk就是用C语言编写的。当有一些需...
  • 1.为什么重写equals()方法? 因为object中的equals()方法比较的是对象的引用地址是否相等,如何你需要判断对象里的内容是否相等,则需要重写equals()方法。 2.Java中有哪些类重写了equals()方法? java中的大...
  • 1.何时需要重写equals() 当一个类有自己特有的“逻辑相等”概念(不同于对象身份的概念)。 2.设计equals() [1]使用instanceof操作符检查“实参是否正确的类型”。 [2]对于类中的每一个“关键域”,检查实参中...

空空如也

1 2 3 4 5 ... 20
收藏数 155,305
精华内容 62,122
关键字:

重写equals方法