Java中的equals和==

String类中的equals源码：

/**
         * Compares this string to the specified object.  The result is {@code  
         * true} if and only if the argument is not {@code null} and is a {@code  
         * String} object that represents the same sequence of characters as this  
         * object.  
         *  
         * @param  anObject  
         *         The object to compare this {@code String} against  
         *  
         * @return  {@code true} if the given object represents a {@code String}  
         *          equivalent to this string, {@code false} otherwise  
         *  
         * @see  #compareTo(String)  
         * @see  #equalsIgnoreCase(String)  
         */    
        public boolean equals(Object anObject) {    
            //判断是否是和自己比较  
            if (this == anObject) {    
                return true;    
            }    
            //判断传过来的anObject是否是String类型的实例  
            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方法被重写成,比较两个对象中对象的内容是否相等,该方法将两个String对象拆分成字符数组,然后通过遍历字符数

组中的每一个字符是否都相等,若相等,则返回true 否则返回false;

而我们查看一般对象的equals方法,其方法体如下：

equals方法是基类Object中的方法，因此对于所有的继承于Object的类都会有该方法。

很显然，在Object类中，equals方法是用来比较两个对象的引用是否相等，即是否指向同一个对象。

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

package com.jsecode.esb.web.action;
import java.util.Scanner;
public class StringDemo {

    public static void main(String[] args) {
        
        //基本数据类型的比较
        int num1 = 10;
        int num2 = 10;
        System.out.println(num1 == num2);   //true
        
        /*
        1.==在基本数据类型中的比较
        “==” 属于关系运算符,比较的是两个基本数据类型的值是否相等，
        num1 和num2都是int型 它们的值都是10,因此使用”==”当然相等。
        */
        
        //引用数据类型的比较
        String s1 = "chance";
        String s2 = "chance";
        System.out.println(s1 == s2);        //true
        //String的equals比较两个字符串的实际内容是否相等
        System.out.println(s1.equals(s2));   //true
        
        /*
        2.在String类中的比较
        2.1 不new String类对象时的比较
        ==在引用数据类型中,比较的是引用的对象是否相等,即是否引用了同一个对象，
        当执行String s1 = “chance”;这条语句时,会在堆中的字符常量池里找”chance”这个字符串,
        若没有找到,则将”chance”这个字符串放入字符串常量池中.而在栈中开辟一块名为s1的空间存放”chance”,这块空间的引用。
        当执行String s2 = “chance”;这条语句时,会在堆中的字符串常量池里找”chance”这个字符串,
        很显然,可以找到,于是便把字符常量池里”chance”这个字符串的引用地址赋给s2,
        因此s1与s2存放的都是堆中字符常量池中的同一个”chance”的引用。         
        
        s1.equals(s2)这里的equals在String类中被重写过,用来比较两个字符串的实际内容是否相等,
        即每一个字符是否相等,因为比较的是字符串内容,s1,s2内容都是chance当然是相等的。
        */
        
        //String类中==与equals的比较
        String s3 = new String("chance");     
        String s4 = new String("chance");
        System.out.println(s3 == s4);        //false
        //String的equals比较两个字符串的实际内容是否相等
        System.out.println(s3.equals(s4));   //true
        
        /*
        2.在String类中的比较
        2.2 new String类时的比较
        当程序执行String s3 = new String(“chance”); 这一句时,会在堆内存中开辟一块空间用于存放”chance”这一字符串.
        并在栈中开辟一块名为s3的内存空间存放堆中刚刚创建的”chance”对象的引用。
        程序执行String s4 = new String(“chance”); 这句时,会在堆内存中开辟另一块空间用于存放”chance”这一字符串,
        并在栈中开辟一块名为s4的内存空间存放堆中刚刚创建的”chance”对象的引用.
        因为s3和s4中存放的是两个不同对象的引用,自然System.out.println(s3 == s4); 返回的是false;
        因为还是String类 因此equals方法比较的还是字符串中内容是否相等,即每个字符是否相等。可见s3和s4这两个对象中中存放都是”chance”,自然每个字符都相等。 
        */
        
        //非String类中==与equals类型的比较
        Scanner scanner  = new Scanner(System.in);      
        Scanner scanner2 = new Scanner(System.in);
        System.out.println(scanner.equals(scanner2));  //false
        Scanner sc = scanner;
        System.out.println(scanner.equals(sc));        //true
        
        /*
        3 不在String类中的比较
        执行第一条语句Scanner scanner = new Scanner(System.in); 时在堆中开辟了一块内存存放Scanner对象,
        在栈内存中开辟一块名为scanenr的内存存放Scanner对象的引用。
        执行第二条语句Scanner scanner2 = new Scanner(System.in); 时时在堆中另外开辟了一块内存存放Scanner对象,
        在栈内存中开辟一块名为scanenr2的内存存放Scanner对象的引用。
        因为这里调用的是一般对象的equals方法,因此比较的是两个对象是否属于同一个对象,显然不是同一个对象。
        至于最后一个Scanner sc = scanner;则将scanner对象的引用复制给sc因此,sc和scanner指向都是堆中同一个Scanner对象,自然比较的都是相等的。
        */  
    }
}

总结来说：
1）对于==，如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；
　 如果作用于引用类型的变量，则比较的是所指向的对象的地址
2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量
　 如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；
　 诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。