重写equals必须重写hashCode一篇就够了

先上两个方法的源码

hashCode源码

	Object中源码
	本地方法,这里说下官方加的注释
	1.返回的是独享的哈希码值
	2.一个Java应用程序的执行，在同一对象上多次调用该方法,要求返回相同的整数,但在equals中使用比较对象的信息被修改,或者应用程序到另一个执行相同的应用程序,这时候不需要一定保持一致
	3.如果两个对象根据equals()比较后相等，然后调用{@code hashCode}方法是两个对象必须产生相同的整数结果。
	4.如果两个对象不相等，则两个对象必须调用改方法可以产生不同的整数结果,也可以产生相同整数结果。程序员应该注意产生不同的整数结果对于不相等的对象可以提高哈希表的性能。
    public native int hashCode();

equals()源码

	Object中源码
	==直接比较的是地址
	官方注释:
	1.这个方法比较的是引用对象是否与obj(传入方法中的参数)是否相等
	2.重写这个方法时候,为了维护方法的通用契约,他声明相等的对象必须具有相等的哈希码,所以重写该方法需要重写hashCode
  public boolean equals(Object obj) {
        return (this == obj);
    }

先说不重写方法,用 Object自带方法时候调用方法的结果

• 定义一个A类,含有一个年龄的成员变量

public class A {
    private int age;

    public A(int age) {
        this.age = age;
    }
}

• 定义以个B类,通过调用方法比较

public class B {
    public static void main(String[] args) {
        A a1=new A(15);
        A a2=new A(15);
        System.out.println(a1); //A.A@1b6d3586
        System.out.println(a2); //A.A@4554617c
        boolean bl=a1.equals(a2); 
        System.out.println(bl); //false
        System.out.println("a1.hashCode"+a1.hashCode()); //a1.hashCode460141958
        System.out.println("a2.hashCode"+a2.hashCode()); //a2.hashCode116315788

    }

}

• 运行结果

A.A@1b6d3586
A.A@4554617c
false
a1.hashCode460141958
a2.hashCode1163157884

Process finished with exit code 0

• 结果解释,两个对象a1,a2,都是new的对象,他们的存的地址是不一样的,即使他们的内容是一样的,所以调用两个方法的时候也是不一样的.

为什么要重写equals方法呢?

• 因为我们想让当对象的里面的属性相等的时候他们可以算是一个相等的对象,比如一个A类中年龄都是15,那么他们是相等的

为什么重写equals方法时候要从重写hashCode呢?

因为为了保证当两个对象equals方法相同时,他们的hashCode方法调用后返回相同的结果,算是个维护方法的通用契约.

重写equals方法的用处在哪里有用呢?

在hashSet为了提高性能,当然需要相同的属性信息对象在集合中只需要存储一个.

• 没重写时候,A还是和上面的一样

public class B {
    public static void main(String[] args) {
        A a1=new A(5);
        A a2=new A(5);
        HashSet hashSet=new HashSet();
        hashSet.add(a1);
        hashSet.add(a2);
        for (Object a:hashSet
             ) {
            System.out.println(a);
        }
    }

}

• 结果

A.A@4554617c
A.A@1b6d3586

重写A中equal和hashcode方法后可以实现只让集合存储一个.

• 改写后A,其实真正改写equals是通过用属性啥的都要用上,我这里偷懒直接用idea自动生成的

public class A {
    private int age;

    public A(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        A a = (A) o;
        return age == a.age;
    }

    @Override
    public int hashCode() {
        return Objects.hash(age);
    }
}

• B代码

public class B {
    public static void main(String[] args) {
        A a1=new A(5);
        A a2=new A(5);
        HashSet hashSet=new HashSet();
        hashSet.add(a1);
        hashSet.add(a2);
        for (Object a:hashSet
             ) {
            System.out.println(a);
        }
    }

}

• 结果,显然集合中只存储了一个.hashSet中add方法是怎样判断key是否相同的可以自己再看源码.可以博客自己搜索下看看别人是怎么分析的

A.A@24

String已经重写过了hashCode和equals方法

• 老规矩上String重写equals()的源码

分析:把第h乘31后,然后在加上第一个字符,更新h,然后继续同样步骤,因此可以看出相同的字符串肯定有相等的hashCode值,但是不同的也可以有相同的hashCode值
private int hash; // Default to 0
  public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

• String重写equals()的源码

 public boolean equals(Object anObject) {
 		//调用者是否和传入的对象地址是否相等,相等直接返回true
        if (this == anObject) {
            return true;
        }
        //anObject是否是右边类的实例?
        if (anObject instanceof String) {
        	//转成String类型,开始一个一个字符比较,全相等才返回true,有一个不同则返回false
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

• 为什么h*31,可能通过统计不同字符串乘以31得到的值相等的概率低,也或许乘31只需要右移5位然后减1,这样运算比较快吧.
• 下面这种情况肯定两个hashCode相等,即使String不重写两个方法

public class B {
    public static void main(String[] args) {
        String a="小明";
        String a1="小明";

        System.out.println(a1==a);
        System.out.println(a.hashCode());
        System.out.println(a1.hashCode());
        System.out.println(a1.equals(a));

    }

}

• 下面这种不重写equals是不会相等的,因为重写了两个方法才相等.

public class B {
    public static void main(String[] args) {
        String a="小明";
        String A=new String("小明");

        System.out.println(A==a);  //false 
        System.out.println(a.hashCode());  //756703
        System.out.println(A.hashCode());  //756703
        System.out.println(A.equals(a));  //true
    }

}

• 运行结果 两个地址肯定是不相同的,但是他们调用两个方法的结果是相同的

false
756703
756703
true

想了解字符串的一些注意事项可以看完这篇文章
字符串一些细节点这个,希望大家都多度支持,一起挖基础