如何比较爪哇的字符串？

Question

我一直在程序中使用==运算符来比较到目前为止的所有字符串。 但是，我遇到了一个错误，将其中一个更改为.equals（），然后修复了错误。

==不好吗？什么时候应该使用，不应该使用？有什么区别？

Answer 1

== 测试引用相等性（它们是否是同一个对象）。

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

Objects.equals() 在调用 .equals() 之前检查 null，因此您不必这样做（从 JDK7 开始可用，也可用在 番石榴）。

因此，如果您想测试两个字符串是否具有相同的值，您可能需要使用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

来自 Java 语言规范 JLS 15.21 .3.参考相等运算符 == 和 !=：

虽然==可用于比较String类型的引用，但这样的相等测试确定两个操作数是否引用相同的String< /代码> 对象。如果操作数是不同的 String 对象，即使它们包含相同的字符序列 (§3.10.5，§3.10.6) 。可以通过方法调用 s.equals(t) 来测试两个字符串 s 和 t 的内容是否相等。




您几乎总是想要使用Objects.equals()。在罕见情况下，您知道您正在处理interned 字符串，您可以使用==。

从 JLS 3.10.5 开始。 字符串文字：

此外，字符串文字始终引用 String 类的相同实例。这是因为字符串文字 - 或者更一般地说，字符串是常量表达式的值 (§15.28) - 使用 String.intern 方法进行“实习”，以便共享唯一实例。

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

需要考虑的其他方法

String.equalsIgnoreCase() 忽略大小写的值相等。但请注意，此方法在各种与区域设置相关的情况下可能会产生意外结果，请参阅此问题< /a>.

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

Answer 2

== 测试对象引用，.equals() 测试字符串值。

有时看起来好像 == 比较值，因为 Java 会在幕后做一些事情来确保相同的内联字符串实际上是同一个对象。

例如：

String fooString1 = new String("foo");
String fooString2 = new String("foo");

// Evaluates to false
fooString1 == fooString2;

// Evaluates to true
fooString1.equals(fooString2);

// Evaluates to true, because Java uses the same object
"bar" == "bar";

但是要小心空值！

== 可以很好地处理 null 字符串，但是从以下位置调用 .equals() null 字符串会导致异常：

String nullString1 = null;
String nullString2 = null;

// Evaluates to true
System.out.print(nullString1 == nullString2);

// Throws a NullPointerException
System.out.print(nullString1.equals(nullString2));

因此，如果您知道 fooString1 可能为 null，请告诉读者，通过编写

System.out.print(fooString1 != null && fooString1.equals("bar"));

以下内容会更短，但检查 null 的情况不太明显：

System.out.print("bar".equals(fooString1));  // "bar" is never null
System.out.print(Objects.equals(fooString1, "bar"));  // Java 7 required

Answer 3

== 比较对象引用。

.equals() 比较字符串值。

有时 == 会产生比较 String 值的错觉，如下例所示：

String a="Test";
String b="Test";
if(a==b) ===> true

这是因为当您创建任何 String 文字时，JVM 首先在 String 池中搜索该文字，如果找到匹配项，同样的引用将被赋予新的字符串。因此，我们得到：

(a==b) ===> true

                       String Pool
     b -----------------> "test" <-----------------a

但是，== 在以下情况下会失败：

String a="test";
String b=new String("test");
if (a==b) ===> false

在这种情况下，对于 new String("test") 语句 new String 将在堆上创建，并且该引用将被赋予 b，因此 b 将在堆上获得引用，而不是在字符串池中。

现在a指向字符串池中的字符串，而b指向堆上的字符串。因此我们得到：

if(a==b) ===> false。

                String Pool
     "test" <-------------------- a

                   Heap
     "test" <-------------------- b

虽然 .equals() 始终比较 String 的值，因此在两种情况下都给出 true：

String a="Test";
String b="Test";
if(a.equals(b)) ===> true

String a="test";
String b=new String("test");
if(a.equals(b)) ===> true

因此使用 .equals() 总是更好。

Answer 4

==操作员检查两个字符串是否完全是同一对象。

.equals（）方法将检查两个字符串是否具有相同的值。

Answer 5

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

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

那么问题是，如果所有的字符串都缓存在系统中，为什么 == 返回 false 而 equals 返回 true？嗯，这是可能的。如果您创建一个像 String str = new String("Testing") 这样的新字符串，您最终会在缓存中创建一个新字符串，即使缓存已经包含具有相同内容的字符串。简而言之，"MyString" == new String("MyString") 将始终返回 false。

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

注意： == 运算符比 equals 快得多，因为您正在比较两个内存地址，但您需要确保代码不会在代码中创建新的 String 实例。否则你会遇到错误。

Answer 6

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" 的新引用。参考文献不同，但内容是一样的。

Answer 7

是的，这很糟糕...

==表示您的两个字符串引用完全是同一对象。您可能已经听说过这种情况，因为Java保留了一个字面的表（它确实如此），但并非总是如此。一些字符串以不同的方式加载，从其他字符串等构建，因此您绝对不能假设两个相同的字符串存储在同一位置。

平等为您提供了真正的比较。

Answer 8

是的，==对比较字符串不利（除非您知道它们是规范的）。 ==只需比较对象引用。 .equals（）测试平等。对于字符串而言，通常它们会相同，但是正如您发现的那样，这并不能始终保证。

Answer 9

Java 有一个字符串池，Java 在该池下管理字符串对象的内存分配。请参阅 Java 中的字符串池

当您检查 (比较）两个对象，使用 == 运算符将地址相等性与字符串池进行比较。如果两个 String 对象具有相同的地址引用，则返回 true，否则返回 false。但如果您想比较两个 String 对象的内容，则必须重写 equals 方法。

equals实际上是Object类的方法，但它被重写到String类中，并给出了一个新的定义来比较对象的内容。

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

Answer 10

我同意zacherates的回答。

但您可以做的是对非文字字符串调用 intern() 。

来自 zacherates 示例：

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

如果您实习，非文字字符串相等性为 true：

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

Answer 11

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

要比较对象（包括String）的实际内容，必须使用equals方法。

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

Answer 12

.equals() 比较类中的数据（假设该函数已实现）。
== 比较指针位置（对象在内存中的位置）。

如果两个对象（不谈论基元）都指向相同的对象实例，则 == 返回 true。
如果两个对象包含相同的数据，.equals() 返回 true equals() 与 Java 中的 ==

这可能对你有帮助。

Answer 13

== 执行引用相等性检查，检查两个对象（本例中为字符串）是否引用内存中的同一对象。

equals() 方法将检查两个对象的内容或状态是否相同。

显然 == 更快，但如果您只想判断 2 个 String 是否包含相同的文本，则在许多情况下会（可能）给出错误结果。

绝对推荐使用equals()方法。

不用担心性能。鼓励使用 String.equals() 的一些事情：

1. String.equals() 的实现首先检查引用相等性（使用 ==），如果两个字符串通过引用相同，则不再执行进一步的计算！
2. 如果两个字符串引用不相同，String.equals() 接下来将检查字符串的长度。这也是一个快速操作，因为 String 类存储字符串的长度，不需要计算字符或代码点。如果长度不同，则不执行进一步检查，我们知道它们不可能相等。
3. 只有到这里为止，才会真正比较两个字符串的内容，这将是一个简写比较：如果我们发现不匹配的字符（在两个字符串中的相同位置），则不会比较所有字符)，不再检查其他字符。

总而言之，即使我们保证字符串是实习生，使用 equals() 方法仍然不是人们想象的那样的开销，这绝对是推荐的方法。如果您想要有效的引用检查，请使用枚举，其中语言规范和实现保证相同的枚举值将是相同的对象（通过引用）。

Answer 14

如果您像我一样，当我第一次开始使用 Java 时，我想使用“==”运算符来测试两个 String 实例是否相等，但无论好坏，这都不是在 Java 中执行此操作的正确方法。

在本教程中，我将演示几种正确比较 Java 字符串的不同方法，从我最常使用的方法开始。在本 Java 字符串比较教程的最后，我还将讨论为什么“==”运算符在比较 Java 字符串时不起作用。

选项1：使用equals方法比较Java字符串
大多数时候（也许是 95% 的时间）我用 Java String 类的 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 String 比较

还有第三种方法比较 Java 字符串的不太常见的方法，那就是使用 String 类的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 Object 类中包含 equals 方法。每当您创建自己的对象并且想要提供一种方法来查看对象的两个实例是否“相等”时，您应该在类中重写（并实现）此 equals 方法（与 Java 语言提供的方式相同） String equals 方法中的这种相等/比较行为）。

您可能想看看这个==，。 equals()、compareTo() 和compare()

Answer 15

功能：

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

Answer 16

== 运算符检查两个引用是否指向同一个对象。 .equals() 检查实际的字符串内容（值）。

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

• 案例1

  字符串 s1 = "堆栈溢出";
  String s2 = "堆栈溢出";
  s1==s2； //真的
  s1.等于(s2); //真的
  

  原因：创建的不带 null 的字符串文字存储在堆的 permgen 区域的字符串池中。因此 s1 和 s2 都指向池中的同一个对象。

• 案例2

  String s1 = new String("堆栈溢出");
  String s2 = new String("堆栈溢出");
  s1==s2； //错误的
  s1.等于(s2); //真的
  

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

Answer 17

== 比较对象的引用值，而 java.lang.String 类中的 equals() 方法比较 equals() 的内容code>String 对象（到另一个对象）。

Answer 18

我认为，当您定义字符串时，您会定义对象。因此，您需要使用.equals（）。当您使用原始数据类型时，您会使用==，但使用String（和任何对象），必须使用.equals（）。

Answer 19

如果 java.lang.Object 类中存在 equals() 方法，并且期望检查对象状态的等效性！这意味着对象的内容。而 == 运算符应该检查实际的对象实例是否相同。

示例

考虑两个不同的引用变量，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() 每次都会创建一个新对象。

Answer 20

操作员 == 始终用于对象参考比较，而字符串类 .equals（）方法被覆盖为内容比较< /strong>：

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)

Answer 21

所有对象都可以保证具有.equals（）方法，因为对象包含.equals（），返回布尔值。如果需要进一步的定义定义，则覆盖此方法是子类的工作。没有它（即使用==），仅在两个对象之间检查内存地址以保持平等。字符串覆盖此.equals（）方法，而不是使用内存地址，而是返回字符级别的字符串比较以获得平等。

一个关键要注意的是，字符串存储在一个块池中，因此一旦创建了字符串，它将永远存储在同一地址的程序中。字符串不会改变，它们是不变的。这就是为什么如果您有大量的字符串处理要做，使用常规字符串串联是一个坏主意的原因。相反，您将使用提供的StringBuilder类。请记住，该字符串的指针可能会更改，如果您有兴趣查看两个指针是否相同==是一个很好的方法。字符串本身没有。

Answer 22

您还可以使用 compareTo() 方法来比较两个字符串。如果compareTo结果为0，则两个字符串相等，否则比较的字符串不相等。

== 比较引用而不比较实际字符串。如果您确实使用 new String(somestring).intern() 创建了每个字符串，那么您可以使用 == 运算符来比较两个字符串，否则使用 equals() 或compareTo 方法只能使用。

Answer 23

在Java中，当使用==运算符比较2个对象时，它检查对象是否涉及内存中的同一位置。换句话说，它检查了两个对象名称是否基本上是引用了同一内存位置。

Java 字符串类实际覆盖默认equals（）在object类中实现 - 它覆盖了该方法，以便仅检查值字符串，而不是记忆中的位置。
这意味着，如果您调用equals（）进行比较2 字符串对象的方法，那么只要字符的实际顺序相等，两个对象都被认为是相等的。

==操作员检查两个字符串是否完全是同一对象。

.equals（）方法检查两个字符串是否具有相同的值。