判断字符串相等

• “==”操作符用于比较两个对象的地址是否相等。
• .equals() 方法用于比较两个对象的内容是否相等。

String s1 = new String("hh");
String s2 = new String("hh");
// true
System.out.println(s1.equals(s2));
// false
System.out.println(s1 == s2);

• Object类的equals()

// 假如子类没有重写该方法的话，那么“==”操作符和 .equals() 方法的功效就完全一样
public boolean equals(Object obj) {
    return (this == obj);
}

• String类的equals()

public boolean equals(Object anObject) {
    // 检查是否是同一个对象的引用，如果是，直接返回 true
    if (this == anObject) {
        return true;
    }
    // 检查 anObject 是否是 String 类的实例
    if (anObject instanceof String) {
        // 将 anObject 强制转换为 String 类型
        String anotherString = (String)anObject;
        // 获取当前字符串的长度
        int n = value.length;
        // 检查两个字符串长度是否相等
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            // 遍历比较两个字符串的每个字符
            while (n-- != 0) {
                // 如果在任何位置字符不同，则返回 false
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            // 所有字符都相同，返回 true
            return true;
        }
    }
    // 如果 anObject 不是 String 类型或长度不等，则返回 false
    return false;
}

• 举例

// true，equals() 比较的是两个字符串对象的内容是否相等
new String("ha").equals("ha");
// false，左侧的是在堆中创建的对象，右侧是在字符串常量池中的对象，尽管内容相同，但内存地址不同
new String("ha") == "ha";
// false，new 出来的对象肯定是完全不同的内存地址
new String("ha") == new String("ha");
// ture，字符串常量池中只会有一个相同内容的对象
"ha" == "ha";
// true，由于h和a都在字符串常量池，所以编译器在遇到‘+’操作符的时候将其自动优化为ha
"ha" == "h" + "a";
// true，new先在字符串常量池中创建对象，然后再在堆中创建对象
// 执行 intern() 方法的时候发现字符串常量池中已经有了ha这个对象，所以就直接返回字符串常量池中的对象引用了
new String("ha").intern() == "ha";

• Objects.equals()

// 不需要在调用之前判空
public static boolean equals(Object a, Object b) {
    return (a == b) || (a != null && a.equals(b));
}

• String类的.contentEquals()

public boolean contentEquals(CharSequence cs) {
    // Argument is a StringBuffer, StringBuilder
    if (cs instanceof AbstractStringBuilder) {
        if (cs instanceof StringBuffer) {
            synchronized(cs) {
               return nonSyncContentEquals((AbstractStringBuilder)cs);
            }
        } else {
            return nonSyncContentEquals((AbstractStringBuilder)cs);
        }
    }
    // Argument is a String
    if (cs instanceof String) {
        return equals(cs);
    }
    // Argument is a generic CharSequence
    char v1[] = value;
    int n = v1.length;
    if (n != cs.length()) {
        return false;
    }
    for (int i = 0; i < n; i++) {
        if (v1[i] != cs.charAt(i)) {
            return false;
        }
    }
    return true;
}