听说你还搞不定java中的==和equals？

相信很多读者关于==和equals懂了又懵，懵了又懂，如此循环，事实上可能是因为看到的博客文章之类的太多了，长篇大论，加上一段时间的洗礼之后就迷路了。本篇文章再一次理清楚。当然如果觉得本文太啰嗦的话，当然我也考虑到了，因为我也不喜欢长篇大论啰里啰嗦比比叨叨胡搅蛮缠的文章，毕竟大家入门java 的时候就知道个大概了，因此记住一句话就好了：equals本身和 == 没有区别，对于基本数据都是比较值，对于引用类型，则比较的是所指向的对象的地址！其他类在继承Object类之后对equals方法重写，所以表现的是比较里面的内容！具体比较的则要看自己是怎么重写的。

好了，如果有兴趣的就看下文，当然不感兴趣的大佬可以点个赞直接走了，不用看了，会了还看个*啊，楼主你个憨憨（皮一下很开心）

1、原生的equals()方法本身与 “ == ”没有任何区别！

从java语言本质上来讲，"=="属于JAVA语言的运算符，而equals则是根类Object的一个方法。

关于Object类的equals()方法，我们可以看看其源码

  /*
     * @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) {
    return (this == obj);
}

是的，equals底层其实就是“ == ”，也就是说，原生的equals()方法本身与 “ == ”没有任何区别！唯一的区别则是基本类型没有继承Object类，所以基本类型没有equals()方法，也就是说基本类型只能使用“ == ”判断值是否相等。

既然原生的equals()方法本身与 “ == ”没有任何区别，那么我们对运算符 “ == ”的使用有所了解即可！

运算符 “ == ”其具体作用是用来比较值是否相等，这里分两中情况：

• 1、基本数据类型的变量，则直接比较其存储的 “值”是否相等；

• 2、引用类型的变量，则比较的是所指向的对象的地址是否相等；

到这里我们可以初步确认原生的equals()方法本身与 “ == ”没有任何区别！作用正是如上。

2、equals()方法的重写

但是重点来了，因为对于equals()方法我一直在强调原生二字。是的，让很多初学者疑惑的点就在这里：equals()方法的重写！

在JDK中，诸如String、Date等类对equals方法进行了重写，以String为例，这里感兴趣的读者可以一起看看String类中重写的equals()方法，当然跳过也问题不大

/**
     * Compares this string to the specified object.  The result is {@code
     * true} if and only if the argument is not {@code null} and is a {@code
     * String} object that represents the same sequence of characters as this
     * object.
     *
     * @param  anObject
     *         The object to compare this {@code String} against
     *
     * @return  {@code true} if the given object represents a {@code String}
     *          equivalent to this string, {@code false} otherwise
     *
     * @see  #compareTo(String)
     * @see  #equalsIgnoreCase(String)
     */
    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            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;
    }

从源码中可以看出，首先该方法判断比较的是所指向的对象地址是否相等，如果相同直接返回true，如果不相同进行下一个if判断，第二个if判断大致意思则是比较其存储的 “值”是否相等，也就是比较内容值！相同就返回true，比如两个new String对象“AAA”和“AAA”，这里虽然对象地址不相等，但是内容相等，所以同样返回true。

这里我就想给各位出个典型的String例子了：

public static void main(String[] args) {
       String a = "宜春";
       String b = new String("宜春");
       String c = b; //注意这里是引用传递，意思是c也指向b指向的内存地址
       
       System.out.println(a == b);  //false
       System.out.println(a == c);  //false
       System.out.println(b == c);  //true
       System.out.println(a.equals(b));  //true
       System.out.println(a.equals(c));  //true
       System.out.println(b.equals(c));  //true
    }

【特别注意：String类型属于引用类型】

解析：
（1）a == b？意思是地址指向的是同一块地方吗？很明显不一样。

（2）a == c？意思是地址指向的是同一块地方吗？很明显不一样。

（3）b == c？意思是地址指向的是同一块地方吗？很明显内容一样，所以为true。

（4）a.equals( b )？意思是地址指向的内容一样嘛？一样。

（4）a.equals( c )？意思是地址指向的内容一样嘛？一样。

（4）b.equals( c )？意思是地址指向的内容一样嘛？一样。

当然，你可能还是有点疑惑，那么结合下面这张图再理解上面的解析，你可能就恍然大悟了

OK。现在能理解嘛？你你你......不用回答，我知道你理解了（理直气壮）。当然值得注意一点的是String中intern()方法，先看一段程序：

    public static void main(String[] args) {
       String a = "宜春";
       String b = new String("宜春");
       b=b.intern();

       System.out.println(a == b);  //true
       System.out.println(a.equals(b));  //true
    }

intern方法的意思是检查字符串池里是否存在，如果存在了那就直接返回为true。因此在这里首先a会在字符串池里面有一个，然后 b.intern()一看池子里有了，就不再新建new了，直接把b指向它。

3、为什么要重写equals方法？

不知道大家有没有想过这个问题。当然答案也是很简单的，因为程序员比较字符串一般比较其内容就好了，比较内存地址是不是同一个对象就好像没啥意义了，重写equals方法就很方便用来比较字符串的内容了。

其实除了诸如String、Date等类对equals方法进行重写，我们在实际开发中，我们也常常会根据自己的业务需求重写equals方法.

举个栗子：
我们的需求就是如果两个学生对象姓名、身份证号、性别相等，我们认为两个学生对象相等，不一定需要学生对象地址相同。

学生A的个人信息（姓名：如花,性别:女，身份证号：123，住址：广州），学生A对象地址为0x11，
学生B的个人信息（姓名：如花,性别:女，身份证号：123，住址：深圳），学生A对象地址为0x12，

这时候如果不重写Object的equals方法，那么返回的一定是false不相等，这个时候就需要我们根据自己的需求重写equals()方法了。具体equals方法的重写代码如下：

// 重写equals方法
	@Override
	public boolean equals(Object obj) {
		if(!(obj instanceof Student)) {
       // instanceof 已经处理了obj = null的情况
			return false;
		}
		Student stuObj = (Student) obj;
		// 对象地址相等
		if (this == stuObj) {
			return true;
		}
		// 如果两个对象姓名、身份证号码、性别相等，我们认为两个对象相等
		if (stuObj.name.equals(this.name) && stuObj.sex.equals(this.sex) && stuObj.IDnumber.equals(this.IDnumber)) {
			return true;
		} else {
			return false;
		}
	}

开发中这样设计，才能符合我们的生活！到这里我就不信了你还搞不定==和equals！

可是一涉及重写equals方法的同时又衍生了下面一个问题。

4、重写equals方法之后要不要重写hashCode()方法？

当然这个问题要讨论，又要长篇大论哔哔一大堆了，有空写一篇这样的文章吧专门讨论讨论这个问题，当然园子里的大佬们也写了一大堆！可以自行去了解了解。本篇文章简单聊聊，点到即可。

首先hashCode()方法是Object类的一个方法，源码如下：

/**
     * 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}.
     * <p>
     * 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.
     * <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.
     * <li>It is <em>not</em> 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.
     * </ul>
     * <p>
     * As much as is reasonably practical, the hashCode method defined by
     * class {@code Object} does return distinct integers for distinct
     * objects. (This is typically implemented by converting the internal
     * address of the object into an integer, but this implementation
     * technique is not required by the
     * Java<font size="-2"><sup>TM</sup></font> programming language.)
     *
     * @return  a hash code value for this object.
     * @see     java.lang.Object#equals(java.lang.Object)
     * @see     java.lang.System#identityHashCode
     */
    public native int hashCode();

可以看出hashCode()方法返回的就是一个int数值，从方法的名称上就可以看出，其目的是生成一个hash码。hash码的主要用途就是在对对象进行散列的时候作为key输入，据此很容易推断出，我们需要每个对象的hash码尽可能不同，这样才能保证散列的存取性能。

事实上，Object类提供的默认实现确实保证每个对象的hash码不同（在对象的内存地址基础上经过特定算法返回一个hash码）。Java采用了哈希表的原理。哈希算法也称为散列算法，是将数据依特定算法直接指定到一个地址上。初学者可以这样理解，hashCode方法实际上返回的就是对象存储的物理地址（实际上不是）。

想要知道hashCode的作用，必须要先知道Java中的集合。

Java中的集合List的元素是有序的，元素可以重复；Set元素无序，但元素不可重复。这我们都清楚。但是你有没有想过这样一个问题：要想保证元素不重复，可两个元素是否重复应该依据什么来判断呢？

每错这里就是用Object.equals方法了。但是，如果每增加一个元素就检查一次，那么当元素很多时，后添加到集合中的元素比较的次数就非常多了。也就是说，如果集合中现在已经有1000个元素，那么第1001个元素加入集合时，它就要调用1000次equals方法。这显然会大大降低效率。

那怎么解决呢？我们可以在Java集合框架中得到验证。由于HashSet是基于HashMap来实现的，所以这里只看HashMap的put方法即可。源码如下：

public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);
        //这里通过哈希值定位到对象的大概存储位置
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            //if语句中，先比较hashcode，再调用equals()比较
            //由于“&&”具有短路的功能，只要hashcode不同，也无需再调用equals方法
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
}

正如源码中注释所述，“&&”具有短路的功能，只要hashcode不同，也无需再调用equals方法。是的，Java采用了哈希表的原理。 哈希表具有优越的查询性能，就像九九乘法表2*3=6你能很轻易知道，但是哈希表难免还会出现哈希冲突,只是概率极低。

如此设计，这样一来，当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理位置上。
如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存，不相同就散列其它的地址。所以这里存在一个冲突解决的问题。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。

因此并不是重写了equals方法就一定要重写hashCode方法，只有用到HashMap,HashSet等Java集合的时候重写了equals方法就一定要重写hashCode方法。用不到哈希表仅仅重写equals()方法也OK的。

Java官方建议 重写equals()就一定要重写hashCode()方法。毕竟实际开发场景中常常用到Java集合

5、eqauls方法和hashCode方法关系

Java对于eqauls方法和hashCode方法是这样规定的：

1、如果两个对象equals为true ，他们的hashcode一定相等。
2、如果两个对象equals为false，他们的hashcode有可能相等。
3、如果两个对象hashcode相等，equals不一定为true。
4、如果两个对象hashcode不相等，equals一定为false。

最后，若有不足或者不正之处，欢迎指正批评，感激不尽！

欢迎各位关注我的公众号，里面有一些java学习资料和一大波java电子书籍，比如说周志明老师的深入java虚拟机、java编程思想、核心技术卷、大话设计模式、java并发编程实战.....都是java的圣经，不说了快上Tomcat车，咋们走！最主要的是一起探讨技术，向往技术，追求技术，说好了来了就是盆友喔...