java —— equals 与 ==

equals

　　众所周知，java 中的所有的类都继承自 Object 这个超类 ，他就是Java所有类的父类或祖先类，Object类里面有一个equals方法，并且提供了默认的实现，如下所示。

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

　　从上面代码得知：如果自定的类没有覆盖 equals 方法，那么该方法是来判断两个对象是否相等。

　　而在实际使用常常需要覆写这个方法来改变判断两个对象在实际现实中是否相等。比如，判断学生是否为同一个人时，经常以学号（ID）来进行判断。如下代码片段，

public boolean equals(Object otherObject){

        //1. 出于性能优化的考虑，首先判断是否是自身比较 

        if(this == otherObject) return true; 

    //2. 出于安全性的检测

    if(null == otherObject) return false;

    //3. 测试比较的对象是否是同一类型

        if(!(otherObject.getClass() == this.getClass())) return false;

    //4. 类型转换

    PingPong other = (PingPong)otherObject;

    //5. 根据业务需要对需要比较的成员变量进行逐一比较

    //如果比较项都相同则返回为true

    if(other.getId() == this.getId) return true;

    return false;

}

　　在Java规范中，它对equals()方法的使用必须要遵循如下几个规则：

　　equals 方法在非空对象引用上实现相等关系：

　　1、自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。

　　2、对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true。

　　3、传递性：对于任何非空引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 应返回 true。

　　 4、一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y) 始终返回 true 或始终返回 false，前提是对象上 equals 比较中所用的信息没有被修改。

　　5、 对于任何非空引用值 x，x.equals(null) 都应返回 false。

　　对于上面几个规则，我们在使用的过程中最好遵守，否则会出现意想不到的错误。

" == " 与 equals 的不同

　　== 是一个操作符，操作符的左右两边变量既可以是基本类型也可是对象类型。当==应用于基本类型的时候，是用于判断操作符左右两边的变量存储的值是否相等；当==应用于对象类型的时候是用于判断操作符左边的对象是否是同一对象（地址值是否相等）。

案例分析

String str1 = "猜一猜";
String str2 = "猜一猜";
String str3 = new String("猜一猜");
boolean  ret;
ret = (str1 == str2);         //?
ret = (str1.equals(str2));    //?
ret = (str1 == str3);        //?
ret = (str1.equals(str3));     //?
ret = (str1 == str1.trim());    //?

ret = (str1 == str2); 
//true：str1与str2均为直接量。对于直接量的字符串,Java从性能上有优化机制：
//Java为了避免在一个系统中产生大量的String对象；
//设计了一个字符串常量池容纳String对象。创建一个字符串
//时，首先检查池中是否有字符串内容相等的字符串；如果有则
//直接返回池中该对象的引用；否则创建并放入池中.
ret = (str1.equals(str2));
//true：String类的equals方法用于检查字符串内容相等
ret = (str1 == str3);    
//false：直接量和对象之间的关系与两个直接量之间的关系不同
ret = (str1.equals(str3)); 
//true：String类的equals方法用于检查字符串内容相等
ret = (str1 == str1.trim());
//true：调用trim方法的字符串对象，返回值仍然为该对象的引用

输出结果

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;
    }

String 类的 equals 重写代码

为什么 字符串的直接赋值与 new 一个对象用 “==”比较会不一样？

　　java中，所有的引用放在栈内存中，所有的值放在堆内存中，而堆又分好多块，new 对象必然开辟对空间，放在大众的堆空间中，这部分是内存独立的，
　　所以如果有字符串String s1=new String(“猜”);那么如果有String s2=new String(“猜”);那么s1,s2都会被分配内存空间，地址就不一样。
　　而直接赋值是放在堆空间中的“串池”中，它里面放的是具体的数值，常量，比如说ASCII，基本数据，等等，这块区域的数值是共享的。也就是说：
　　假如有字符串String s1 = "猜"和字符串String s2="猜";那么字符串s2是不占用内存空间的，会直接把s2的引用指向“串池”中的“123”，所以s1和s2的地址一样。
　　至于直接new 的和直接赋值的，不用说了，存放的内存空间都不一样，自然地址也就不一样，而操作符“==" 是直接比较地址值。

小结

equals是类的成员方法

只能用于对象之间的比较，不能用于基本类型；

　　如果一个自定义类不覆盖Object的equals方法，那么equals就是用于判断两个对象是否是同一个引用，意即是否是指向同一内存区域的首地址。

　　如果自定义类覆盖了Object的equals方法，那么则按照该方法自定义的业务逻辑进行判断，一般是用于判断两个对象的全部或部分内容是否相同。

==  既可以用于对象之间的比较，也可以用于基本类型。

　　== 一方面可判断基本类型的值是否相等。

　　Java基本类型包括了浮点型（float、double）；整型（byte、short、int、long）；字符型（char）；布尔型（boolean）。但是，由于精度的问题，不建议==用于浮点型的比较，可采用两个浮点数相减并取绝对值，如果小于一个足够小的数（比如1.E-6）就认为是相等的。

　　==如果用于对象之间，则用于判断两者之间是否是同一个对象（指向的地址值）。