equals和==的区别？

经常被简单的理解为equals方法用来比较两个对象是否相同，
而==比较运算符用来比较两个基本数据类型的数值是否相同。

这样的理解无可厚非，但还要透过简单看看本质，才会更清晰。

1，基本数据类型的值。
int x = 3;
int y = 3;
System.out.println(x==y);//true
对于基本数据类型的值只能用 == 比较运算符进行比较是否相等。
那么对于引用数据类型呢？


2，引用数据类型的比较。
Demo d1 = new Demo();
Demo d2 = new Demo();


System.out.println(d1==d2);//比较的是d1和d2的内存地址是否相等。
System.out.println(d1.equals(d2));//Demo类继承了Object类中的equals方法

两条输出语句的结果都是false，为什么？
第一句原因：
用new操作符创建的对象都会在内存中分配一个新的内存地址。
所以两个对象的内存地址不同，为false。

第二句原因：
必须明确equals到底比较的是对象的什么？查看Object类的equals方法源码：
public boolean equals(Object obj) {
return (this == obj);
    }
发现内部使用的也是 == 运算符比较的。
所以在对象的比较相同上 == 和equals是一样的。

那有的同学就问了，那equals方法还有什么用呢？

虽然每个对象都有自己的内存地址，但是每个对象也有自己的一些特有的特征。
比如学生对象有自己的姓名和年龄，希望根据姓名和年龄的相同来判断学生对象是否相同。

这时使用Object类的equals就不能满足需求了，
就需要通过覆盖equals的方式，建立学生对象比较相同的具体内容。

public boolean equals(Object obj){

if(姓名和年龄相同)
  return true;
return false;

}

Student s1 = new Student("zhangsan",20);
Student s2 = new Student("zhangsan",20);
System.out.println(s1==s2); //结果是false，比较两个对象的地址。
System.out.println(s1.equals(s2));//结果是true，比较的是对象的具体内容。

所以，在用Java的类描述对象的时候，如果要判断该对象是否相同时，通常都会
覆盖equals方法，建立根据该对象特征进行比较相同的依据。

这也就是大家常听到的“equals是用来比较对象内容”的原因。

Java中很多对象都覆盖了equals方法，建立该对象特有的比较相同的方式。
比如String，Integer，Boolean等。

         
1. 用 == 进行比较：         

                基本数据类型. 例 byte,short,int,long,float,double,boolean.char,比较的是他们的值。
               
                引用数据类型，比较的是他们在内存中存放的地址，所以，除非是同一个 new 出来的对象，否则他们比较的结果就为false.               



2.          用 equals()  进行比较：               
         
                         JAVA中的所有类都是继承于Object这个基类的，在Object 类中定义了一个equals方法，这个方法的初始行为是比较对象的内存地址，
                         但在一些类库当中这个方法被重写，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在内存中的地址值了。
                        
                         引用数据类型，有两种情况：
                
                         1. 没有重写equals，他们之间比较的还是内存中的地址值.

                                  
                         2. 重写了equals，他们之间比较的就不是地址值了，根据具体业务来定义该方法，有可能是对象的内容了。       
                        
                        
                        
3. 引入概念来解释。

                1.  字符串缓冲池。
                               
                                在程序运行时虚拟机会创建一个字符串缓冲池，当使用 s2 = "Monday" 这样的表达式创建字符串时，程序会先在字符缓冲池中寻找相同的对象。
                                在第一个程序中，s1 先被放入池中，当 s2 被创建时，程序找到了具有相同值的 s1，就让 s2 去引用 s1引用的对象，两个引用指向了同一个对象。
                                在第二个程序中，使用了 new 操作符，他告诉程序： 我不要旧的，我要自己创建一个新的，于是一个新的"Monday"Sting对象被创建在内存中。
                                        他们的值相同，但是位置不同。
                       
                       
                       
                       
                       
4. 总结：
       
                equals() 和 == 区别有：
                       
                        1.  equals() 是方法. == 是操作符。
                        2.  == 主要用于基本类型之间的比较, 有时也比较对象，而 equals() 仅用于对象之间的比较。
                               


                        
                        
例 1：        用 equals() 进行比较，重写了　equals方法

class Test
{
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
       
        public static void main(String[] args)
        {
                String s1 = "Monday";
                String s2 = "Monday";
               
                sop(s1==s2);         //比较的是内存地址值
                sop(s1.equals(s2));          // 重写了 String 类中的 equals 方法，比较的是对象的内容
        }
}

运行结果： true
                                         true
                                         
                                         


例 2：        用 equals() 进行比较，重写了　equals方法
                                 
class Test
{
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
       
        public static void main(String[] args)
        {
                String s1 = new String();
                String s2 = new String();
               
                sop(s1==s2);        //比较的是内存地址
                sop(s1.equals(s2));                // 重写了 String 类中的 equals 方法，比较的是对象的内容
               
                s1=s2;
               
                sop(s1==s2);
                sop(s1.equals(s2));
        }
}


运行结果： false
                                         true
                                         true
                                         true
                                         
                                         
例 3： 用 equals() 进行比较，没有重写equals方法

class Test
{
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
       
        public static void main(String[] args)
        {
                Object s1 = new Object();
                Object s2 = new Object();
               
                sop(s1==s2);                //比较的是内存地址
                sop(s1.equals(s2));                // 比较的是内存地址，因为此处的 equals 方法还是用的 Object 类中的 equals 方法。
               
                s1=s2;
                sop(s1==s2);
                sop(s1.equals(s2));
        }
}



运行结果： false
                                         false
                                         true
                                         true
                                         



例 4：

class Test
{
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
       
        public static void main(String[] args)
        {
                String s1 = "Monday";
                String s2 = new String("Monday");
               
                s2 = s2.intern();
               
                sop(s1==s2);
                sop(s1.equals(s2));
        }
}

运行结果： true
                                         true
                                         
       
范例分析：　
                       
                                java.lang.String的intern()方法 ，检查字符串池里是否存在"abc"这么一个字符串（用 equals(Object) 方法确定），如果存在，就返回池里的字符串；
                        如果不存在，该方法会把"abc"添加到字符串池中，然后再返回它的引用。
                               
                       
                        intern遵循以下规则：对于任意两个字符串 s 和 t，当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为 true。                
                       
                        更好的办法：　把所有的　String　都　intern()　到缓冲池去，在用到new的时候就进行这个操作，String s2 = new String("Monday").intern();
                       


例 5 ：用 equals() 进行比较，没有重写equals方法

class Test
{
        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));        // Ａ类没有重写equals方法，还是沿用的　Object 中的　equals　，所以比较的是地址。
        }
}

class A
{
        int age;
        String home;
}

运行结果： false
                                         false
                                         



例 6 ：接上面的例子，用 equals() 进行比较，重写了　equals　方法
                                         
class Test
{
        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
                        {
                                A a = (A)obj;//强转
                                if(a.age==this.age && a.home.equals(this.home))
                                {
                                        return true;
                                }
                                return false;
                        }
                }
        }
}

运行结果： false
                                         true