Java中的参考对比和内容对比

Question

我正在学习参考（或地址）比较和内容比较。下面的说法让我很困惑：

如果一个类没有重写 equals 方法，那么默认情况下，它会使用重写了该方法的最近父类的 equals(Object o) 方法。

需要注意的一点：我没有重写.equals()方法，我只是在我的主类中练习它。

下面是我的代码：

package com.reference.content.comparison;

public class ReferenceAndContentComparison {

    public static void main(String[] args) {

        /* "==" operator is used for REFERENCE (or address) comparison. It means, it check if both objects point to same memory location or not.
         * ".equals()" method is used for CONTENT comparison (in String class). It means, it check if both objects have same value or not.
         * 
         * MAIN DIFFERENCES ARE:
         * 1. "==" is an operator while ".equals()" is a method (of Object class).
         * 2. Line 7 to 8.
         * 3. ".equals()" method of Object class is used for REFERENCE comparison but in String class, it is used for CONTENT reference (by overriding .equals()).
         * 4. If a class does not override the equals method, then by default, it uses the equals(Object o) method of the closest parent class that has overridden this method.
         * 5. When comparing two Strings using .equals() method, their content is compared, and not their references.
         *    Link for point 5: https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#equals-java.lang.Object-
         */
        String s1 = "HELLO";
        String s2 = "HELLO"; // references s1
        String s3 =  new String("HELLO"); // new instance but same content
 
        System.out.println(s1 == s2); // true; Both s1 and s2 refer to same objects. Their addresses are same.
        System.out.println(s1 == s3); // false; Addresses of s1 and s3 are different.
        System.out.println(s1.equals(s2)); // true; Content of both s1 and s2 are same. Content Reference, because s1 and s2 are string class objects.
        System.out.println(s1.equals(s3)); // true; Content of both s1 and s3 are same. Content Reference, because s1 and s3 are string class objects.
        
        System.out.println("-----");
        
        Thread t1 = new Thread();
        Thread t2 = new Thread();
        Thread t3 = t1;
        String st1 = new String("WORLD");
        String st2 = new String("WORLD");
 
        System.out.println(t1 == t3); // true; Both t1 and t3 refer to same objects. Address of t1 is assigned to t3.
        System.out.println(t1 == t2); //false; Addresses of t1 and t2 are different.
        System.out.println(st1 == st2); // false; Addresses of st1 and st2 are different.
        System.out.println(t1.equals(t2)); /* false; Here, t1 and t2 are both Thread class objects (not String class objects) and we haven't overridden the
                                            .equals() method for Thread class anywhere so by default (as per point 4), .equals() of Object class will be
                                            in effect and hence as per point 3, .equals() will be used as REFERNCE Comparison.
                                            And since addresses are different, it's false.*/
        System.out.println(st1.equals(st2)); /* true; Unlike above scenario, st1 and st2 are String class objects and hence as per point 5, content reference is
                                                happening here and since their contents are same, it is true.*/

    }

}

我的困惑是这个t1.equals(t2)由于什么原因给出了 false ？是因为内容不匹配还是这里发生了参考比较？我确信答案是参考比较，因为我没有重写主类中的 .equals() 方法，并且默认情况下它使用 Object 的方法> 类（如开头的声明中所述）。

但也请考虑以下场景：

st1.equals(st2) 给出 true 是因为什么原因？内容是否匹配？是不是这里也发生了参考比较？或者说，既然内容匹配，那不是参考比较而是内容比较？或者，还有别的什么？ 请解释一下。

Answer 1

String 类重写了从 Object 类继承的 equals 方法，并实现了逐个字符比较两个 String 对象的逻辑。

为什么你可能会问，String类是否重写了从Object类继承的equals方法？因为继承自Object的equals方法执行的是引用相等！

这就是为什么当使用 .equals() 方法比较两个字符串时，会比较它们的内容，而不是它们的引用。

证据由您的代码本身提供。

这里还有两个证据表明 String 覆盖了 Object.equals(Object)

Javadoc 暗示了这一点。请注意，相等性基于字符串的内容。事实上，即使 String.equals(Object) 方法存在不同的 Javadoc，也意味着该方法已被重载……考虑到 javadoc 的生成方式。

源代码是这么说的。显然，链接的代码是重载的。显然，这不仅仅是比较对象引用。

注意

正如所评论的，并非 Java 中的所有字符串都被保留。尝试从文件或控制台读取某些内容，这些字符串不是“驻留的”，因此需要覆盖 equals() （以及 hashcode()）。