1）“==”运算符用来比较两个变量的值是否相等。也就是说，该运算符用于比较变量对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能使用“==”运算符。

具体而言，如果两个变量是基本数据类型，可以直接使用“==”运算符来比较其对应的值是否相等。如果一个变量指向的数据是对象（引用类型），那么，此时涉及了两块内存，对象本身占用了一块内存（堆内存），变量也占用一块内存，例如，对于赋值语句：

String s = new String();

变量s占用一块存储空间，而new String()则存储在另外一块存储空间里，此时，变量s所对应内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等（这两个对象是否指向同一块存储空间），这时候就可以用“==”运算符进行比较。但是，如果要比较这两个对象的内容是否相等，那么用“==”运算符就无法实现了。

2）equals是Object类提供的方法之一。每一个Java类都集成自Object类，所以每一个对象都具有equals这个方法。Object类中定义的equals(Object)方法的情况下，equals(Object)与“==”运算符一样，比较的是引用。

相比“==”运算符，equals(Object)方法的特殊之处就在于它可以被覆盖，所以可以通过覆盖的方法让它不是比较引用而是比较数据内容，例如String类的equals方法是用于比较两个独立对象的内容是否相同，即堆中的内容是否相同，以下面的代码为例：

 String s1 = new String("Hello"); 

String s2 = new String("Hello");

两条new语句创建了两个对象，然后用s1、s2这两个变量分别指向一个对象，这是两个不同的对象，它们的首地址是不同的，即s1和s2中存储的数值是不相同的，所以，表达式s1==s2将返回false，而这两个对象中的内容是相同的，所以，表达式s1.equals(s2)将返回true。

如果一个类没有自己定义equals()方法，那么它将继承Object类的equals()方法，Object类的equals()方法的实现代码如下：

 boolean equals(Object object){

            return this==object;

}

通过以上例子可以说明，如果一个类没有自己定义equals()方法，它默认的equals()方法（从Object类继承的）就是使用“==”运算符，也是在比较两个变量指向的对象是否是同一对象，此时使用equals()方法和使用“==”运算符会得到同样的结果。若比较的是两个独立的对象，则总返回false。如果编写的类希望能够比较该类创建的两个实例对象的内容是否相同，那么必须覆盖equals()方法，由开发人员自己编写代码来决定在什么情况下即可认为两个对象的内容是相同的。

3）hashCode()方法是从Object类中继承过来的，它也用来鉴定两个对象是否相等。Object类中的hashCode()方法返回对象在内存中地址转换成的一个int值，所以如果没有重写hashCode()方法，任何对象的hashCode()方法都是不相等的。

虽然equals()方法也是用来判断两个对象是否相等的，但是它与hashCode()方法是有区别的。一般来讲，equals()方法是给用户调用的，如果需要判断两个对象是否相等的，可以重写equals()方法，然后在代码中调用，这样就可以判断它们是否相等了。对于hashCode()方法，用户一般不会去调用它，例如在hashmap中，由于key是不可以重复的，它在判断key是否重复时就判断了hashCode()方法，而且也用到了equals()方法。此处“不可以重复”指的是equals()和hashCode()只要有一个不等就可以了。所以，hashCode()方法相当于是一个对象的编码，就好像文件中的md5，它与equals()方法的不同之处就在于它返回的是int型，比较起来不直观。

 

一般在覆盖equals()方法的同时也要覆盖hashCode()方法，否则，就会违反Object.hashCode的通用约定，从而导致该类无法与所有基于散列值(hash)集合类(HashMap、HashSet和Hashtable)结合在一起正常运行。

hashCode()方法的返回值和equals()方法的关系如下：

x.equals(y)返回true，即两个对象根据equals()方法比较是相等的，那么调用这两个对象中任意一个对象的hashCode()方法都必须产生同样的整数结果。如果x.equals(y)返回false，即两个对象根据equals()方法比较是不相等的，那么x和y的hashCode()方法的返回值有可能相等，也有可能不相等。反之，hashCode()方法的返回值不相等，一定能推出equals()方法的返回值也不相等，而hashCode()方法的返回值相等，equals()方法的返回值则可能相等，也可能不相等。

面试题：

1、Object若不重写hashCode（）的话，hashCode是如何计算出来的？

答：默认情况下，Object中的hashCode() 对对象的jvm内存地址进行映射。也就是说如果对象不重写该方法，则返回相应对象的JVM内存地址的映射。源码如下：

public native int hashCode();

new People("Jack", 12)和new People("Jack", 12)表面看相同，但确是两个实例对象，地址不同，所以两者的hashCode不相同。

根据这个方法的声明可知，该方法返回一个int类型的数值，并且是本地方法，因此在Object类中并没有给出具体的实现。

2、Object若不重写equals（）的话，equals（）方法是如何比较的？

答：直接比较两个对象是否相等，通过判断两个对象的地址是否相等（即，是否是同一个对象）来区分它们是否相等，源码如下：

public boolean equals(Object obj) {

        return (this == obj);

    }

注：若是基本数据类型，==和equals比较的都是值。

     若是对象，==比较的是地址，equals比较的是值。

3、hashCode和equals的关系？

若两个对象的hashCode相等，则equals不一定为true。

若equals为true，则两个对象的hashCode一定相等。

4、若重写equals（）方法需要注意哪些问题？

1）自反性：x.equals(x)一定返回true

2）对称性：x.equals(y)返回true当且仅当y.equals(x)

3）传递性：x.equals(y)且y.equals(z)，则x.equals(z)为true

4）一致性：若x.equals(y)返回true，则不改变x，y时多次调用x.equals(y)都返回true

5）对于任意的非空引用值x，x.equals(null)一定返回false。

6）若重写equals方法，一定要重写hashCode方法。否则相等对象（equals返回true）可能具有不同的散列码（hashCode）。

equals重写举例：

  @Override

    public boolean equals(Object obj) {

        // TODO Auto-generated method stub

        return this.name.equals(((People)obj).name) && this.age== ((People)obj).age;

    }

即，若两个人的名字和年龄相等，则可以认为是同一个人。

5、若重写hashCode（）方法需要注意哪些问题？

重写hashCode方法，让equals方法和hashCode方法始终在逻辑上保持一致性.

 @Override

    public int hashCode() {

        // TODO Auto-generated method stub

        return name.hashCode()*37+age;

    }

注：hashCode中所用的属性和equals中所用的属性一样的，这样如果两个对象根据equals方法比较是不等的，则hashCode方法一定返回不同的整数。

6、String类的hashCode（）是如何计算的？

注：value[]是存储String的内容的，即当使用String str = "abc";的时候，本质上，"abc"是存储在一个char类型的数组中的。

hash是String实例化的hashcode的一个缓存，默认值是0，因为String经常被用于比较，比如在HashMap中key是Stringl类型。如果每次进行比较都重新计算hashcode的值的话，那无疑是比较麻烦的，而保存一个hashcode的缓存无疑能优化这样的操作。

public int hashCode() {

        int h = hash;

        if (h == 0 && value.length > 0) {//该字符串的hash值没有被计算过，并且字符串存在。

            char val[] = value;

            for (int i = 0; i < value.length; i++) {

                h = 31 * h + val[i];

            }

            hash = h;

        }

        return h;

 }

String计算hashCode的方法实际可以看作是一种对字符加权求和的算法，在前面的字符的权重大。

这样前缀相同的字符串和hash值都落在邻近的区间。这样可以节省内存，因为hash值相邻，这样用于存储的数组可以小一些。比如当用的HashMap，以String为key的类型时。

以31为倍数，原因是因为31是一个奇质数，所以31*i=32*i-i=(i<<5)-i，这种位移与减法结合的计算相比一般的运算快很多。