关于equals的问题，equals比较的是什么？是不是每个类的equals的比较都是不同的 求大神解救下

equals 方法（是String类从它的超类Object中继承的）被用来检测两个对象是否相等，即两个对象的内容是否相等，区分大小写。
但是，String类虽然从Object中继承了equals方法,但是它重写了equals方法,把原来判断对象地址是否相等改成了判断对象值是否相等.
所以就有一道面试题是这样
String str = "abcd";
//                str = "hello";
//                String str = new String("abcd");
               
                System.out.println(str==str);//false
                System.out.println(str.equals(str));//true 字符串的equals覆盖了Object类，比较的是字符串的内容是否相同。
               
                //问，str和str1的区别。
                /*
                 * str在内存中只有一个对象。
                 * str1,在内存中有两个对象。
                 */
               
               
                System.out.println("---------------");
               
                String s1 = "abc";
                String s2 = "abc";
               
                System.out.println(s1==s2);    //true
                //这里就是常量池的概念，如果常量池里已经有字符串abc,那String s2这样一做,常量池不会再创建新的对象,只是把已经有的abc赋值给s2,所以s1==s2是true

分为两种情况，如果是基本数据类型，则比较的是值，如果是引用型数据类型，则比较地址值。在Object中，有equals的方法，所以要看类是否复写了这个方法，才可以判断是否一样。

我们在用的类中如果没有实现equals方法，类的对象比较的是地址值。如果要想按照我们的意愿去比较，则需要重写object的equals方法

equals方法，默认(不覆盖父类的)比较的对象的真实内存地址
覆盖equals方法，建立对象自己的比较方式，比较的是类中成员变量的具体数值
相较而言比较运算符 == ，如果比较基本数据类型，比较的数值是否一致  
如果在引用数据类型中，比较的是对象的真实内存地址

1. public boolean equals(Object obj) {
   
2.         return (this == obj);
   
3.     }

复制代码

上面是Object类中equals的代码。也就是比较两个对象的地址。
每个类默认都是Object的子类。如果类中没有重写equals方法。就调用的是Object类中的equals.

我的理解是：object类中的equals方法是用于比较一个对象与另一个对象是否相同，如果这两个对象在内存中的地址值是相同的，那么这两个对象就是相同的，否则是不相同的。

在String类中，已经重写了equals()方法

1.     /**
   
2.      * Compares this string to the specified object.  The result is {@code
   
3.      * true} if and only if the argument is not {@code null} and is a {@code
   
4.      * String} object that represents the same sequence of characters as this
   
5.      * object.
   
6.      *
   
7.      * @param  anObject
   
8.      *         The object to compare this {@code String} against
   
9.      *
   
10.      * @return  {@code true} if the given object represents a {@code String}
    
11.      *          equivalent to this string, {@code false} otherwise
    
12.      *
    
13.      * @see  #compareTo(String)
    
14.      * @see  #equalsIgnoreCase(String)
    
15.      */
    
16.     public boolean equals(Object anObject) {
    
17.         if (this == anObject) {
    
18.             return true;
    
19.         }
    
20.         if (anObject instanceof String) {
    
21.             String anotherString = (String) anObject;
    
22.             int n = value.length;
    
23.             if (n == anotherString.value.length) {
    
24.                 char v1[] = value;
    
25.                 char v2[] = anotherString.value;
    
26.                 int i = 0;
    
27.                 while (n-- != 0) {
    
28.                     if (v1[i] != v2[i])
    
29.                             return false;
    
30.                     i++;
    
31.                 }
    
32.                 return true;
    
33.             }
    
34.         }
    
35.         return false;
    
36.     }

复制代码

所以使用时比较会相同。如果是自己写的类的话，就应该重写equals()方法了，自己定义相同时的比较，而不用内存地址来比较

equals()是比较两个对象的内容是否相等，如果自己不定义针对自己的类的equals()方法，那么就会使用Object的equals()方法，而且String也有自己的equals()方法（它已经覆盖了Object的该方法了。)

肖涵 发表于 2014-3-19 16:52
equlas是比较对象的值，是判断这两个对象的引用（内存地址）是不是相同，

==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。
equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。

object类中的equals方法是用于比较一个对象与另一个对象是否相同，如果这两个对象在内存中的地址值是相同的，那么这两个对象就是相同的，否者是不相同的。

equlas是比较对象的值，是判断这两个对象的引用（内存地址）是不是相同，

equals用于比较两个独立的对象内容是否，他比较的是两个对象是否是独立的
就想 String a= new String（“ss”）和String b= new String（“ss”），这是两个不同对象，其内存地址不同，所以a！=b，但是他们内容相同，所以a.equals(b)为true
至于每个类的equals比较是否相同，那要看每个类对是如何对Object中的equls方法进行覆盖的

equals比较的是内容，如果类重写了equals方法，就根据重写的方法比较