犯错的体会，equals和==区别

在公司设计一个缓存机制时，用到了一个判断，判断两个字符串是否相等，由于以前没关注equals和==的区别，于是随意的用了==，结果可想而知，判断永远不成立，直接跳到异常，此时才开始重视equals和==之间的区别

概括：

          ==在基本类型中（byte,short,char,int,long,float,double,boolean ）比较的是内容，在引用类型中，判断的是内存地址，除非是同一个对象是true，否则是false

          equals初始行为是判断对象的内存地址，和==一样，但是在很多复合数据类型中，equals方法都被覆盖了，不再是比较内存中存放地址，一般都会覆盖此方法，建立判断对象的依据

          注意：String中有些不同，在String对象建立时会有字符串缓冲区，也就是字符串常量池，例如：String a = “abc”； String b = “abc” 建立字符串a时会先去查找字符串缓冲区有没有abc，如果没有，则创建abc，建立b时，查找缓冲区，发现有abc，则把a的地址赋予b，故String中比较会有些不同

在网上看到一篇博客写的比我详细，故做一些修改进行转载

##1点击打开链接

1. ==可以用来比较基本类型和引用类型（对象），判断内容和内存地址

2. equals只能用来比较引用类型,它只判断内容。该函数存在于老祖宗类 Java.lang.Object

java中的数据类型，可分为两类：

1.基本数据类型，也称原始数据类型。byte,short,char,int,long,float,double,boolean

  他们之间的比较，应用双等号（==）,比较的是他们的值。

2.复合数据类型(类)

  当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，

  所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。

JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法。

  这个方法的初始行为是比较对象的内存地 址，但在一些类库当中这个方法被覆盖掉了。

  如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。

对于复合数据类型之间进行equals比较，在没有覆写equals方法的情况下，

  他们之间的比较还是基于他们在内存中的存放位置的地址值的，

  因为Object的equals方法也是用双等号（==）进行比较的，所以比较后的结果跟双等号（==）的结果相同。

二、string之间的判断

[java] view plain copy

String str1 = "hello";//存在于常量池中，堆栈 

String str4 = "hello"; 

String str2 = new String("hello");//存放在堆中 

String str3 = new String("hello"); 

String str5 = str2; 

System.out.println(str1.equals(str2));//true 

System.out.println(str3.equals(str2));//true 

System.out.println(str1==str2);//false 

System.out.println(str2==str3);//false 

System.out.println(str1==str4);//true 

System.out.println(str5==str2);//true 

字符串缓冲池：程序在运行的时候会创建一个字符串缓冲池。

当使用 String str4 = "hello"; 这样的表达创建字符串的时候，

程序首先会在这个String缓冲池中寻找相同值的对象，

在String str1 = "hello";中，str1先被放到了池中，所以在str4被创建的时候，程序找到了具有相同值的 str1

并将str4引用s1所引用的对象"hello"

三、String可以相等的情况

[java] view plain copy

String str1 = "hello"; 

String str2 = new String("hello"); 

str2 = str2.intern(); 

System.out.println(str1==str2);//true 

str3 = str3.intern(); 

System.out.println(str3==str2);//true 

（java.lang.String的intern()方法"abc".intern()方法的返回值还是字符串"abc"，

表面上看起来好像这个方 法没什么用处。

但实际上，它做了个小动作：检查字符串池里是否存在"abc"这么一个字符串.

如果存在，就返回池里的字符串；如果不存在，该方法会 把"abc"添加到字符串池中，然后再返回它的引用。

intern遵循以下规则：对于任意两个字符串 s 和 t，当且仅当 s.equals(t) 为 true 时，

s.intern() == t.intern() 才为 true。

四、两个任意实例间的判断，比如两个Person实例

①直接判断

[java] view plain copy

package com.test; 

public class JavaTest5_Equals { 

    public static void main(String[] args)  { 

        A a1 = new A(); 

        a1.age = 10; 

        a1.home = "浙江"; 

        A a2 = new A(); 

        a2.age = 10; 

        a2.home = "浙江"; 

        System.out.println(a1==a2); 

        System.out.println(a1.equals(a2)); 

    } 

} 

class A { 

    int age; 

    String home; 

} 

输出结果为：

false

false

语句System.out.println(a1==a2);的输出结果毫无疑问应该为 false。

按照类String的情况，语句System.out.println(a1.equals(a2));的输出结果应该是true，但这里却为false。

这是因为编译器所提供的String类已经复写了 eqauls 函数。而我们这里却没有进行相应的操作。

②复写eqauls 函数

解决办法即为重新复写 eqauls 函数。

查阅 API 中的eqauls 函数，我们可以看到：

根据该描述，我们可以复写类 A 中的 equals 函数

方法如下：

第一步：对象为空，false

if(obj==null) { 

        return false; 

第二步：对象不一致，false

if(! (obj instanceof A)) {                                   //格式：obj instanceof Class   obj是对象，  Class是已存在的对象类

            return false; 

第三步：先将对象向下转型为对象类型（不然会报错），再判断自己所设想的相等条件

[java] view plain copy

//重写父类里面的equals 

public boolean equals(Object obj)  { 

    //为空false，类型不一致false，各个成员变量值相等才为true 

    if(obj==null) { 

        return false; 

    } else { 

        if(! (obj instanceof A)) { 

            return false; 

        } else { 

            //没有这一步会出错，因为此时的obj是 Object obj；a1.equals(a2)中的a2是 Object a2 = new A；

            A a = (A)obj;//从泛华到具体类型需要强转 

            if(a.age==this.age && a.home.equals(this.home)) { 

                return true; 

            } 

            return false; 

        } 

    } 

} 

由此，我们可以重新进行判断

[java] view plain copy

package com.test; 

public class JavaTest5_Equals { 

    public static void main(String[] args)  { 

        A a1 = new A(); 

        a1.age = 10; 

        a1.home = "浙江"; 

        A a2 = new A(); 

        a2.age = 10; 

        a2.home = "浙江"; 

        System.out.println(a1==a2); 

        System.out.println(a1.equals(a2)); 

    } 

} 

class A { 

    int age; 

    String home; 

    //重写父类里面的equals 

    public boolean equals(Object obj)  { 

        //为空false，类型不一致false，各个成员变量值相等才为true 

        if(obj==null) { 

            return false; 

        } else { 

            if(! (obj instanceof A)) { 

                return false; 

            } else { 

                 //没有这一步会出错，因为此时的obj是 Object obj；a1.equals(a2)中的a2是 Object a2 = new A；

                A a = (A)obj;//从泛华到具体类型需要强转 

                if(a.age==this.age && a.home.equals(this.home)) { 

                    return true; 

                } 

                return false; 

            } 

        } 

    } 

} 

执行结果为：

false

true

综上，我们即完成了 equals 函数的复写工作。

另：附上类String中equals函数的复写方法：

[java] view plain copy

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; 

}