==与equals()的区别?<有实例程序>

Question

class A
{
int a=1;
}
public class p142
{
public static void main(String args[])
{
A obj1=new A();
A obj2=new A();
String s1,s2,s3="abc",s4="abc";
s1=new String("abc");
s2=new String("abc");
System.out.println("s1.equals(s2)是"+(s1.equals(s2)));
System.out.println("s1==s3是"+(s1==s3));
System.out.println("s1.equals(s3)是"+(s1.equals(s3)));
System.out.println("s3==s4是"+(s3==s4));  //我觉得s3!=s4,因为不是指向同一首地址
System.out.println("s2.equals(s3)是"+(s2.equals(s3)));
System.out.println("s1==s2是"+(s1==s2));
System.out.println("obj1==obj2是"+(obj1==obj2));
System.out.println("obj1.equals(obj2)是"+(obj1.equals(obj2)));  //这里我觉得
                                                                              //应该是相同的吧,内容一样啊/
obj1=obj2;
System.out.println("obj1=obj2后obj==obj2是"+(obj1==obj2));
System.out.println("obj1=obj2后obj1.equals(obj2)是"+(obj1.equals(obj2)));
}
}

Answer 1

@(%&#@)%&)%&)@&%)@&%
無語...
就是個引用對象和地址的區別,沒必要搞這么大陣仗吧?

Answer 2

s3="abc",s4="abc";这样赋值的String 对象 在java里面会先去查看一个String的常量池如果已经创建了 ，则不再重复创建，直接指向常量池中的那个已经存在对象s3 已经在常量池中创建了，所以s4也指向s3的那个对象

Answer 3

equeals方法是Object的方法 默认是 按照 内存地址比较
除非你重写 public boolean equals(Object obj) {
return (this == obj);
    }
上面是Object中equals方法，可以看到如果你不在A中重写这个方法就会默认按照地址比较

Answer 4

呵呵其实3和4他们指向的是一个对象啊，因为"abc"也是一个对象啊，他们都指向了它。

Answer 5

1.string是特殊的，string对象都是指向一个常量的，如果两个string的值是一样的，那么都是指向同一块内存，基本上你用＝＝或equals会得到一样的结果，但始终推荐使用equals，因为equeals是不光看地址这么简单的，就算地址不一样，它同样能检查其内容，详细请看String的equals方法实现。
2.对于一般的对象，如果其类自己没有实现equals的话，一般是使用地址去比较的，也就是说此时是和==一样，都是用内存地址去比较，所以自己的类，一般要想比较内容是否一样就要自己实现equals方法你这里，s3,s4是一样内容的string，所以用==或equals都可以，记住，string是特殊的，且一般时候用equals最保险，所以这里它们相等
obj1和obj2的类是没有自己实现equals的，所以它采用了Object类的equals方法，而这种方式是只比较内存地址的，所以它们不等，可以参考string实现自己的equals

Answer 6

equals用到的地方非常非常多呀，像collection.removeAll（）等很多方法都是基于equals方法而设计的呀getClass（），在面向接口编程的时候，你可以知道你到底是在使用哪一个类的对象呀，还有反射的时候用的很多，可能现在你的应用都较为简单，所以会用不到

Answer 7

==,指两个对象变量指向heap中同一个对象，
equals，指判断两个相同的对象（同一个类），不一定在heap中是同一个。

Answer 8

对于值类型数据 == 就是逻辑相等.
对象类型 == 指的是对象地址相同.
equals() 方法对于对象类型用户可以重写.

Answer 9

在HashMap ,HashSet 等散列容器中,如果 key 是一个对象数据类型,则必须重写这个对象的hashcode() 和 equals() 方法.在进行按 key 访问 value  的时候,会根据key对象的散列码来查询内存地址是否存在值.

Answer 10

“equals”表示两个对象的内容是否一样；“==”表示两个引用是否指向同一个对象的地址

Answer 11

s3="abc",s4="abc";
这样赋值的String 对象 在java里面会先去查看一个存放String的常量池空间
如果已经创建了相同的对象 ，则不再重复创建，直接指向常量池中的那个已经存在对象 
s3 已经在常量池中创建了，所以s4也指向s3的那个对象 
equals方法是Object的方法 默认是按照内存地址比较,当自定义类时，除非你重写equals；
上面是Object中equals方法，可以看到你没有在A中重写这个方法
就会默认按照地址比较

Answer 12

为什么s1==s3是fasle,s2==s3是false,s3==s4是true倒可以理解。

Answer 13

== 对象比较时是地址比较 或者基本数据类型比较的时是值比较；
equals比较的是内容。

Answer 14

 s1=new String("abc");
        s2=new String("abc");明白了，没看到这两句

Answer 15

楼主,相信您能在我这里得到满意的答案...请看:
1:对于操作符 "=="和"equals",如果指向的是同一个对象,那么,返回"true"
例外原则:
对于一些覆盖了方法equals()的类(File,java.util.Date,String,八个包装类),只要比较的对象类型,内容相同
那么返回的就是"true".

Answer 16

equals()方法是Object类的一个方法,sun给Object类的方法一个默认的实现:如:a.equals(b),只有当a,b指向同一个对象的时候才返回true,否则都返回false.
而String类重写了equals()方法,如:c.equals("hello"),它是按字符序列逐个比较，如果所有字符都相等，则返回true,否则返回false

Answer 17

package cn;public class ttt {
int i;
String tt;
public static void main(String[] args )
{
    Integer n1 = new Integer(47);
    Integer n2 = new Integer(47);
    System.out.println("n1 and n2 "+n1.equals(n2));
    
    String c1 = "kkk";
    String c2 = "kkk";
    System.out.println("c1 and c2 "+c1.equals(c2));
    System.out.println("c1 and c2 "+(c1 == c2));
    
    ttt a1 = new ttt();
ttt a2 = new ttt();
a1.i = 1;
a2.i = 1;
a1.tt = "sss";
a2.tt = "sss";
System.out.println("a1 equsls a2  "+a1.equals(a2));
//对于自定义的类，equals采用的是==的比较方法，比较地址
System.out.println(a1.i == a2.i);
System.out.println(a1.tt == a2.tt);//变量指向同一地址
}
}n1 and n2 true
c1 and c2 true
c1 and c2 true
a1 equsls a2  false
true
true
我也写了一个，可供参考