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

==测试引用是否相等。

.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()更便宜(一个指针比较而不是一个循环)，因此，在适用的情况下(例如，您可以保证您只处理实习字符串)，它可以提供重要的性能改进。然而，这种情况很少见。

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()之间的区别

谢谢。

It's good to notice that in some cases use of "==" operator can lead to the expected result, because the way how java handles strings - string literals are interned (see String.intern()) during compilation - so when you write for example "hello world" in two classes and compare those strings with "==" you could get result: true, which is expected according to specification; when you compare same strings (if they have same value) when the first one is string literal (ie. defined through "i am string literal") and second is constructed during runtime ie. with "new" keyword like new String("i am string literal"), the == (equality) operator returns false, because both of them are different instances of the String class.

唯一正确的方法是使用.equals() -> datos[0].equals(通常)。==表示仅当两个对象是object的相同实例(即。内存地址相同)

更新:01.04.2013我更新了这篇文章，因为下面的评论是正确的。最初我声明实习(String.intern)是JVM优化的副作用。虽然它确实节省了内存资源(这就是我所说的“优化”)，但它是语言的主要特征

==操作符是一个简单的值比较。 对于对象引用，(值)就是(引用)。如果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