Java中的字符串是不可变的。这意味着每当您尝试更改/修改字符串时，都会得到一个新实例。你不能改变原来的字符串。这样做是为了缓存这些字符串实例。典型的程序包含大量字符串引用，缓存这些实例可以减少内存占用并提高程序的性能。

当使用==运算符进行字符串比较时，您不是在比较字符串的内容，而是在比较内存地址。如果两者相等，则返回true，否则返回false。而字符串中的equals则比较字符串内容。

问题是，如果所有字符串都缓存在系统中，为什么==返回false，而==返回true?这是可能的。如果你创建一个新的字符串，比如string str = new string ("Testing")，你最终会在缓存中创建一个新的字符串，即使缓存中已经包含了一个具有相同内容的字符串。总之，"MyString" == new String("MyString")将总是返回false。

Java还讨论了intern()函数，该函数可用于字符串，使其成为缓存的一部分，因此"MyString" == new string ("MyString").intern()将返回true。

注意:==操作符比equals快得多，因为您比较的是两个内存地址，但您需要确保代码没有在代码中创建新的String实例。否则会遇到bug。

==测试引用是否相等(它们是否是同一个对象)。

.equals()测试值是否相等(它们是否包含相同的数据)。

Objects.equals()在调用.equals()之前检查是否为空，因此不必这样做(在JDK7中可用，在Guava中也可用)。

因此，如果你想测试两个字符串是否具有相同的值，你可能会使用Objects.equals()。

// These two have the same value
new String("test").equals("test") // --> true 

// ... but they are not the same object
new String("test") == "test" // --> false 

// ... neither are these
new String("test") == new String("test") // --> false 

// ... but these are because literals are interned by 
// the compiler and thus refer to the same object
"test" == "test" // --> true 

// ... string literals are concatenated by the compiler
// and the results are interned.
"test" == "te" + "st" // --> true

// ... but you should really just call Objects.equals()
Objects.equals("test", new String("test")) // --> true
Objects.equals(null, "test") // --> false
Objects.equals(null, null) // --> true

你几乎总是想使用Objects.equals()。在极少数情况下，您知道您正在处理的是实习字符串，您可以使用==。

来自JLS 3.10.5。字符串:

而且，string字面值总是引用string类的同一个实例。这是因为字符串字面量——或者更一般地说，是常量表达式的值的字符串(§15.28)——被“internned”，以便使用string .intern方法共享唯一的实例。

在JLS 3.10.5-1中也可以找到类似的例子。

其他需要考虑的方法

String.equalsIgnoreCase()忽略大小写的值相等性。但是要注意，在各种与区域设置相关的情况下，此方法可能会产生意想不到的结果，请参阅这个问题。

String. contentequals()将String的内容与任何CharSequence的内容进行比较(自Java 1.5起可用)。在进行相等比较之前，不必将StringBuffer等转换为String，但将null检查留给您。

功能:

public float simpleSimilarity(String u, String v) {
    String[] a = u.split(" ");
    String[] b = v.split(" ");

    long correct = 0;
    int minLen = Math.min(a.length, b.length);

    for (int i = 0; i < minLen; i++) {
        String aa = a[i];
        String bb = b[i];
        int minWordLength = Math.min(aa.length(), bb.length());

        for (int j = 0; j < minWordLength; j++) {
            if (aa.charAt(j) == bb.charAt(j)) {
                correct++;
            }
        }
    }

    return (float) (((double) correct) / Math.max(u.length(), v.length()));
}

测试:

String a = "This is the first string.";

String b = "this is not 1st string!";

// for exact string comparison, use .equals

boolean exact = a.equals(b);

// For similarity check, there are libraries for this
// Here I'll try a simple example I wrote

float similarity = simple_similarity(a,b);

是的，==不利于比较字符串(实际上是任何对象，除非您知道它们是规范的)。==只是比较对象引用。.equals()测试是否相等。对于字符串，它们通常是相同的，但正如你所发现的，这并不总是保证的。

==比较Java中的对象引用，String对象也不例外。

为了比较对象(包括String)的实际内容，必须使用equals方法。

如果使用==对两个String对象进行比较的结果为真，那是因为String对象被合并了，并且Java虚拟机有多个引用指向同一个String实例。不要期望使用==比较一个包含相同内容的String对象与另一个String对象的计算结果为true。

String a = new String("foo");
String b = new String("foo");
System.out.println(a == b); // prints false
System.out.println(a.equals(b)); // prints true

确保你明白其中的原因。这是因为==比较只比较引用;equals()方法对内容逐字符进行比较。

当你为a和b调用new时，每一个都得到一个指向字符串表中的“foo”的新引用。参考文献不同，但内容是一样的。