equals和== 的区别是什么啊，什么时候用equals，什么时候用==？？之前以为搞明白了，现在又雾了。
菜鸟虚心求教！

如果比较的对象是引用类型：
== 比较的是两个对象的地址是否相等。
equals 比较的是两个对象的值是否相等，由于equals是object类中的方法，所以这个方法可以被重写，所以说这个比较值可以由创建者来决定。在一些哈希类的容器里，经常需要定义equals方法。

如果比较对象是基本类型：
== 比较的是两个变量的值是否相等。
equals 由于是基本类型，不存在对象的概念，所以更谈不上方法，更涉及不到equals。

以下是String类中 equals 方法的源码，你可以体会一下。

1. public boolean equals(Object anObject) {
   
2.         
   
3.                 //比较两个对象的引用地址是否相同，若相同，那么不用说别的，两个对象肯定一模一样。
   
4.                 if (this == anObject) {
   
5.             return true;
   
6.         }
   
7.                 //若上面不成立，判断两个对象类型是否一致
   
8.         if (anObject instanceof String) {
   
9.                 //以下是String类自定义的比较规则。
   
10.             String anotherString = (String) anObject;
    
11.             int n = value.length;
    
12.             if (n == anotherString.value.length) {
    
13.                 char v1[] = value;
    
14.                 char v2[] = anotherString.value;
    
15.                 int i = 0;
    
16.                 while (n-- != 0) {
    
17.                     if (v1[i] != v2[i])
    
18.                             return false;
    
19.                     i++;
    
20.                 }
    
21.                 return true;
    
22.             }
    
23.         }
    
24.         return false;
    
25.     }

复制代码

1. int number1 = 1;
   
2.                 int number2 = 1;
   
3.                
   
4.                 /*
   
5.                  * true
   
6.                  * int为基本类型，所以对比的值即1==1，结果为true
   
7.                  */
   
8.                 System.out.println(number1 == number2);
   
9.                
   
10.                 String a = new String("a");
    
11.                
    
12.                 String b = new String("a");
    
13.                
    
14.                 String c = new String("c");
    
15.                 //输出a/b/c的哈希码值
    
16.                 System.out.println(a.hashCode());//97
    
17.                 System.out.println(b.hashCode());//97
    
18.                 System.out.println(c.hashCode());//99
    
19.                 /*
    
20.                  * true
    
21.                  * a和b都是对象，所以比较哈希码值，结果97==97为true
    
22.                  */
    
23.                 System.out.println(a.equals(b));
    
24.                 /*
    
25.                  * false
    
26.                  * 这里比较的内存地址
    
27.                  */
    
28.                 System.out.println(a == b);
    
29.                 /*
    
30.                  * false
    
31.                  * a和b都是对象，所以比较哈希码值，结果97==99为false
    
32.                  */
    
33.                 System.out.println(a.equals(c));
    
34.                 /*
    
35.                  * false
    
36.                  * 这里比较的内存地址
    
37.                  */
    
38.                 System.out.println(a == c);
    
39.                
    
40.                 /*
    
41.                  * equals 和 == 参见下面信息
    
42.                  * http://wenku.baidu.com/link?url=_5wAJQarxUdHotDoyWRbXrMoE7KqaMgwee8qz-ykUne90ZhksHwxoprUpFApGGSRRMrlnlq2IB-WH6Hm3A0LabTV7CDGCT0K4CUM8uFhXPK
    
43.                  *
    
44.                  * hashCode：参见下面信息
    
45.                  * http://www.iteye.com/topic/257191
    
46.                  * http://blog.csdn.net/fenglibing/article/details/8905007
    
47.                  */

复制代码

如果就两个对象比，用==比较好，equals方法看怎么定义，里面可能比较很多多西，如果只有一样，就没有必要用equals了

个人是这么理解的:   ==  比较的就是变量本身的值,而equals是给引用型做比较用的，equals会自动去比较引用类型的指向的值！这个如果你自己建立了一个引用类型，也就是一个类，你可以在类中复写equals方法，让系统知道你这个类是怎么样判断两个实例如果相等的！总结：就是系统的基本数据类型用==    引用数据类型用equals      自定的类要自定equals

引用数据类型用equals比较的是地址 不过String 例外 它重写了equals方法，比较的是字符串是否相等。

equals函数是需要自己重写的根据实际需求，一般要是用类的对象来调用的话比较的是空间地址，和==一样

equels：等于。。。。==：是不是一个东西