String.equals 与 == [duplicate]

使用 string.equals（Object other） 函数比较字符串，而不是运算符。==

该函数检查字符串的实际内容，运算符检查对对象的引用是否相等。请注意，字符串常量通常是“内部”的，因此实际上可以比较两个具有相同值的常量，但最好不要依赖它。====

if (usuario.equals(datos[0])) {
    ...
}

注意：比较是在“usuario”上完成的，因为它在你的代码中保证不为空，尽管你仍然应该检查数组中是否确实有一些标记，否则你会得到一个数组越界异常。datos

而不是

datos[0] == usuario

用

datos[0].equals(usuario)

==比较变量的引用，其中比较您想要的值。.equals()

您应该使用字符串等于来比较两个字符串是否相等，而不是运算符 ==，它只是比较引用。

值得一提的是，在某些情况下，使用“==”运算符可以产生预期的结果，因为 java 处理字符串的方式 - 字符串文字在编译过程中被嵌入（参见 ） - 因此，当您在两个类中编写示例并将这些字符串与“==”进行比较时，您可以得到 result： true，这是根据规范预期的;当您比较相同的字符串（如果它们具有相同的值）时，第一个是字符串文字（即通过 定义），第二个是在运行时构造的，即。对于 “new” 关键字，（equality） 运算符返回 false，因为它们都是类的不同实例。String.intern()"hello world""i am string literal"new String("i am string literal")==String

唯一正确的方法是使用 .equals（） -> datos[0].equals（usuario）。 仅当两个对象是对象的相同实例（即具有相同的内存地址）时才表示==

更新：01.04.2013 我更新了这篇文章，因为下面的评论在某种程度上是正确的。最初我声明实习（String.intern）是JVM优化的副作用。虽然它确实节省了内存资源（这就是我所说的“优化”的意思），但它主要是语言的特性

如果您在将字符串插入数组之前调用该字符串，它也将起作用。 当且仅当被隔离的字符串的值等于 （.） 时，它们才是引用相等的 （）intern()==equals()

public static void main (String... aArguments) throws IOException {

String usuario = "Jorman";
String password = "14988611";

String strDatos="Jorman 14988611";
StringTokenizer tokens=new StringTokenizer(strDatos, " ");
int nDatos=tokens.countTokens();
String[] datos=new String[nDatos];
int i=0;

while(tokens.hasMoreTokens()) {
    String str=tokens.nextToken();
    datos[i]= str.intern();            
    i++;
}

//System.out.println (usuario);

if(datos[0]==usuario) {  
     System.out.println ("WORKING");    
}

equals()函数是一种类方法，应该由程序员重写。 类覆盖它以检查两个字符串是否相等，即在内容而不是引用中。ObjectString

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

考虑程序

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

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

这里的 和 ，都是指相同的。因此表达式是 。abcxyzString"Awesome"(abc == xyz)true

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");

这里是两个内容相同的不同字符串。因此，这里的表达式是 where as is .abcxyz"Hello World"(abc == xyz)false(abc.equals(xyz))true

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

谢谢。

我们来分析一下下面的 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."

运算符检查两个对象的标识（两个变量是否引用同一对象）。由于 和 引用内存中的相同字符串，因此它们彼此相同。该方法检查两个对象是否相等（两个对象是否具有相同的内容）。当然，和的内容是一样的。==str1str2equalsstr1str2

当代码执行时，将创建一个包含内容的字符串的新实例，并由变量 引用。然后再次创建另一个包含内容的字符串实例，并由 引用。由于 和 指的是两个不同的实例，因此它们并不相同，但它们 内容是一样的。String str3 = new String("Hello world.")"Hello world."str3"Hello world."str4str3str4

因此，输出包含四行：

Str1 == str2

Str1 equals str2

Str3! = str4

Str3 equals str4

==运算符比较 Java 中对象的引用。您可以使用字符串的方法。equals

String s = "Test";
if(s.equals("Test"))
{
    System.out.println("Equal");
}

如果您要比较字符串的任何赋值，即原始字符串，“==”和 .equals 都可以使用，但对于新的字符串对象，您应该只使用 .equals，这里的“==”将不起作用。

例：

String a = "name";

String b = "name";

if(a == b)并将返回 true。(a.equals(b))

但

String a = new String("a");

在这种情况下将返回if(a == b)false

所以最好使用运算符....equals

使用 Split 而不是 tokenizer，它肯定会提供准确的输出 例如：

string name="Harry";
string salary="25000";
string namsal="Harry 25000";
string[] s=namsal.split(" ");
for(int i=0;i<s.length;i++)
{
System.out.println(s[i]);
}
if(s[0].equals("Harry"))
{
System.out.println("Task Complete");
}

在此之后，我相信你会得到更好的结果......

通常用于比较，其中要验证两者是否具有相同的值。.equalsObjectObjects

==用于参考比较（两者在堆上是否相同）并检查是否为 null。它还用于比较基元类型的值。ObjectsObjectObject

== 运算符是值的简单比较。
对于对象引用，（值）是（引用）。因此，如果 x 和 y 引用同一对象，则 x == y 返回 true。

@Melkhiah66 您可以使用 equals 方法代替 '==' 方法来检查是否相等。 如果使用 intern（），则检查对象是否在池中（如果存在），则返回 等于否则不相等。equals 方法在内部使用哈希码并为您提供所需的结果。

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

我知道这是一个老问题，但这是我如何看待它（我发现非常有用）：

技术说明

在 Java 中，所有变量要么是原始类型，要么是引用。

（如果你需要知道什么是引用：“对象变量”只是指向对象的指针。因此，某些东西实际上是内存中的地址（一个数字）。Object something = ...

==比较确切的值。因此，它会比较原始值是否相同，或者引用（地址）是否相同。这就是为什么通常不适用于字符串的原因;字符串是对象，对两个字符串变量执行操作只是比较内存中的地址是否相同，正如其他人指出的那样。 调用对象的比较方法，该方法将比较引用指向的实际对象。对于字符串，它会比较每个字符以查看它们是否相等。====.equals()

有趣的部分：

那么，为什么有时字符串会返回 true？请注意，字符串是不可变的。在代码中，如果这样做==

String foo = "hi";
String bar = "hi";

由于字符串是不可变的（当你调用或某些东西时，它会生成一个新字符串，而不是修改内存中指向的原始对象），所以你实际上不需要两个不同的对象。如果编译器是智能的，则字节码将读取为仅生成一个对象。所以如果你这样做.trim()String("hi")String("hi")

if (foo == bar) ...

紧接着，它们指向同一个对象，并将返回 true。但你很少打算这样做。相反，你要求用户输入，即在内存的不同部分创建新的字符串，等等。

注意：如果你做了类似的事情，编译器可能仍然会发现它们是一回事。但重点是，当编译器看到文字字符串时，它可以轻松优化相同的字符串。baz = new String(bar)

我不知道它在运行时是如何工作的，但我假设 JVM 不保留“实时字符串”列表并检查是否存在相同的字符串。（例如，如果您两次读取一行输入，并且用户输入两次相同的输入，则不会检查第二个输入字符串是否与第一个输入字符串相同，并将它们指向相同的内存）。这样可以节省一些堆内存，但可以忽略不计，开销不值得。同样，关键是编译器很容易优化文字字符串。

你有它......对 VS 的坚韧不拔的解释。 以及为什么它看起来是随机的。==.equals()

==参考相等性测试。

.equals()价值相等性测试。

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

==用于测试两个字符串是否相同。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()

认识 Jorman

Jorman是一位成功的商人，拥有2栋房屋。

但其他人不知道。

是同一个乔曼吗？

当你问麦迪逊街或伯克街的邻居时，他们只能说：

仅使用住所，很难确认它是同一个乔曼。由于它们是 2 个不同的地址，因此很自然地假设它们是 2 个不同的人。

这就是运算符 == 的行为方式。所以它会说这是错误的，因为它只比较地址。datos[0]==usuario

救援调查员

如果我们派一个调查员呢？我们知道这是同一个乔曼，但我们需要证明这一点。我们的侦探将仔细观察所有物理方面。通过彻底的调查，代理人将能够得出结论，这是否是同一个人。让我们看看它在 Java 术语中的发生。

下面是 String 方法的源代码：equals()

它逐个字符比较字符串，以便得出结论，它们确实是相等的。

这就是 String equals 方法的行为方式。因此将返回 true，因为它执行逻辑比较。datos[0].equals(usuario)

将检查两个字符串是否具有相同的值并返回值，因为运算符会检查这两个字符串是否是同一个对象。.equals()boolean==

有人在更高的帖子上说 == 用于 int 和检查 null。 它还可用于检查布尔运算和字符类型。

不过要非常小心，并仔细检查您使用的是 char 而不是 String。 例如

    String strType = "a";
    char charType = 'a';

对于字符串，您将检查 这是正确的

    if(strType.equals("a")
        do something

但

    if(charType.equals('a')
        do something else

不正确，您需要执行以下操作

    if(charType == 'a')
         do something else

The == operator checks if the two references point to the same object or not.
.equals() checks for the actual string content (value).

请注意，.equals（） 方法属于类 Object（所有类的超类）。您需要根据类要求覆盖它，但对于 String，它已经实现，它会检查两个字符串是否具有相同的值。

Case1)
String s1 = "Stack Overflow";
String s2 = "Stack Overflow";
s1 == s1;      // true
s1.equals(s2); // true
Reason: String literals created without null are stored in the string pool in the permgen area of the heap. So both s1 and s2 point to the same object in the pool.
Case2)
String s1 = new String("Stack Overflow");
String s2 = new String("Stack Overflow");
s1 == s2;      // false
s1.equals(s2); // true
Reason: If you create a String object using the `new` keyword a separate space is allocated to it on the heap.

a==b

比较引用，而不是值。with 对象引用的使用通常仅限于以下几种：==

1. 比较以查看引用是否为 .null

2. 比较两个枚举值。这之所以有效，是因为每个常量只有一个对象。enum

3. 您想知道两个引用是否指向同一对象

"a".equals("b")

比较值是否相等。由于此方法是在类中定义的，所有其他类都是从该类派生的，因此会自动为每个类定义此方法。但是，它不会对大多数类执行智能比较，除非类覆盖它。对于大多数 Java 核心类来说，它都是以一种有意义的方式定义的。如果未为（用户）类定义它，则其行为与 相同。Object==