==和equals又混淆了，麻烦解答下

Question

  Test  test1 = new Test();
  Test  test2 = new Test();  String s1=new String("a");
  String s2=new String("a");
        
                                 //这2种声明有区别吗？
  String h1= "hello"; 
  String h2 = "hello";   System.out.println(test1==test2); //false 比较的是引用对象的地址，new了2个对象，他们存放地址不一样
System.out.println(test1.equals(test2)); //false   为什么会不一样？


System.out.println(h1==h2); //true  为什么是对的，比较的不是地址吗？String 不是基本类型啊
System.out.println(h1.equals(h2));//true 也能理解


System.out.println(s1 == s2);//false  比较的是引用对象的地址，new了2个对象，他们存放地址不一样
System.out.println(s1.equals(s2));//true  这个也知道

Answer 1

此回复为自动发出,仅用于显示而已，并无任何其他特殊作用
楼主【yaonet2008】截止到2008-07-04 19:19:09的历史汇总数据(不包括此帖)：
发帖的总数量:37                       发帖的总分数:1380                     
结贴的总数量:26                       结贴的总分数:920                      
无满意结贴数:0                        无满意结贴分:0                        
未结的帖子数:11                       未结的总分数:460                      
结贴的百分比:70.27 %               结分的百分比:66.67 %                  
无满意结贴率:0.00  %               无满意结分率:0.00  %                  
楼主加油

Answer 2

System.out.println(test1.equals(test2)); //false   为什么会不一样？
                         //new了2个对象，明显不可能equals，就像你买了2个苹果，这2个苹果会是同一个？

Answer 3

  String s2=new String("a");
        
                                 //这2种声明有区别吗？
  String h1= "hello"; 
                                 //有区别，第一种产生2个对象，第二种只有一个
                                         //内存和字符串池     字符串池

Answer 4

错test1.equals(test2)  到底是true还是false决定于public boolean equals(Object obj)中定义的规则，例如
public class Test
{
    public static void main(String[] args)
    {
        Test t1 = new Test();
        Test t2 = new Test();
        
        System.out.println(t1.equals(t2)); //true
        System.out.println(t1 == t2); //false
    }
    
    public boolean equals(Object obj)
    {
        return true;
    }
}

Answer 5

String s1 = new String("a");
String s2 = new String("a");        
                               
String h1 = "hello"; 
String h2 = "hello"; 
再解释一下上面四行前两行是直接new了两个String对象，分别位于两个独立的内存单元
所以equals为false，==为false第三行，将hello添加到字符串池，并将h1指向hello
第四行，发现字符串池中已经有hello，就直接将h2指向hello
所有，h1与h2不管是==还是equals都是true

Answer 6

System.out.println(h1==h2);//这个没有new对象,所对h1,h2引用的都是String池中的同一字符串,所以为true

Answer 7

System.out.println(h1==h2); //true  为什么是对的，比较的不是地址吗？String 不是基本类型啊
比较的是地址..但是h1和h2对象引用的是内存的同一块地址,内存址的值为hello

Answer 8

The equals method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any non-null reference values x and y, this method returns true if and only if x and y refer to the same object (x == y has the value true). 看了JDK文档，不知道我错哪了。。-_-

Answer 9

麻烦 狂人 解释一下，说人错了也得给出理由吧？难道jdk帮助文档解释的规则就不是规则了？

Answer 10

我五楼解释了哈，呵呵
你帖的那一行英文那可能是超级超类中解释如果重写了Object中的public boolean equals(Object obj)方法，那两个相同类型的对象用equals比较，到底是true还是false就决定于你在重写equals时定义的规则，比如我在五楼帖的那个让它永远返回true，那么只要是那个类的对象，equals都是true下面帖上Object类中的equals方法源码    public boolean equals(Object obj) {
return (this == obj);
    }
很明显，如果不重写equals方法的话，equals与==效果一样

Answer 11

怀疑狂人在钻牛角尖,楼主说过他重写过equals方法？
照你这样说，没有几个方法是可以返回true了，我非要把它们重写，嘎嘎-_-

Answer 12

看清楚楼主的问题
System.out.println(test1.equals(test2)); //false   为什么会不一样？我只是为了解释清楚这个没错，如果没有重写equals，那这个类型的两个实例equals永远是false一般的，很多情况下都要重写equals，比如有个Person类，如果两个对象的身份证号一样，那我们就要强行规定他相等，如下
class Person
{
    /**
     * 身份证号
     */
    private int sfz;
    
    /**
     * 名字
     */
    private String name;
    
    public String getName()
    {
        return name;
    }    public void setName(String name)
    {
        this.name = name;
    }    public int getSfz()
    {
        return sfz;
    }    public void setSfz(int sfz)
    {
        this.sfz = sfz;
    }
    
    //只要身份证号叫一样，那我们就认为这两个人相等
    public boolean equals(Person p)
    {
        return this.sfz == p.sfz;
    }
}

Answer 13

狂人看看这句有没有错：没错，如果没有重写equals，那这个类型的两个实例equals永远是false，
因为它们不是指向同一个对象

Answer 14

没有错是两个实例哈
比如
Test t1 = new Test();
Test t2 = new Test();
t1.equals(t2)     false如果你强行将其中一个指向另一个，比如
t2 = t1
那么这时t1.equals(t2)就是true了

Answer 15

这里就有个“一样”和同一个的问题了
equals可以理解为一样
==就是同一个喽至于怎么个算一样，就要看你的规则了，比如两个苹果，我规定重量相等那我就认为是一样的，当然我也可以再严格一点，要重量相等而且要颜色相似才可以认为是一样的

Answer 16

  Test  test1 = new Test();
  Test  test2 = new Test();  String s1=new String("a");
  String s2=new String("a");
     
  String h1= "hello"; 
  String h2 = "hello";   System.out.println(test1==test2); //false 比较的是引用对象的地址，new了2个对象，他们存放地址不一样
System.out.println(test1.equals(test2)); //false   此处test1调用的是Object里的equals方法，此方法说明只能两个对名象名指向于同一对象时才为true
        
       
System.out.println(s1 == s2);//false  比较的是引用对象的地址，new了2个对象，他们存放地址不一样
System.out.println(s1.equals(s2));//true  此外S1调用的是String类的equals方法，此方法是当两个字符串值相等时就为true

Answer 17

总结下：对于类的equals()：
1.“对于Object类的equals()来说 就比较引用的地址”
2. 重写的equals()，就看你的规则
  
对于String的equals()：
这个狂人已经解释的很清楚了

Answer 18

1.equals比的是双方对象中的内容是否相等.2."=="比较时分两种情况(1)如果比较的双方是java的基本数据类型(char，byte，short，int，long，float，double，boolean),那么'=='比较的依据是双方的直是否相等.int i=2;int k=2;System.out.println(i==k); //返回tureString str1 = "abc";String str2 = "abc";      //以上两个语句都创建对象.引号内包含文本是String类特有创建对象的方式.但是"=="返回的结果是true,为什么呢?因为在JVM内,存在字符串池,其中保存着很多String对象，并且可以被共享使用，因此它提高了效率.字符串池由String类维护，我们可以调用intern()方法来访问字符串池。当运用引号内包含文本创建对象时,所创建的对象是加入到字符串池里面的.如果要创建下一个字符串对象,JVM首先会到字符串池中寻找,是否存在对应的字符串对象,如果存在,则返回一个己存在对象的对象的引用给要创建的对象引用.如果不存在,才会创建一个新的对象,并返回一个新对象的对象引用给要创建的对象引用.以上这段话理解起来可能比较拗口.用代码理解就是str2和str1是两个对象引用,并指向了同一个对象.所以'=='返回的是true.
重点:只有引号内包含文本创建对象才会将创建的对象放入到字符串池. String str = new String("abc")这种方法创建的字符串对象是不放入到字符串池的.所以,引号内包含文本创建对象的性能要比后来那种方法创建字符串对象的性能要好.String str3 = str1+str2;   //这种创建方式是不放入字符串池的.String str4 = str1+"cd";   //这种创建方式是不放入字符串池的.String str5 = "ab"+str2;   //这种创建方式是不放入字符串池的.String str6 = "ab"+"cd"   //这种创建方式是放入字符串池的.这种情况实际上是创建了1个对象，abcd"1个对象System.out.println(str1==str2); //返回tureSystem.out.println(str1.equals(str2)); //返回ture(2)如果比较的双方是对象的变量类型,那么'=='比较的依据是双方的对象的引用是否是指向同一个对象.   Date d1 = new Date();
   try
   {
    Thread.sleep(500);
   }
   catch(Exception e)
   {
    e.printStackTrace();
   }
   Date d2 = new Date();
   Date d3 = d1;
   System.out.println(d1==d2); //返回false
   System.out.println(d1==d3); //返回true
   System.out.println(d1.equals(d2)); //返回false
   System.out.println(d1.equals(d3));//返回true如果没有线程休息,   System.out.println(d1.equals(d2));返回ture,因为在一个时间点内创建了两个Date对象.也就是说两个对象代表的时间是相等的.

Answer 19

来凑个热闹！！对于用户自己定义的类，如果没有显式定义equals()方法，将调用Object的equals()方法，其代码为：    public boolean equals(Object obj) {
return (this == obj);
    }可见，用户自定义的类，没有显式定义equals()方法的话，“==”与“equals”完全等价！！对于Date类，重定义了equals()方法，比较的是代表的时间是否一致：    public boolean equals(Object obj) {
        return obj instanceof Date && getTime() == ((Date) obj).getTime();
    }

Answer 20

都是jdk惹的祸!!搞得这么多人在这研究这问题,我看啊,会用知道什么时候行什么时候不行就得了.
右边没有new 的就用"=="号吧!
右边有了new的,就看看两个家伙的衣着是不是一样的,如果一样就当他们是true,否则就当他们是false.
当然,如果有new,但两个家伙都是穷光蛋,那就没得比了,只能认为他们的"皮大衣"不一样了!

Answer 21

对呀，equer比较的是地址而＝＝比较的是内存中的。所以有本质的区别

Answer 22

System.out.println(h1==h2); //true这是因为初始化h1为“hello”,当初始化h2时 ,由于已有相同的初值存在，且没有通过new 关键字重新创建，所以h2直接指向了h1的内容“hello”,不再重新开辟内存。