在Java中，当==运算符用于比较两个对象时，它会检查对象是否引用内存中的相同位置。换句话说，它检查两个对象名是否基本上是对相同内存位置的引用。
Java String类实际上覆盖了Object类中的默认equals()实现——它覆盖了方法，因此它只检查字符串的值，而不是它们在内存中的位置。这意味着，如果调用equals()方法来比较两个String对象，则只要实际的字符序列相等，两个对象都被视为相等。
==运算符检查两个字符串是否完全相同。
.equals()方法检查两个字符串是否具有相同的值。

还可以使用compareTo()方法比较两个字符串。如果compareTo结果为0，则两个字符串相等，否则被比较的字符串不相等。
==比较参考值，而不比较实际字符串。如果确实使用new String(somestring).intern()创建了每个字符串，则可以使用==运算符比较两个字符串，否则只能使用equals（）或compareTo方法。

所有对象都保证具有.equals()方法，因为对象包含返回布尔值的方法.equals()。如果需要进一步定义，则子类的任务是重写此方法。如果没有它（即使用==），则仅检查两个对象之间的内存地址是否相等。String覆盖了这个.equals()方法，它不使用内存地址，而是返回字符级别的字符串比较，以获得相等性。
需要注意的是，字符串存储在一个块池中，因此一旦创建了字符串，它将永远存储在同一地址的程序中。字符串不会更改，它们是不可变的。这就是为什么如果您有大量的字符串处理要做，那么使用常规字符串连接是一个坏主意。相反，您将使用提供的StringBuilder类。请记住，指向该字符串的指针可以更改，如果您有兴趣查看两个指针是否相同，==将是一个不错的选择。字符串本身并不是。

运算符*==始终用于对象引用比较，而字符串类。为内容比较重写了equals（）*方法：

String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1 == s2); // It prints false (reference comparison)
System.out.println(s1.equals(s2)); // It prints true (content comparison)

如果equals()方法存在于java.lang.Object类中，则应检查对象状态的等价性！这意味着对象的内容。而==操作员应检查实际对象示例是否相同。

• 榜样*

考虑两个不同的参考变量str1和str2：

str1 = new String("abc");
str2 = new String("abc");

如果您使用equals()

System.out.println((str1.equals(str2))?"TRUE":"FALSE");

如果使用==，您将获得TRUE输出。

System.out.println((str1==str2) ? "TRUE" : "FALSE");

现在您将获得FALSE作为输出，因为str1和str2都指向两个不同的对象，尽管它们共享相同的字符串内容。因为new String()，每次都会创建一个新对象。

我认为，当您定义String时，您定义了一个对象。因此，您需要使用.equals()。使用基本数据类型时，使用==，但对于String（和任何对象），必须使用.equals()。

==比较对象的参考值，而java.lang.String类中存在的equals()方法比较String对象（与另一个对象）的内容。

Java有一个字符串池，Java在其中管理字符串对象的内存分配。见String Pools in Java
当您使用==运算符检查（比较）两个对象时，它会将地址相等性与字符串池进行比较。如果两个字符串对象具有相同的地址引用，则返回true，否则返回false。但是，如果要比较两个字符串对象的内容，则必须覆盖equals方法。
equals实际上是对象类的方法，但它被重写为字符串类，并给出了一个新的定义，用于比较对象的内容。

Example:
    stringObjectOne.equals(stringObjectTwo);

但请注意，它尊重字符串的情况。如果要进行不区分大小写的比较，则必须使用String类的equalsIgnoreCase方法。
让我们看看：

String one   = "HELLO"; 
String two   = "HELLO"; 
String three = new String("HELLO"); 
String four  = "hello"; 

one == two;   // TRUE
one == three; // FALSE
one == four;  // FALSE

one.equals(two);            // TRUE
one.equals(three);          // TRUE
one.equals(four);           // FALSE
one.equalsIgnoreCase(four); // TRUE

我同意zacherates的回答。
但您可以在非文字字符串上调用intern()。
来自zacherates的例子：

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

如果您将非文字字符串相等性设为true：

new String("test").intern() == "test" ==> true

==比较Java中的对象引用，String对象也不例外。
为了比较对象（包括String）的实际内容，必须使用equals方法。

如果使用==对两个String对象进行比较，结果是true，这是因为String对象是内部的，并且Java虚拟机具有指向String的同一示例的多个引用。不应期望使用==将包含相同内容的一个String对象与另一个String对象进行比较，以评估为true。

.equals()比较类中的数据（假设实现了函数）。==比较指针位置（对象在内存中的位置）。
如果两个对象（不谈论基元）都指向同一个对象示例，则==返回true。如果两个对象包含相同的数据equals() Versus == in Java，则.equals()返回true
这可能对你有帮助。

==执行引用相等性检查，检查两个对象（本例中的字符串）是否引用内存中的同一对象。
equals()方法将检查两个对象的内容或状态是否相同。
显然，==速度更快，但如果您只想知道两个E1D3D1E是否包含相同的文本，则在许多情况下可能会给出错误结果。
当然，建议使用equals()方法。
不要担心性能。鼓励使用String.equals()的一些事项：
1.String.equals()的实现首先检查引用相等性（使用==），如果两个字符串通过引用相同，则不执行进一步的计算！
1.如果两个字符串引用不相同，String.equals()接下来将检查字符串的长度。这也是一个快速操作，因为String类存储字符串的长度，不需要计算字符或代码点。如果长度不同，则不进行进一步检查，因为我们知道它们不可能相等。
1.只有到目前为止，我们才会实际比较两个字符串的内容，这将是一个简单的比较：不是所有字符都会比较，如果我们发现不匹配的字符（在两个字符串中的相同位置），则不会检查更多字符。
当一切都说了算，即使我们保证字符串是实习生，使用equals()方法仍然不是人们可能认为的开销，绝对是推荐的方法。如果您希望进行有效的引用检查，则在语言规范和实现保证相同的枚举值将是同一对象（通过引用）的情况下使用枚举。

如果你和我一样，当我第一次开始使用Java时，我想使用“==”操作符来测试两个字符串示例是否相等，但不管是好是坏，在Java中这不是正确的方法。
在本教程中，我将演示几种不同的方法来正确比较Java字符串，首先是我大多数时候使用的方法。在本Java字符串比较教程的最后，我还将讨论为什么在比较Java字符串时“==”运算符不起作用。

选项1：Java字符串与equals方法比较大多数情况下（可能95%的情况下），我将字符串与Java字符串类的equals进行比较，如下所示：

if (string1.equals(string2))

这个String equals方法查看两个Java字符串，如果它们包含完全相同的字符串，则认为它们相等。
查看一个使用equals方法的快速字符串比较示例，如果运行以下测试，两个字符串将不会被视为相等，因为字符不完全相同（字符的大小写不同）：

String string1 = "foo";
String string2 = "FOO";

if (string1.equals(string2))
{
    // this line will not print because the
    // java string equals method returns false:
    System.out.println("The two strings are the same.")
}

但是，当两个字符串包含完全相同的字符串时，equals方法将返回true，如下例所示：

String string1 = "foo";
String string2 = "foo";

// test for equality with the java string equals method
if (string1.equals(string2))
{
    // this line WILL print
    System.out.println("The two strings are the same.")
}

选项2：与equalsIgnoreCase方法进行字符串比较

在一些字符串比较测试中，您需要忽略字符串是大写还是小写。当您希望以这种不区分大小写的方式测试字符串的相等性时，请使用String类的equalsIgnoreCase方法，如下所示：

String string1 = "foo";
String string2 = "FOO";

 // java string compare while ignoring case
 if (string1.equalsIgnoreCase(string2))
 {
     // this line WILL print
     System.out.println("Ignoring case, the two strings are the same.")
 }

选项3：使用compareTo方法进行Java字符串比较

还有第三种比较Java字符串的不太常见的方法，即字符串类compareTo方法。如果两个字符串完全相同，则compareTo方法将返回值0（零）。下面是这个字符串比较方法的一个快速示例：

String string1 = "foo bar";
String string2 = "foo bar";

// java string compare example
if (string1.compareTo(string2) == 0)
{
    // this line WILL print
    System.out.println("The two strings are the same.")
}

当我在写Java中的平等概念时，需要注意的是Java语言在基本Java对象类中包含了一个equals方法。每当您创建自己的对象，并且希望提供一种方法来查看对象的两个示例是否“相等”时，您应该在类中重写（并实现）这个equals方法（就像Java语言在字符串equals中提供这种相等/比较行为一样）。
您可能想看看这个==, .equals(), compareTo(), and compare()

功能：

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()检查实际字符串内容（值）。
注意，.equals()方法属于类Object（所有类的超类）。您需要根据您的类要求重写它，但对于字符串，它已经实现，并且它检查两个字符串是否具有相同的值。

*案例1

String s1 = "Stack Overflow";
String s2 = "Stack Overflow";
s1 == s2;      //true
s1.equals(s2); //true

原因：不为空创建的字符串文本存储在堆的permgen区域的字符串池中。因此s1和s2都指向池中的相同对象。

*案例2

String s1 = new String("Stack Overflow");
String s2 = new String("Stack Overflow");
s1 == s2;      //false
s1.equals(s2); //true

原因：如果使用new关键字创建字符串对象，则会在堆上为其分配单独的空间。