深入理解Java原始数据类型和包装类关于==和equals的比较

ゝ一纸荒年。 2022-06-12 12:37 259阅读 0赞

## 1.运算符 == ##

**对于六大Java数值类原始数据类型**，==比较的是数值

**对于六大Java原始数据类型对应的包装类**，==比较的是内存地址

## 2.equals() ##

equals()方法只有对象才有，所以我们讨论一下原始数值类型的包装在的equals（）方法吧！

**对于六大Java原始数据类型对应的包装类，equals都是比较值。**

有源码为证如下所示：

**Byte类**

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

**Short类**

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

**Integer类**

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

**Long类**

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

**Double类**

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

/**
         * 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));
        }

**Float类**

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

/**
    
         * 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));
        }

[SouthEast]: /images/20220612/133bae03aa124f2e98b03703dd390097.png
[SouthEast 1]: /images/20220612/76ac2cb9f2fe423ea53e72bea3ff540b.png
[SouthEast 2]: /images/20220612/2e42d1cdba0d4c5c8cda88c84be090bd.png
[SouthEast 3]: /images/20220612/6b0fe27588c84be5b982f893e962599a.png
[SouthEast 4]: /images/20220612/70db980bf3444dd68e54f41e37a25d12.png
[SouthEast 5]: /images/20220612/bf319d0f0d864aa28fd2ae289b869412.png