Java源码解析：深入理解==和equals()

忘是亡心i 2022-06-12 14:12 214阅读 0赞

## **1.结论** ##

### **1.1 ==** ###

> 1.所有原始数据类型，比较的是值  
> 2.所有的对象比较的是内存地址  
> **注意点：Integer类有对象池\[-128,127\]**

### **1.2 equals()方法** ###

> 1.未重写的equals()方法，默认比较内存地址  
> 2.String类和原始数据类型中重写了equals()方法，所有比较的是值，而非内存地址

### **1.3 建议** ###

因此，要判断两个对象是不是同一个对象，最准确比较方式是==  
但若想将属性值相同的两个对象，判断为同一个对象，则建议用重写的equals()方法【比如set集合中去重】

## **2. 一起看源码** ##

== 是Java内部定义的，没有源码可看，就不管了。这里主要看一下equals（）方法的源码。

原始数据类类型对应的包装类的equals方法中都有一句话如下所示：

**The result is \{@code true\} if and only if the argument is not \{@code null\} and is a \{@code 包装类\} object that represents a \{@code 对应原始数据类型\} with the same value as the \{@code 对应原始数据类型\} represented by this object.**

意思是：只要包装类对应的原始数据类型的值是一样的，那么equals返回true。（前提：对象不为null）

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

**Character类**  
![这里写图片描述][SouthEast]

**Byte类**  
![这里写图片描述][SouthEast 1]

**Short类**  
![这里写图片描述][SouthEast 2]

**Integer类**  
![这里写图片描述][SouthEast 3]

**Long类**

![这里写图片描述][SouthEast 4]

**Float类**

/**
    
         * Compares this object against the specified object.  The result
         * is {
       @code true} if and only if the argument is not
         * {
       @code null} and is a {
       @code Float} object that
         * represents a {
       @code float} with the same value as the
         * {
       @code float} represented by this object. For this
         * purpose, two {
       @code float} values are considered to be the
         * same if and only if the method {
       @link #floatToIntBits(float)}
         * returns the identical {
       @code int} value when applied to
         * each.
         *
         * <p>Note that in most cases, for two instances of class
         * {
       @code Float}, {
       @code f1} and {
       @code f2}, the value
         * of {
       @code f1.equals(f2)} is {
       @code true} if and only if
         *
         * <blockquote><pre>
         *   f1.floatValue() == f2.floatValue()
         * </pre></blockquote>
         *
         * <p>also has the value {
       @code true}. However, there are two exceptions:
         * <ul>
         * <li>If {
       @code f1} and {
       @code f2} both represent
         *     {
       @code Float.NaN}, then the {
       @code equals} method returns
         *     {
       @code true}, even though {
       @code Float.NaN==Float.NaN}
         *     has the value {
       @code false}.
         * <li>If {
       @code f1} represents {
       @code +0.0f} while
         *     {
       @code f2} represents {
       @code -0.0f}, or vice
         *     versa, the {
       @code equal} test has the value
         *     {
       @code false}, even though {
       @code 0.0f==-0.0f}
         *     has the value {
       @code true}.
         * </ul>
         *
         * This definition allows hash tables to operate properly.
         *
         * @param obj the object to be compared
         * @return  {
       @code true} if the objects are the same;
         *          {
       @code false} otherwise.
         * @see java.lang.Float#floatToIntBits(float)
         */
        public boolean equals(Object obj) {
            return (obj instanceof Float)
                   && (floatToIntBits(((Float)obj).value) == floatToIntBits(value));
        }

**Double类**

/**
         * Compares this object against the specified object.  The result
         * is {
       @code true} if and only if the argument is not
         * {
       @code null} and is a {
       @code Double} object that
         * represents a {
       @code double} that has the same value as the
         * {
       @code double} represented by this object. For this
         * purpose, two {
       @code double} values are considered to be
         * the same if and only if the method {
       @link
         * #doubleToLongBits(double)} returns the identical
         * {
       @code long} value when applied to each.
         *
         * <p>Note that in most cases, for two instances of class
         * {
       @code Double}, {
       @code d1} and {
       @code d2}, the
         * value of {
       @code d1.equals(d2)} is {
       @code true} if and
         * only if
         *
         * <blockquote>
         *  {
       @code d1.doubleValue() == d2.doubleValue()}
         * </blockquote>
         *
         * <p>also has the value {
       @code true}. However, there are two
         * exceptions:
         * <ul>
         * <li>If {
       @code d1} and {
       @code d2} both represent
         *     {
       @code Double.NaN}, then the {
       @code equals} method
         *     returns {
       @code true}, even though
         *     {
       @code Double.NaN==Double.NaN} has the value
         *     {
       @code false}.
         * <li>If {
       @code d1} represents {
       @code +0.0} while
         *     {
       @code d2} represents {
       @code -0.0}, or vice versa,
         *     the {
       @code equal} test has the value {
       @code false},
         *     even though {
       @code +0.0==-0.0} has the value {
       @code true}.
         * </ul>
         * This definition allows hash tables to operate properly.
         * @param   obj   the object to compare with.
         * @return  {
       @code true} if the objects are the same;
         *          {
       @code false} otherwise.
         * @see java.lang.Double#doubleToLongBits(double)
         */
        public boolean equals(Object obj) {
            return (obj instanceof Double)
                   && (doubleToLongBits(((Double)obj).value) ==
                          doubleToLongBits(value));
        }

[SouthEast]: /images/20220612/50878413df794c149afdd58416bf60bc.png
[SouthEast 1]: /images/20220612/1010c09bba4a4c0ab935a18f362656e6.png
[SouthEast 2]: /images/20220612/3391050c228841b289da1308a1740d79.png
[SouthEast 3]: /images/20220612/32889a5291ce49e18ab619ea9ab7578a.png
[SouthEast 4]: /images/20220612/fbf81a933d5c4f34867db2813ebbfad2.png