黑马程序员技术交流社区

标题: ==与equal的区别 [打印本页]

作者: 尹善波 时间: 2012-6-30 14:08
标题: ==与equal的区别
student a=new student(“LUCY”,20);
student b=new student(“LUCY”,20);
System.out.println(a==b);
System.out.println(a.equal(b));
运算结果有什么不同，为什么会这样？

作者: 黑马刘杰 时间: 2012-6-30 14:13
a和b是两个对象，有两个内存空间，a和b是不一样的。以上运行结果就是两个false。

作者: 赵倩倩 时间: 2012-6-30 14:15
这里要看你要比较的内容是什么 equal比较的是地址中的内容而==是比较的内存地址

作者: 黑马刘杰 时间: 2012-6-30 14:15
你用的是Object的equals()方法，equals()方法就等同于==

作者: 自己玩 时间: 2012-6-30 14:23
==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。
如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如Objet obj = new Object();变量obj是一个内存，new Object()是另一个内存，此时，变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。
equals方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。例如，对于下面的代码：
String a=new String("foo");
String b=new String("foo");
两条new语句创建了两个对象，然后用a,b这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的首地址是不同的，即a和b中存储的数值是不相同的，所以，表达式a==b将返回false，而这两个对象中的内容是相同的，所以，表达式a.equals(b)将返回true。
在实际开发中，我们经常要比较传递进行来的字符串内容是否等，例如，String input = …;input.equals(“quit”)，许多人稍不注意就使用==进行比较了，这是错误的，随便从网上找几个项目实战的教学视频看看，里面就有大量这样的错误。记住，字符串的比较基本上都是使用equals方法。
如果一个类没有自己定义equals方法，那么它将继承Object类的equals方法，Object类的equals方法的实现代码如下：
boolean equals(Object o){
return this==o;
}
这说明，如果一个类没有自己定义equals方法，它默认的equals方法（从Object 类继承的）就是使用==操作符，也是在比较两个变量指向的对象是否是同一对象，这时候使用equals和使用==会得到同样的结果，如果比较的是两个独立的对象则总返回false。如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，那么你必须覆盖equals方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。

作者: 吴扬 时间: 2012-6-30 14:26
"=="这个符号是逻辑运算符，既可用于基本数据类型的比较，也可用于引用数据类型比较
当用于比较引用数据类型时，比较的是这两个引用的内存地址值
student a=new student(“LUCY”,20);
student b=new student(“LUCY”,20);
a和b是两个不同的对象，在内存中的内存地址值不一样，所以System.out.println(a==b);打印的是false。
而equals()这个方法是object类中的方法，它在没有被覆盖的情况下比较还是对象在内存中的存放位置的地址值，所以System.out.println(a.equal(b));打印的也是false
而String类中对equals()方法进行了覆盖，覆盖之后比较的是两个字符串对象的内容。

作者: 封明川 时间: 2012-6-30 14:27
这个要看你的Student的equal()方法是怎么写的
和我这个差不多的话，就是下面这个结果

class Student
{
public String name;
public int age;
Student(String name, int age)
{
this.name = name;
this.age = age;
}

public boolean equal(Student s)
{
if(this.name==s.name && this.age==age)
return true;
else
return false;
}
}
Student a=new Student("LUCY",20);  //这个是新建一个对象
Student b=new Student("LUCY",20);  //这里又新建了一个对象
System.out.println(a==b);                //这里比较的两个类对象在内存中的地址值，结果是false
System.out.println(a.equal(b));       //这里比较的是两个对象所指向的值，结果是true

作者: wht 时间: 2012-6-30 14:27
对于字符串变量来说，使用“==”和“equals()”方法比较字符串时，其比较方法不同。
“==”比较两个变量本身的值，即两个对象在内存中的首地址。
“equals()”比较字符串中所包含的内容是否相同。
比如：
String s1,s2,s3 = "abc", s4 ="abc" ;
s1 = new String("abc");
s2 = new String("abc");
那么：
s1==s2 是 false //两个变量的内存地址不一样，也就是说它们指向的对象不一样，
故不相等。
s1.equals(s2) 是 true //两个变量的所包含的内容是abc，故相等。

作者: 薄炳鑫 时间: 2012-6-30 14:32
==比较的是两个对象的地址值，你建立的两个对象肯定地址是不相同的。
equals()方法在使用的时候一般都要复写，用来比较两个对象是否相等，下面的代码是我对equals方法的复写，你可以参考一下。

public class Student
{
private String name;
private int age;
public Student(String name, int age)
{
this.name = name;
this.age = age;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
//对Student中的具体内容进行比较，比较他的名字和年龄。
public boolean equals(Student p)
{
if (p.getName().equals(this.getName()))
{
if (p.getAge() == this.getAge())
return true;
}
else
{
return false;
}
return false;
}
}
//测试类
public class StudentTest
{
public static void main(String[] args)
{
Student a = new Student("lucy", 20);
Student b = new Student("lucy", 20);
System.out.println(a == b);//这里返回false
System.out.println(a.equals(b));//这里返回true，没有复写equals方法的话返回false.
}
}

复制代码

作者: 尹善波 时间: 2012-6-30 14:45

薄炳鑫发表于 2012-6-30 14:32
==比较的是两个对象的地址值，你建立的两个对象肯定地址是不相同的。
equals()方法在使用的时候一般都要复 ...

了解了，结果的不同源自代码环境的不同

作者: 尹善波 时间: 2012-6-30 14:45

薄炳鑫发表于 2012-6-30 14:32
==比较的是两个对象的地址值，你建立的两个对象肯定地址是不相同的。
equals()方法在使用的时候一般都要复 ...

了解了，结果的不同源自代码环境的不同

作者: 汪璨 时间: 2012-6-30 14:57
1、= =操作符比较的是操作符两端的操作数是否是同一个对象；另外= =操作符两边的操作数必须是同一类型的（可以是父子类之间）才能编译通过。
2、String的equals()方法比较的是两个String对象的内容是否一样
3、= =比较的是地址，如果是具体的阿拉伯数字的比较，值相等则为true

明白上面的以后就知道:
a == b 结果为false//因为不是同一个对象,地址值不同
a.equals(b)结果为true//因为比较的内容都是LUCY,20

作者: 赵方明 时间: 2012-6-30 14:59
受教学习

作者: 余清兰 时间: 2012-6-30 15:38
两个结果都为false，因为对于非基本数据类型(String类除外)，＝＝和equals都是比较的两个变量的地址值，你这里是两个类类型的变量分别指向了各自的对象

class student
{
student(String name,int age)
{}
}
class test123
{
public static void main(String[] args)
{
student a=new student("LUCY",20);//在堆内存中开辟空间，并有了地址值，类类型变量a指向这个地址值。
student b=new student("LUCY",20);//在堆内存中开辟空间，并有了地址值，类类型变量b指向这个地址值。
System.out.println(a==b);//判断的是两个类类型变量指向的变量地址值，地址值是唯一的，所以为false
System.out.println(a.equals(b));//这个是直接调用的Object类中的equals方法，此方法就是比较的地址值，可看API文档。
}
}

复制代码

但是如果是String类型的变量，equals()就是比较的字符串内容，还有==的用法也比较特殊，下面给个详细的说明

class stringDemo
{
public static void main(String[] args)
{
String s1 = "abc";
String s2 = new String("abc");
String s3 = "abc";
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//true
System.out.println(s1==s3);//true
}
}

复制代码

分析：s1是一个类类型变量，类类型变量一定指向对象，所以”abc”是一个对象。字符串最大特点是，一旦被初始化就不可以被改变。
基本数据类型比较的是内容，引用数据类型比较的是地址值，所以s1==s2是比较的地址值，结果为false.由于String类覆写了object 类中的equals方法，并建立了自己对象独特的判断相同的内容（该方法用于判断字符串是否相同），所以这里比较的是内容是否相等，结果为true. s1和s2的区别：s1在内存中有一个对象，s2在内存中有两个对象。
字符串对象比较特殊，String s1 = "abc";这个字符串对象在常量池中存在了，s3在进行初始化的时候发现abc已经在内存中存在了，它就不会再独立开辟空间了，若再开辟空间比较浪费，也就是说在字符串对象中,只要内容相同，就不会再开辟空间，这里s1和s3指向的是同一个对象，所以结果是true

作者: 赵庆礼 时间: 2012-6-30 16:00
class student
{
   private String name;
   private int age;
   student( String name, int age )
   {
      this.name = name;
      this.age = age;
   }
   public boolean equal( student s )                               //重写equal（）方法，是比较的是两个对象的内容，若相同则返回true，否则返回false；equals()方法是object类中的方法，
                                                                                    //它在没有被覆盖的情况下比较还是对象在内存中的存放位置的地址值，
                                                                                    //所以equal()方法在没有被覆盖的时候System.out.println(a.equal(b));打印的也是false

   {
      if ( this.name == s.name && this.age == s.age )
      {
            return true;
      }
      else
            return false;
      }
   }
class TestEqual
{
   public static void main(String[] args)
   {
      student a = new student( "LUCY", 20 );
      student b = new student( "LUCY", 20 );
      System.out.println( a == b);    //a和b是两个不同的对象，在内存中的内存地址值不一样，所以System.out.println(a==b);打印的结果为false。
      System.out.println( a.equal( b ) ); //equal()方法在被覆盖后，比较的是两个地址的内容，System.out.println( a.equal( b ) ); 打印的结果为true。
   }
}

红体字为解释，附图

作者: 孙飞 时间: 2012-6-30 17:25
看过之后对这一块更清晰了

作者: dev 时间: 2012-6-30 17:55
==比较是的内存地址，而equal()方法比较的是内容。
程序中a和b的内容是相同的，所以a.equal(b)打印结果为：true，
而a和b的内存地址是不同，因为他们都是用关键字new出来的，
所以a==b打印结果为：false。

作者: 王一军 时间: 2012-6-30 18:37
==号是用来比较对象在内存中的地址，也就是比较对象的地址字节
比如说我现在用
Strudent s=new Student（）；//大家都知道new关键字是用来创建一个新的对象的，那么对象的创建后在内存中是唯一的，如果想引用他必须得有一个地址来指向它。
我现在使用
student s1=s；// 这个时候就是把s在内存中的地址给了s1，这时候s1和s都同时指向了一个对象，这个时候我用
System.out.println（s==s1）输出的就是true因为==比较的是内存地址，而s1和s都指向了同一个内存对象，那么他们的值肯定是一样了
而相反.equals（）是对象中的方法，它的作用仅仅是用来对比两个对象中的值是否是一样的，而不管内存只一块，只要其中的值是一样就会返回true ，不管他们是不是同一个对象，内存地址是否一致。
比如说：
String s=new String（“123”）；//这两个一眼看上去没什么区别但是仔细看，他们都分别用了new关键字创建了各自的对象，而对象的值却是一样

String s1=new String（“123”）；
这种情况下我用s1==s可想而知返回的是false因为他们是两个对象，根据对象在内存中的唯一性而定，这两个对象的地址肯定不会一样所以返回，false
如果使用s.equals（s1）返回为true，这是为什么呢？因为刚才说道，.equals（）比较的是两个对象中的值而不是地址，所以返回true 。
这下你明白==和.equals（）的区别了吧

作者: 金龙 时间: 2012-6-30 21:43
运算结果当然不同，估计编译都不会通过，因为，那个比较方法是equals()。 ==是比较运算符。判断的是值是否相同，而equals是超类Object中的方法，用于判断两个对象是否相同（即比较它俩是不是同一个对象），然后呢？equals可以按照自己的需求进行复写，而==呢，它就是个比较运算符，如果你把equals改正确了，运行结果应该是两个false，==判断的是值（即两个对象的内存地址值），而equals判断的是它俩是不是同一个对象，比较的也是内存地址值。。结果当然不同，因为它俩都是new出来的个体

作者: 周朋飞 时间: 2012-7-1 04:15
楼主啊估计你问这种问题，版主连看都不会看因为这种问题论坛里太多了，你通过new来创建对象，那么都会在堆里分配空间，然后返回你创建的对象的引用，你new了两次就分配了两块空间，分别存放你的值，所以返回的地址肯定是不一样的，所以==比较会是false 因为它比较的就是引用的地址，但是因为String重写了Obect的equals方法，所以比较的是两个引用所指向的对象的内容是否相同，不用说你也肯定认为是相等的那结果不就是你想要的吗

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2