java中equals()方法和==比较

Object中的equals()方法默认是按地址比较，而不按内容进行比较。
这和关系运算符“==”在进行对象比较时没有区别了，但是经常说==两边
对象是按地址在比较，而equals()是按内容在比较，这是怎么回事？？？


像String s1="回家了"；
  String s2="回家了"；
  s1.equals(s2),返回值是true
 而
 String s1=new String("回家了")
 String s2=new String("回家了")
 s1.equals(s2),返回值是false
这个有该怎么解释？？？

51 个解决方案

#1

前面的返回true很正常，因为内容相等，但是后面的你确认返回时false？如果你说==返回false的话还差不多吧。

#2

不是一个对象

#3

我貌似看错了    s1.equals(s2),应该返回值是true的
s1 == s2 不是一个对象  返回是false

引用 2 楼  的回复:

不是一个对象

#4

package cn.test;

public class StringEqualsTest {
	public static void main(String[] args) {
		String str1 = "回家了";
		String str2 = "回家了";
		String str3 = new String("回家了");
		String str4 = new String("回家了");

		System.out.println(str1.equals(str2));
		System.out.println(str3.equals(str4));
	}

}
运行结果：
true
true

楼主你怎么运行的。我得到的结果和你不一样。

#5

引用 1 楼  的回复:

前面的返回true很正常，因为内容相等，但是后面的你确认返回时false？如果你说==返回false的话还差不多吧。

赞成1 楼

#6

 public boolean equals(Object anObject) {
	if (this == anObject) {
	    return true;
	}
	if (anObject instanceof String) {
	    String anotherString = (String)anObject;
	    int n = count;
	    if (n == anotherString.count) {
		char v1[] = value;
		char v2[] = anotherString.value;
		int i = offset;
		int j = anotherString.offset;
		while (n-- != 0) {
		    if (v1[i++] != v2[j++])
			return false;
		}
		return true;
	    }
	}
	return false;
    }

源码 一目了然

#7

String s1="回家了"；
  String s2="回家了"；
  s1.equals(s2),返回值是true
 而
 String s1=new String("回家了")
 String s2=new String("回家了")
你的第一个是同一个对象哦，你没有new，它就在一个内存池里找有没有"回家了"找到了，就让s2指向他，所以还是比较的地址
第二个是new了的，所以地址肯定不同

#8

equals方法可以被子类重写，然后多态调用，就这么简单

#9

“但是经常说==两边对象是按地址在比较，而equals()是按内容在比较”这句话在排除根类Object以及没有自己重写equals方法的情况下是对的。

即Object类中equals的实现就是用的==
其他继承Object的equals方法基本上都重写了这个方法，比如String类的equals方法：

equals
public boolean equals(Object anObject)
Compares this string to the specified object. The result is true if and only if the argument is not null and is a String object that represents the same sequence of characters as this object. 

Overrides:
equals in class Object
Parameters:
anObject - The object to compare this String against 
Returns:
true if the given object represents a String equivalent to this string, false otherwise
See Also:
compareTo(String), equalsIgnoreCase(String)

这是String的equals方法源码：

public boolean equals(Object obj)
    {
        if(this == obj)
            return true;
        if(obj instanceof String)
        {
            String s = (String)obj;
            int i = count;
            if(i == s.count)
            {
                char ac[] = value;
                char ac1[] = s.value;
                int j = offset;
                int k = s.offset;
                while(i-- != 0) 
                    if(ac[j++] != ac1[k++])
                        return false;
                return true;
            }
        }
        return false;
    }

#10

equals在没重写之前和==一样，重写之后，equals只要内容一样即为true

#11

拜托，第二个也是相等的。发帖也发个正确的。唉

#12

引用 1 楼  的回复:

前面的返回true很正常，因为内容相等，但是后面的你确认返回时false？如果你说==返回false的话还差不多吧。

说的很对，equals 是用来比值 对象不同 只要值相同 返回肯定是true, 而 ==  是比地址的  如果对象不同，值相等也是返回false

#13

楼主要认真审题哦！！

#14

一个是比较值一个是比较地址

#15

true
ture

#16

我昨天也在为这个问题困惑 后来请教老师 得到的答案是 
这个跟堆栈有关系 一个是直接指向的内存空间 另一个是相当于指针
但是由于现在的虚拟机机制 导致这两种方法现在在分配上已经是一样的

额 差不多就是这样 

但是我回来调试 结果确实是一个true 一个false
难道这个还跟运行环境有关？

#17

第二个 如果是 s1==s2    那就是false   因为new 出来的东西 放在堆内存里面  并且不是同一对象 所以是false

#18

String str1 = "回家了";
    执行这句时，首先到String pool里面去找，发现没有，就把"回家了"这个对象放到String pool里面，并返回string pool 中这个对象的地址赋给str1；

String str2 = "回家了";
    执行这句时，也是首先到String pool里面去找，发现对象"回家了"已经存在，就直接返回地址并赋给str2；

String str3 = new String("回家了");
    执行这句时，首先到String pool里面去看"回家了"这个对象在不在，如果不存在，那么就在String pool中创建这个对象，然后在堆中创建对象"回家了"（不管堆中存不存在都创建），并把堆中这个对象的地址返回赋给str3；如果存在，就直接在堆中创建这个对象，并将地址返回赋给str3；（总之用了new关键字，返回的就是堆中的地址）。

String str4 = new String("回家了");
    执行这句时，跟执行上一句（str3）是一样的。

所以：
    str1 == str2  --->true
   str1.equals(str2) --->true
   str3 == str4   --->false
   str3.equals(str4) --->true

执行equals方法时，首先用 == 判断，如果返回true，就直接返回true，如果返回false，再进一步比较这连个对象的内容。这里可以看equals的源代码，源码面前，了无秘密！

#19

class Compare
{ String s=new String("a");
  public void equals()
  {
    String s=new String("a")
    System.out.println(s==this.s);
  }

}
像这而==比较对象输出是false
这儿成员变量和方法中的变量一模一样，==比较地址不相等。s对象在堆中开辟内存空间，在栈中存储引用，也就是地址值。
这儿成员变量和局部变量中，在栈中的地址没有共享，而是两个不同地址所以输出是false?

#20

理解上有误区了。
String重写了equals方法，重写代码如9楼
String s1 = "回家了"; 
这句话执行时，首先在栈中新建s1引用变量，在常量池而非堆中新建一个“回家了”的引用对象
String s2 = "回家了";
这句话执行时，首先在栈中新建s2引用变量，由于之前的常量池中有“回家了”这里就不新建了。
所以无论==还是equals都相等
---------------------------------------------------
String s1 = new String("回家了"); 
这句话第一次执行，首先在栈中新建s1引用变量，然后在常量池中新建“回家了”引用对象，然后在堆中新建String对象。
String s2 = new String("回家了"); 

这句话执行，首先在栈中新建s1引用变量，由于常量池中有“回家了”引用对象，所以不新建，然后在堆中新建String对象。

而你用s1 == s2 肯定是不等的，因为他们比较的是堆中的地址。

你可以使用s1.intern() == s2.intern() 将这俩个引用变量同时指向常量池中的“回家了”引用对象。
这就相等了

#21

引用 6 楼  的回复:

Java code


 public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObje……

LZ看下JDK源码就明白了

#22

"="运算符，比较两个值是否相等，equals是判断两个对象是否相等，第二个new过了，不是同一个对象

#23

equals跟==一般情况下是等价的，但是对于String类型，它重写了equals方法，比较的是内容。默认情况下两个都是比较的引用，除非你重写equals方法。

#24

近3个月没上csdn了,一来 又见到老话题. 
这个东西在csdn上能搜出过百条把...

#25

引用 18 楼  的回复:

String str1 = "回家了";
  执行这句时，首先到String pool里面去找，发现没有，就把"回家了"这个对象放到String pool里面，并返回string pool 中这个对象的地址赋给str1；

String str2 = "回家了";
  执行这句时，也是首先到String pool里面去找，发现对象"回家了"已经存在，就直接返回地址并赋给str2；

S……

这个解释的很清楚啊

#26

含义不一样。

#27

从源码角度来看

#28

都是true

#29

主要是String类型存在一个静态化处理过程，即String str1 = "aaa"和String str2="aaa",在编译阶段的常量池内会进行一个比对合并过程，如果两值对象相等，只留下一个堆空间对象，把str1和str2的引用指向留下的对象，所以str1==str2为true,如果你换成String str1 = new String("aaa"),String str2 = new String("aaa")这种写法,str1 == str2就为false

#30

引用 16 楼  的回复:

我昨天也在为这个问题困惑 后来请教老师 得到的答案是 
这个跟堆栈有关系 一个是直接指向的内存空间 另一个是相当于指针
但是由于现在的虚拟机机制 导致这两种方法现在在分配上已经是一样的

额 差不多就是这样 

但是我回来调试 结果确实是一个true 一个false
难道这个还跟运行环境有关？

确实跟运行状态有关，String str = 'aaa'的那个String对象，是在编译期间就生成了的，而String str = new String("aaa")的写法，对象要在运行期间才能生成。

#31

查看源码确实明白了为什么String s1=new String("回家了")
  String s2=new String("回家了")
  s1.equals(s2),返回值是true
我也在类中测试了一下“==”

class Compare
{ String s=new String("a");
   public void fun()
   {
   String s=new String("a")
   System.out.println(s==this.s);
   }

}
像这而==比较对象输出是false
这儿成员变量和方法中的变量一模一样，==比较地址不相等。s对象在堆中开辟内存空间，在栈中存储引用，也就是地址值。
这儿成员变量和局部变量中，在栈中的地址没有共享，而是两个不同地址所以输出是false?

#32

后面的返回也是true啊，==才是返回false

#33

因为String类重写equals方法。

#34

引用 16 楼  的回复:

我昨天也在为这个问题困惑 后来请教老师 得到的答案是 
这个跟堆栈有关系 一个是直接指向的内存空间 另一个是相当于指针
但是由于现在的虚拟机机制 导致这两种方法现在在分配上已经是一样的

额 差不多就是这样 

但是我回来调试 结果确实是一个true 一个false
难道这个还跟运行环境有关？

不会有楼主的情况。

2个都是true ，按楼主的意思写的话。

#35

第一种是在StringPool中，同一个字符串，只比较字符串内容，
第二个是不同的String对象，要比较HashCode的值，还有字符串内容的。

#36

你们这…… 
都是true！

#37

补充一下吧，比较的是 hashCode值，对于string hashCode只和值有关系，和其他没有任何关系的！也就是只要值一样，string的hashCode一定相同，可以看看jdk里的String!

#38

两个对象肯定不一样 

#39

字符串直接赋值是在栈中，赋值开始时，会先查找栈中是否有这个字符串，如果有，则指向这个字符串，如果没有则新建一个。
当String s1="回家了"；时， 栈中没有这个字符串，所以会在栈中新建一个，再把s1指向栈中的"回家了"。
当String s2="回家了"；时， 栈中已经有了这么一个字符串，就把s2指向栈中的"回家了"。
所以s2其实和s1指向的都是同一个字符串。

当每次new创建字符串的时候，会再堆中创建一个字符串对象，再在栈中创建这个字符串的引用。
所以s3和s4分别是2个对象的应用，所以返回false

#40

但是String 中的equals是经过重写的，先比较2个是否是同一个对象，如果是则返回true,如果不是则比较2个字符串的值，如果值相同则返回true,否则返回false

#41

引用 20 楼  的回复:

理解上有误区了。
String重写了equals方法，重写代码如9楼
String s1 = "回家了"; 
这句话执行时，首先在栈中新建s1引用变量，在常量池而非堆中新建一个“回家了”的引用对象
String s2 = "回家了";
这句话执行时，首先在栈中新建s2引用变量，由于之前的常量池中有“回家了”这里就不新建了。
所以无论==还是equals都相等
-----------……

20正解！！！已经解释的很清楚了~~~~~~

#42

这问题看看源码就知道了。

#43

引用 6 楼  的回复:

Java code

 public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
   ……

package same;

public class test 
{
public boolean equals(Object anObject)
{
if(this==anObject)
{
return true;
}
if(anObject instanceof String)
{
String anotherString=(String)anObject;
int n=count;
if (n == anotherString.count) {
        char v1[] = value;
        char v2[] = anotherString.value;
        int i = offset;
        int j = anotherString.offset;
        while (n-- != 0) {
            if (v1[i++] != v2[j++])
            return false;
        }
        return true;
        }
    }
    return false;
    }


}

#44

package same;

public class test 
{
public boolean equals(Object anObject)
{
if(this==anObject)
{
return true;
}
if(anObject instanceof String)
{
String anotherString=(String)anObject;
int n=count;
if (n == anotherString.count) {
        char v1[] = value;
        char v2[] = anotherString.value;
        int i = offset;
        int j = anotherString.offset;
        while (n-- != 0) {
            if (v1[i++] != v2[j++])
            return false;
        }
        return true;
        }
    }
    return false;
    }


}
  能运行吗？

#45

在object类中  equals方法就是使用 == 做比较的，
而所有类都是继承object类，
但是有的类却覆盖了object类的equals方法，使用自己的实现方式，比如String覆盖的equals方法，实现了内容的比较

#46

该回复于2012-04-18 13:55:47被版主删除

#47

#48

JDK文档
equals
public boolean equals(Object anObject)比较此字符串与指定的对象。当且仅当该参数不为 null，并且是表示与此对象相同的字符序列的 String 对象时，结果才为 true。 

有空的时候，去看下JDK文档

#49

~了解下

#50

为什么我测试的是两个都返回true?