java中的default equals实现如何用于字符串？

我们都知道，如果我们创建两个String对象并使用==对它们进行比较，它将返回false，如果我们使用equals to方法，它将返回true。但是默认情况下equals方法implement==only，那么它如何返回true，它应该返回==返回的内容？？？

equals

方法最初是

对象

类的方法。默认情况下，Java中的每个类都扩展了

对象

类。现在，

equals

方法被重写，使

String

类的行为与

=

不同

它完美地解释了这一点：

将此字符串与指定的对象进行比较。结果是 当且仅当参数不为null且为 表示与此相同字符序列的字符串对象 反对

它的实现如下所示：

@override
public boolean equals(Object anObject) {
// This check is just for the case when exact same String object is passed
if (this == anObject) {
    return true;
}
// After this only real implementation of equals start which you might be looking for
// For other cases checks start from here
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;
}

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;
      }

---

String类中的equals方法被重写，它尝试检查两个字符串中的所有字符是否相等。如果找到，则返回true。因此，字符串类中equals方法的行为不同于它的普通对象类实现。

是默认情况下equals方法在

对象
类中实现
==
。但是您可以在自己的类中重写
equals
方法，以更改在同一类的两个对象之间执行
equality
的方式。例如，
String
类中的
equals
方法被覆盖如下：

@override
public boolean equals(Object anObject) {
// This check is just for the case when exact same String object is passed
if (this == anObject) {
    return true;
}
// After this only real implementation of equals start which you might be looking for
// For other cases checks start from here
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;
}

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;
      }

这就是以下代码的原因：

String s1 = new String("java");
String s2 = new String("java");

s1==s2
返回
false
，因为两者都引用堆上的不同对象。而
s1.equals（s2）
返回
true
，因为现在调用的
equals
是
String
类中定义的，其中
String
对象根据字符串的
内容进行比较。
.equals（）
检查字符串是否相同。有相同的字符<代码>=
仅检查指针是否指向相同的对象。您可以拥有具有相同字符的不同对象，这就是为什么您应该使用
.equals（）
来比较它们
String
类在java中重写
对象
类的
equals
方法，以便它比较两个字符串的内容，而不是比较引用（在
对象
类中的默认实现）

请参见下面的
equals
方法实现
String
类：

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;
    }

equals方法在String类中被重写。这就是为什么。默认情况下，
equals
不会为String类实现
=
。他的问题是，即使equals实现
=
，它们的行为如何都不同！@Amar:在否决某人的答案之前，请重新阅读问题并成熟地思考。OP正在询问sinc默认情况下，e
equals
方法检查
=
，那么为什么两个不同
字符串的
equals
方法返回的内容相同
true
。这就是我在回答中解释的原因。也请重新阅读我的答案。也许吧！我从问题中了解到的是，他已经回答了我实际看到了字符串的实现，并被最初的
==
检查方法弄糊涂了。如果这种理解是错误的，我肯定会收回我的否决票。顺便说一句，不需要在这里对我的成熟度发表个人评论。冷静。@Amar:如果OP已经通过
字符串中的
等于
方法源代码e> 我相信他不会提出这个问题。因为在
==
字符串
类的
方法中，
==
失败后，还进行了一些其他检查。这肯定会被OP注意到。是的，我的错。也许你是对的。