.equals()、.hashcode()和==之间的联系与差异

在说这个问题之前,我先说一下几个概念

  • 内存地址:存放对象的物理地址
  • hashcode: hashcode是jvm为对象生成的一个int类型的数,并且保证在同一个jvm中,对于同一个对象每次返回的都是同一个hashcode(具体生成方式请看hashcode详解)
  • hash冲突:hashcode发生重复

我们先看看在Object中是怎样定义.equals()和.hashcode()的

public boolean equals(Object obj) {
        return (this == obj);
    }
public native int hashCode();

我们可以看到equals方法实际上是调用了 == 方法,而 == 是比较对象的内存地址。所以默认的equals方法是比较的内存地址。
hashcode在1.8中的生成其实是和内存地址无关的,它和线程以及对象生成的顺序有关(具体生成方式请看hashcode详解)

在Object中的.equals()和.hashCode()方法并不能很好的解决生活中的一些问题,比如说,我们new了两个学生对象,学生的id和name都是一样的,在jvm中会认为这是两个对象,可在现实生活中我们却认为这是同一个对象,于是这里出现了歧义,为了解决这种歧义我们需要重写.equals()方法。

public class Student {
    private int id;
    private String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Student))
            return false;
        Student s= (Student) obj;
        if (id==s.id && name.equals(s.name))
            return true;
        return false;
    }

    public static void main(String[] args) {
        Student student1=new Student(1,"张三");
        Student student2=new Student(1,"张三");
        System.out.println(student1==student2);
        System.out.println(student1.equals(student2));
    }
}

运行结果:
false
true

结果看起来很完美,通过重写equals方法,已经做到了辨认学生的目的。

假如我们遇到了要把学生去重的场景,最简单的办法就是把学生对象丢进一个set里面然后再拧出来,我们来看看结果会怎么样?

public class Student {
    private int id;
    private String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Student))
            return false;
        Student s= (Student) obj;
        if (id==s.id && name.equals(s.name))
            return true;
        return false;
    }

    public static void main(String[] args) {
        Student student1=new Student(1,"张三");
        Student student2=new Student(1,"张三");
        System.out.println(student1==student2);
        System.out.println(student1.equals(student2));
        HashSet<Student> set=new HashSet<Student>();
        set.add(student1);
        set.add(student2);
        System.out.println(set.size());
    }
}

输出是
false
true
2

发现并没有去重,为什么呢?因为java中我们最常用的set是hashset,hashset实际上就是没有value的hashmap,他会先把对象的hashcode按照一定的算法定位到一个数组元素上去,如果这个数组上有元素就会进行比较,相同就替换,不同就挂载到下面,因为这两个student的hashcode是不同的,所以这两个student就被定位到不同的数组元素上去了,所以就被认为是两个独立的对象。(hashmap原理)

这种情况下我们可以对hashcode进行重写,让拥有相同id和name的student都拥有相同的hashcode

public class Student {
    private int id;
    private String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Student))
            return false;
        Student s= (Student) obj;
        if (id==s.id && name.equals(s.name))
            return true;
        return false;
    }

    @Override
    public int hashCode() {
        return (id+name).hashCode();
    }

    public static void main(String[] args) {
        Student student1=new Student(1,"张三");
        Student student2=new Student(1,"张三");
        System.out.println(student1==student2);
        System.out.println(student1.equals(student2));
        HashSet<Student> set=new HashSet<Student>();
        set.add(student1);
        set.add(student2);
        System.out.println(set.size());

    }
}

结果如下
false
true
1

通过重写hashcode和equals方法我们可以解决实际问题中jvm和人类认知对象不同的差异。

hashcode是一个int类型的,大小是2^32-1,而对象却可以是无穷无尽的,因此可以推断出hashcode是有可能发生重复的,这种重复我们就称之为hash冲突。

一个好的hash算法应该尽量的去避免这种冲突。

我们用的很多类其实都已经重写了hashcode和equals方法,我详细来分析一下String类型

//String实际是一个final修饰的char数组
 private final char value[];
 //实际上是一个hash的缓存
 private int hash;
  public boolean equals(Object anObject) {
  		//先判断内存地址是否相等,是就返回true
        if (this == anObject) {
            return true;
        }
        //再判断要比较的对象是否是String类型,是就往下走,不是就返回false
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            //先比较长度,长度不对返回false
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                //直接比较对应字符,如果全部相等才会返回true
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }
    public int hashCode() {
        int h = hash;
       //缓存没有  并且有值才会去生成hashcode  
        if (h == 0 && value.length > 0) {
            char val[] = value;
			//每一个char都会参与运算,保证同一个String 即使内存地址不一样 返回的hashcode都是一样的
            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

由于String的hashCode的生成只与内容有关,而与其它因素无关,所以相同内容的String在任何机器上生成的hashcode都是一致的。这个特性我们运用得很多,比如说对数据库进行拆分,我们把某个列对hash取模,然后把数据分到不同机器上的不同的数据库中去,然后要取数据的时候,在对hash进行取模来决定要去哪个数据库去取值。

ok,我们来总结一下:
.equals()在Object中与 == 是等价的,但是.equals()在语义上是对象的内容相等,因此很多时候都会对.equals()进行重写,而 == 则是对内存地址进行比较而不关心对象内容。

.hashcode()的存在则是为了便于我们对对象的操作,比如说使用hash算法来加速数据的存取,原则上来说,我们应该保证.equals()相等的对象的.hashcode()也是相等的,反之则不需要保证。因此在必要的时候我们要对hashcode进行重写。

hashcode实质上是一个int类型的数,hashcode是可以重复的。

你可能感兴趣的:(java基础)