java ==、equals()、hashcode()使用

柔光的暖阳◎ 2022-12-17 14:56 120阅读 0赞

--------------------

### java ==、equals()、hashcode() 使用 ###

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**==、equals()**

**==：比较的数据可为基本数据类型、引用类型**

若为基本数据类型（如：int、char等），则比较数据的值是否相等；

若为引用类型（如：字符串、对象），则比较数据的内存地址是否相同

**equals()：比较的数据为引用类型**

默认比较数据的内存地址是否相同；重写后可比较数据内容是否相等

**\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***

**示例**

class Person{
    
        private String name;
        private Integer age;
    
        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;
        }
    }
    
    class People{
    
        private String name;
        private Integer age;
    
        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;
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof People)) return false;
            People people = (People) o;
            return Objects.equals(getName(), people.getName()) &&
                    Objects.equals(getAge(), people.getAge());
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(getName(), getAge());
        }
    }
    
    public class Test2 {
    
        public static void main(String[] args){
            int a=10;
            int b=20;
            int c=20;
            System.out.println("a==b："+(a==b));
            System.out.println("b==c："+(b==c));
    
            System.out.println("\n**********************");
    
            Person person=new Person();
            person.setName("瓜田李下");
            person.setAge(20);
    
            Person person2=new Person();
            person.setName("瓜田李下");
            person.setAge(20);
            System.out.println("person == person2："+(person == person2));
            System.out.println("person.equals(person2)："+(person.equals(person2)));
    
            System.out.println("\n**********************");
    
            People people=new People();
            people.setName("海贼王");
            people.setAge(20);
    
            People people2=new People();
            people2.setName("海贼王");
            people2.setAge(20);
            System.out.println("people == people2："+(people == people2));
            System.out.println("people.equals(people2)："+(people.equals(people2)));
        }
    }

**控制台输出**

a==b：false
    b==c：true
    
    **********************
    person == person2：false
    person.equals(person2)：false
    
    **********************
    people == people2：false
    people.equals(people2)：true

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

### equals()、hashcode() ###

**equals()返回true：**hashcode()返回的值相等；

**equals()返回false：**hashcode()返回的值可相等、也可不等

**hascode()返回的值不等，equals()返回false**

**Object**

public class Object {
 
 
 @HotSpotIntrinsicCandidate
 public Object() {}
 
 
 *************
 hashcode()
 
 /**
 * Returns a hash code value for the object. This method is
 * supported for the benefit of hash tables such as those provided by
 * {@link java.util.HashMap}.
 * 
 * The general contract of {@code hashCode} is:
 * <ul>
 * <li>Whenever it is invoked on the same object more than once during
 * an execution of a Java application, the {@code hashCode} method
 * must consistently return the same integer, provided no information
 * used in {@code equals} comparisons on the object is modified.
 * This integer need not remain consistent from one execution of an
 * application to another execution of the same application.
 //同一个对象多次调用hashcode()，返回的值相同，不会改变
 
 * <li>If two objects are equal according to the {@code equals(Object)}
 * method, then calling the {@code hashCode} method on each of
 * the two objects must produce the same integer result.
 //如果两个对象调用equals()返回true，则对象的hashcode相等
 
 * <li>It is not required that if two objects are unequal
 * according to the {@link java.lang.Object#equals(java.lang.Object)}
 * method, then calling the {@code hashCode} method on each of the
 * two objects must produce distinct integer results. However, the
 * programmer should be aware that producing distinct integer results
 * for unequal objects may improve the performance of hash tables.
 //如果两个对象调用equals()返回false，则对象的hashcode可相等，也可不等
 //建议为不同的对象设置不同的hashcode，提高hash结构中的操作效率
 * </ul>
 *
 * @implSpec
 * As far as is reasonably practical, the {@code hashCode} method defined
 * by class {@code Object} returns distinct integers for distinct objects.
 *
 * @return a hash code value for this object.
 * @see java.lang.Object#equals(java.lang.Object)
 * @see java.lang.System#identityHashCode
 */
 @HotSpotIntrinsicCandidate
 public native int hashCode();
 
 
 *************
 equals()
 
 /**
 * Indicates whether some other object is "equal to" this one.
 * 
 * The {@code equals} method implements an equivalence relation
 * on non-null object references:
 //equals()由非null对象调用
 
 * <ul>
 * <li>It is reflexive: for any non-null reference value
 * {@code x}, {@code x.equals(x)} should return
 * {@code true}.
 //x.equals(x)返回true
 
 * <li>It is symmetric: for any non-null reference values
 * {@code x} and {@code y}, {@code x.equals(y)}
 * should return {@code true} if and only if
 * {@code y.equals(x)} returns {@code true}.
 //如果x.equals(y)返回true，则y.equals(x)返回true
 
 * <li>It is transitive: for any non-null reference values
 * {@code x}, {@code y}, and {@code z}, if
 * {@code x.equals(y)} returns {@code true} and
 * {@code y.equals(z)} returns {@code true}, then
 * {@code x.equals(z)} should return {@code true}.
 //如果x.equals(y)返回true，y.equals(z)返回true，则x.equals(z)返回true
 
 * <li>It is consistent: for any non-null reference values
 * {@code x} and {@code y}, multiple invocations of
 * {@code x.equals(y)} consistently return {@code true}
 * or consistently return {@code false}, provided no
 * information used in {@code equals} comparisons on the
 * objects is modified.
 //在不修改x、y的前提下，多次调用x.equals(y)返回的结果相同
 
 * <li>For any non-null reference value {@code x},
 * {@code x.equals(null)} should return {@code false}.
 //非null的值x，x.equals(null)返回false
 
 * </ul>
 * 
 * The {@code equals} method for class {@code Object} implements
 * the most discriminating possible equivalence relation on objects;
 * that is, for any non-null reference values {@code x} and
 * {@code y}, this method returns {@code true} if and only
 * if {@code x} and {@code y} refer to the same object
 * ({@code x == y} has the value {@code true}).
 * 
 * Note that it is generally necessary to override the {@code hashCode}
 * method whenever this method is overridden, so as to maintain the
 * general contract for the {@code hashCode} method, which states
 * that equal objects must have equal hash codes.
 //重写equals()时，通常需要重写hashcode()，以保证equals()为true时，返回相同的hashcode
 
 *
 * @param obj the reference object with which to compare.
 * @return {@code true} if this object is the same as the obj
 * argument; {@code false} otherwise.
 * @see #hashCode()
 * @see java.util.HashMap
 */
 public boolean equals(Object obj) { //如果不重写equals()，默认比较对象的内存地址
 return (this == obj);
 }

**\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***

**示例**

class MyObject{
    
        private int hashcode;
    
        public MyObject(int hashcode){
            this.hashcode=hashcode;
        }
    
        @Override
        public boolean equals(Object o) {
            return true;
        }
    
        @Override
        public int hashCode() {
            return hashcode;
        }
    }
    
    public class Test3 {
    
        public static void main(String[] args){
            MyObject object=new MyObject(1);
            MyObject object2=new MyObject(2);
            System.out.println("object.equals(object2)："+object.equals(object2));
    
            System.out.println("object.hashcode()："+object.hashCode());
            System.out.println("object2.hashcode()："+object2.hashCode());
        }
    }

**控制台输出**

object.equals(object2)：true
    object.hashcode()：1
    object2.hashcode()：2

**说明：equals()、hanhcode()约束规则使用时不做检查，仅为提高hash结构操作效率**