==测试引用是否相等。

.equals()测试值是否相等。

因此，如果你真的想测试两个字符串是否具有相同的值，你应该使用.equals()(除非在少数情况下，你可以保证具有相同值的两个字符串将由相同的对象表示，例如:字符串实习)。

==用于测试两个字符串是否是同一个Object。

// 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 

// concatenation of string literals happens at compile time resulting in same objects
"test" == "te" + "st"  ==> true

// but .substring() is invoked at runtime, generating distinct objects
"test" == "!test".substring(1) ==> false

值得注意的是，==比equals()更便宜(一个指针比较而不是一个循环)，因此，在适用的情况下(例如，您可以保证您只处理实习字符串)，它可以提供重要的性能改进。然而，这种情况很少见。

==操作符是一个简单的值比较。 对于对象引用，(值)就是(引用)。如果x和y引用同一个对象，则x == y返回true。

让我们分析下面的Java，来理解string的恒等式:

public static void testEquality(){
    String str1 = "Hello world.";
    String str2 = "Hello world.";

    if (str1 == str2)
        System.out.print("str1 == str2\n");
    else
        System.out.print("str1 != str2\n");

    if(str1.equals(str2))
        System.out.print("str1 equals to str2\n");
    else
        System.out.print("str1 doesn't equal to str2\n");

    String str3 = new String("Hello world.");
    String str4 = new String("Hello world.");

    if (str3 == str4)
        System.out.print("str3 == str4\n");
    else
        System.out.print("str3 != str4\n");

    if(str3.equals(str4))
        System.out.print("str3 equals to str4\n");
    else
        System.out.print("str3 doesn't equal to str4\n");
}

当第一行代码String str1 = "Hello world."执行时，一个字符串\Hello world." 创建，变量str1引用它。由于优化，下一行代码执行时不会再次创建另一个字符串“Hello world.”。变量str2也引用现有的“Hello world.”。

运算符==检查两个对象的同一性(两个变量是否引用同一个对象)。由于str1和str2在内存中引用同一个字符串，所以它们彼此是相同的。equals方法检查两个对象是否相等(两个对象是否具有相同的内容)。当然，str1和str2的内容是相同的。

当代码String str3 = new String("Hello world.")执行时，将创建一个内容为"Hello world."的String的新实例，该实例由变量str3引用。然后再次创建内容为"Hello world."的string的另一个实例，并由 str4。因为str3和str4引用了两个不同的实例，所以它们并不相同，但它们是相同的 内容相同。

因此，输出包含四行:

Str1 == str2

Str1 equals str2

Str3! = str4

Str3 equals str4

a==b

比较引用，而不是值。在对象引用中使用==通常仅限于以下情况:

比较一个引用是否为空。 比较两个enum值。这是因为每个枚举常量只有一个对象。 您想知道两个引用是否指向同一个对象

“a”“b”equals()。

比较值是否相等。因为这个方法是在Object类中定义的，所有其他类都是从Object类派生出来的，所以它是为每个类自动定义的。但是，它不会对大多数类执行智能比较，除非类重写它。对于大多数Java核心类，它都以一种有意义的方式定义。如果它不是为(用户)类定义的，它的行为与==相同。

@Melkhiah66你可以使用equals方法代替'=='方法来检查是否相等。 如果使用intern()，则检查对象是否在池中，如果存在则返回 相等否则不相等。Equals方法在内部使用hashcode并获得所需的结果。

public class Demo
{
  public static void main(String[] args)
  {
              String str1 = "Jorman 14988611";
    String str2 = new StringBuffer("Jorman").append(" 14988611").toString();
    String str3 = str2.intern();
    System.out.println("str1 == str2 " + (str1 == str2));           //gives false
    System.out.println("str1 == str3 " + (str1 == str3));           //gives true
    System.out.println("str1 equals str2 " + (str1.equals(str2)));  //gives true
    System.out.println("str1 equals str3 " + (str1.equals(str3)));  //gives true
  }
}

equals()函数是Object类的一个方法，程序员需要重写它。String类重写它，以检查两个字符串是否相等，即在内容和不引用。

==运算符检查两个对象的引用是否相同。

考虑程序

String abc = "Awesome" ;
String xyz =  abc;

if(abc == xyz)
     System.out.println("Refers to same string");

这里的abc和xyz，都是指同一个字符串“Awesome”。因此表达式(abc == xyz)为真。

String abc = "Hello World";
String xyz = "Hello World";

if(abc == xyz)
    System.out.println("Refers to same string");
else
    System.out.println("Refers to different strings");

if(abc.equals(xyz))
     System.out.prinln("Contents of both strings are same");
else
     System.out.prinln("Contents of strings are different");

这里abc和xyz是两个具有相同内容“Hello World”的不同字符串。因此，表达式(abc == xyz)为假，而as (abc.equals(xyz))为真。

希望你理解==和<Object>.equals()之间的区别

谢谢。