问题:如何比较Java中的字符串?

我一直在程序中使用==运算符比较到目前为止的所有字符串。但是,我遇到了一个错误,而是将其中一个更改为.equals(),并修复了该错误。

==不好吗?什么时候应该使用它,不应该使用它?有什么区别?

标签:java,string,equality

Q: How do I compare strings in Java?

I've been using the == operator in my program to compare all my strings so far. However, I ran into a bug, changed one of them into .equals() instead, and it fixed the bug.

Is == bad? When should it and should it not be used? What's the difference?

回答1:

==测试引用是否相等(它们是否是同一对象)。

.equals()测试值的相等性(在逻辑上是否相等)。

Objects.equals()在调用.equals()之前检查是否为null,因此您不必(自JDK7起可用) ,也可以在 Guava )中找到。

字符串.contentEquals()String的内容与任何CharSequence的内容(从Java 1.5开始可用)进行比较。

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

您几乎总是要使用Objects.equals()。在了解的情况下,遇到已插入的字符串,您可以使用==

来自 JLS 3.10。 5, 字符串文字

此外,字符串文字总是引用类String same 实例。这是因为字符串文字-或更一般而言,是作为常量表达式值的字符串(§15.28)-使用方法String.intern进行"实习",以便共享唯一的实例。

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

A1:

== tests for reference equality (whether they are the same object).

.equals() tests for value equality (whether they are logically "equal").

Objects.equals() checks for null before calling .equals() so you don't have to (available as of JDK7, also available in Guava).

String.contentEquals() compares the content of the String with the content of any CharSequence (available since Java 1.5).

Consequently, if you want to test whether two strings have the same value you will probably want to use 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

You almost always want to use Objects.equals(). In the rare situation where you know you're dealing with interned strings, you can use ==.

From JLS 3.10.5. String Literals:

Moreover, a string literal always refers to the same instance of class String. This is because string literals - or, more generally, strings that are the values of constant expressions (§15.28) - are "interned" so as to share unique instances, using the method String.intern.

Similar examples can also be found in JLS 3.10.5-1.

回答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()会导致异常:

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

以下内容更简短,但它不检查(从Java 7开始)是否为null:

System.out.print(Objects.equals(fooString1, "bar"));

A2:

== tests object references, .equals() tests the string values.

Sometimes it looks as if == compares values, because Java does some behind-the-scenes stuff to make sure identical in-line strings are actually the same object.

For example:

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

But beware of nulls!

== handles null strings fine, but calling .equals() from a null string will cause an exception:

String nullString1 = null;
String nullString2 = null;

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

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

So if you know that fooString1 may be null, tell the reader that by writing

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

The following is shorter, but it’s less obvious that it checks for null (from Java 7):

System.out.print(Objects.equals(fooString1, "bar"));

回答3:

==比较对象引用。

.equals()比较字符串值。

有时==给出了比较String值的错觉,如以下情况:

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

这是因为,当您创建任何String文字时,JVM首先在String池中搜索该文字,并且如果找到匹配项,则将对新String赋予相同的引用。因此,我们得到:

(a == b)===>是

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

但是,在以下情况下,==失败:

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

在这种情况下,对于newString("test"),将在堆上创建new String语句,并将对该引用给予b,因此<将在堆上而不是在字符串池中给code> b 一个引用。

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

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

                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()总是更好。

A3:

== compares Object references.

.equals() compares String values.

Sometimes == gives illusions of comparing String values, as in following cases:

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

This is because when you create any String literal, the JVM first searches for that literal in the String pool, and if it finds a match, that same reference will be given to the new String. Because of this, we get:

(a==b) ===> true

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

However, == fails in the following case:

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

In this case for new String("test") the statement new String will be created on the heap, and that reference will be given to b, so b will be given a reference on the heap, not in String pool.

Now a is pointing to a String in the String pool while b is pointing to a String on the heap. Because of that we get:

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

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

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

While .equals() always compares a value of String so it gives true in both cases:

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

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

So using .equals() is always better.

回答4:

==运算符检查两个字符串是否完全相同。

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

A4:

The == operator checks to see if the two strings are exactly the same object.

The .equals() method will check if the two strings have the same value.

回答5:

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

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

所以问题是,如果所有字符串都缓存在系统中,为什么==返回false,而equals返回true?好吧,这是可能的。如果您创建一个新字符串,例如Stringstr=newString("Testing"),则即使在缓存中已经包含具有相同内容的字符串,最终也会在缓存中创建一个新字符串。简而言之,"MyString"==newString("MyString")将始终返回false。

Java还讨论了可以在字符串上使用的intern()函数,使其成为缓存的一部分,因此"MyString"==newString("MyString").intern()将返回true。

注意:==运算符比等于运算符快得多,因为您正在比较两个内存地址,但是您需要确保该代码没有在代码中创建新的String实例。否则,您将遇到错误。

A5:

Strings in Java are immutable. That means whenever you try to change/modify the string you get a new instance. You cannot change the original string. This has been done so that these string instances can be cached. A typical program contains a lot of string references and caching these instances can decrease the memory footprint and increase the performance of the program.

When using == operator for string comparison you are not comparing the contents of the string, but are actually comparing the memory address. If they are both equal it will return true and false otherwise. Whereas equals in string compares the string contents.

So the question is if all the strings are cached in the system, how come == returns false whereas equals return true? Well, this is possible. If you make a new string like String str = new String("Testing") you end up creating a new string in the cache even if the cache already contains a string having the same content. In short "MyString" == new String("MyString") will always return false.

Java also talks about the function intern() that can be used on a string to make it part of the cache so "MyString" == new String("MyString").intern() will return true.

Note: == operator is much faster than equals just because you are comparing two memory addresses, but you need to be sure that the code isn't creating new String instances in the code. Otherwise you will encounter bugs.

回答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()方法对内容进行逐字符比较。

当您为ab调用new时,每个引用都会获得一个新引用,该引用指向字符串表中的"foo" 。引用不同,但是内容相同。

A6:

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

Make sure you understand why. It's because the == comparison only compares references; the equals() method does a character-by-character comparison of the contents.

When you call new for a and b, each one gets a new reference that points to the "foo" in the string table. The references are different, but the content is the same.

回答7:

是的,这很糟糕...

==意味着您的两个字符串引用是完全相同的对象。您可能已经听说过这种情况,因为Java保留了某种文字表(它确实这样做了),但并非总是如此。某些字符串是通过其他方式加载的,它们是由其他字符串等构成的,因此,您绝不能假定两个相同的字符串存储在同一位置。

Equals为您做真正的比较。

A7:

Yea, it's bad...

== means that your two string references are exactly the same object. You may have heard that this is the case because Java keeps sort of a literal table (which it does), but that is not always the case. Some strings are loaded in different ways, constructed from other strings, etc., so you must never assume that two identical strings are stored in the same location.

Equals does the real comparison for you.

回答8:

是的,==对于比较字符串(任何对象,除非您知道它们是规范的)都是不利的。 ==只是比较对象引用。 .equals()测试是否相等。对于字符串,通常它们是相同的,但是正如您所发现的,并不能保证总是如此。

A8:

Yes, == is bad for comparing Strings (any objects really, unless you know they're canonical). == just compares object references. .equals() tests for equality. For Strings, often they'll be the same but as you've discovered, that's not guaranteed always.

回答9:

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

使用==运算符检查(比较)两个对象时,会将地址相等性比较到字符串池中。如果两个String对象具有相同的地址引用,则返回true,否则返回false。但是,如果要比较两个String对象的内容,则必须重写equals方法。

equals实际上是Object类的方法,但是它被重写为String类,并且给出了一个新的定义,该定义将对象的内容进行比较。

Example:
    stringObjectOne.equals(stringObjectTwo);

但是请注意,它尊重String的大小写。如果要区分大小写,则必须使用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

A9:

Java have a String pool under which Java manages the memory allocation for the String objects. See String Pools in Java

When you check (compare) two objects using the == operator it compares the address equality into the string-pool. If the two String objects have the same address references then it returns true, otherwise false. But if you want to compare the contents of two String objects then you must override the equals method.

equals is actually the method of the Object class, but it is Overridden into the String class and a new definition is given which compares the contents of object.

Example:
    stringObjectOne.equals(stringObjectTwo);

But mind it respects the case of String. If you want case insensitive compare then you must go for the equalsIgnoreCase method of the String class.

Let's See:

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

回答10:

我同意zacherates的回答。

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

以zacherates为例:

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

如果您实习的非文字字符串相等为true

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

A10:

I agree with the answer from zacherates.

But what you can do is to call intern() on your non-literal strings.

From zacherates example:

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

If you intern the non-literal String equality is true

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

回答11:

==比较Java中的对象引用,并且String对象也不例外。

要比较对象(包括String)的实际内容,必须使用equals方法

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

A11:

== compares object references in Java, and that is no exception for String objects.

For comparing the actual contents of objects (including String), one must use the equals method.

If a comparison of two String objects using == turns out to be true, that is because the String objects were interned, and the Java Virtual Machine is having multiple references point to the same instance of String. One should not expect that comparing one String object containing the same contents as another String object using == to evaluate as true.

回答12:

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

如果两个对象(不谈论原语)都指向SAME对象实例,则

==返回true。如果两个对象包含相同的数据,则.equals()返回true equals()与Java中的==相比

这可能会对您有所帮助。

A12:

.equals() compares the data in a class (assuming the function is implemented). == compares pointer locations (location of the object in memory).

== returns true if both objects (NOT TALKING ABOUT PRIMITIVES) point to the SAME object instance. .equals() returns true if the two objects contain the same data equals() Versus == in Java

That may help you.

回答13:

==执行引用相等性检查,检查这两个对象(在这种情况下为字符串)是否引用内存中的同一对象。

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

显然,==更快,但是在很多情况下,如果您只是想知道2个String是否包含相同的文本,则(可能)会给出错误的结果。< / p>

绝对建议使用equals()方法。

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

  1. String.equals()的实现首先检查引用是否相等(使用==),如果两个字符串通过引用相同,则无需进一步计算表演!
  2. 如果两个字符串引用不同,则String.equals()接下来将检查字符串的长度。这也是一种快速的操作,因为String类存储字符串的长度,而无需计算字符或代码点。如果长度不同,则不会进一步检查,我们知道它们不能相等。
  3. 只有到了这一步,才可以对两个字符串的内容进行实际比较,这只是一种简略的比较:如果我们发现一个不匹配的字符(在字符串中的相同位置,则不是所有字符都会被比较) 2个字符串),将不再检查其他字符。

总而言之,即使我们可以保证字符串是实习生,使用equals()方法仍然不是人们可能会想到的开销,这绝对是推荐的方法。如果要进行有效的引用检查,则在语言规范和实现可保证相同的枚举值将是同一对象(通过引用)的情况下,使用枚举。

A13:

== performs a reference equality check, whether the 2 objects (strings in this case) refer to the same object in the memory.

The equals() method will check whether the contents or the states of 2 objects are the same.

Obviously == is faster, but will (might) give false results in many cases if you just want to tell if 2 Strings hold the same text.

Definitely the use of equals() method is recommended.

Don't worry about the performance. Some things to encourage using String.equals():

  1. Implementation of String.equals() first checks for reference equality (using ==), and if the 2 strings are the same by reference, no further calculation is performed!
  2. If the 2 string references are not the same, String.equals() will next check the lengths of the strings. This is also a fast operation because the String class stores the length of the string, no need to count the characters or code points. If the lengths differ, no further check is performed, we know they cannot be equal.
  3. Only if we got this far will the contents of the 2 strings be actually compared, and this will be a short-hand comparison: not all the characters will be compared, if we find a mismatching character (at the same position in the 2 strings), no further characters will be checked.

When all is said and done, even if we have guarantee that the strings are interns, using the equals() method is still not that overhead that one might think, definitely the recommended way. If you want efficient reference check, then use enums where it is guaranteed by the language specification and implementation that the same enum value will be the same object (by reference).

回答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字符串

还有第三种比较少见的比较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()

A14:

If you're like me, when I first started using Java, I wanted to use the "==" operator to test whether two String instances were equal, but for better or worse, that's not the correct way to do it in Java.

In this tutorial I'll demonstrate several different ways to correctly compare Java strings, starting with the approach I use most of the time. At the end of this Java String comparison tutorial I'll also discuss why the "==" operator doesn't work when comparing Java strings.

Option 1: Java String comparison with the equals method Most of the time (maybe 95% of the time) I compare strings with the equals method of the Java String class, like this:

if (string1.equals(string2))

This String equals method looks at the two Java strings, and if they contain the exact same string of characters, they are considered equal.

Taking a look at a quick String comparison example with the equals method, if the following test were run, the two strings would not be considered equal because the characters are not the exactly the same (the case of the characters is different):

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.")
}

But, when the two strings contain the exact same string of characters, the equals method will return true, as in this example:

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.")
}

Option 2: String comparison with the equalsIgnoreCase method

In some string comparison tests you'll want to ignore whether the strings are uppercase or lowercase. When you want to test your strings for equality in this case-insensitive manner, use the equalsIgnoreCase method of the String class, like this:

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.")
 }

Option 3: Java String comparison with the compareTo method

There is also a third, less common way to compare Java strings, and that's with the String class compareTo method. If the two strings are exactly the same, the compareTo method will return a value of 0 (zero). Here's a quick example of what this String comparison approach looks like:

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.")
}

While I'm writing about this concept of equality in Java, it's important to note that the Java language includes an equals method in the base Java Object class. Whenever you're creating your own objects and you want to provide a means to see if two instances of your object are "equal", you should override (and implement) this equals method in your class (in the same way the Java language provides this equality/comparison behavior in the String equals method).

You may want to have a look at this ==, .equals(), compareTo(), and compare()

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

A15:

Function:

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

Test:

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

回答16:

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

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

  • 案例1

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

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

  • 案例2

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

    原因:如果您使用new关键字创建String对象,在堆上为其分配了空间。

A16:

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

Note that the .equals() method belongs to class Object (super class of all classes). You need to override it as per you class requirement, but for String it is already implemented, and it checks whether two strings have the same value or not.

  • Case 1

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

    Reason: String literals created without null are stored in the String pool in the permgen area of heap. So both s1 and s2 point to same object in the pool.

  • Case 2

    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.

回答17:

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

A17:

== compares the reference value of objects whereas the equals() method present in the java.lang.String class compares the contents of the String object (to another object).

回答18:

我认为,当您定义String时,您会定义一个对象。因此,您需要使用.equals()。使用原始数据类型时,使用==,但使用String(和任何对象),则必须使用.equals()

A18:

I think that when you define a String you define an object. So you need to use .equals(). When you use primitive data types you use == but with String (and any object) you must use .equals().

回答19:

如果java.lang.Object类中存在equals()方法,则应检查对象状态的等效性!也就是说,对象的内容。而==运算符应检查实际对象实例是否相同。

示例

考虑两个不同的参考变量,str1str2

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作为输出,因为str1str2都指向两个不同的对象,即使它们共享相同的字符串内容。因为newString()每次都会创建一个新对象。

A19:

If the equals() method is present in the java.lang.Object class, and it is expected to check for the equivalence of the state of objects! That means, the contents of the objects. Whereas the == operator is expected to check the actual object instances are same or not.

Example

Consider two different reference variables, str1 and str2:

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

If you use the equals()

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

You will get the output as TRUE if you use ==.

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

Now you will get the FALSE as output, because both str1 and str2 are pointing to two different objects even though both of them share the same string content. It is because of new String() a new object is created every time.

回答20:

运算符 == 始终用于对象引用比较,而String类 .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)

A20:

Operator == is always meant for object reference comparison, whereas the String class .equals() method is overridden for content comparison:

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)

回答21:

由于对象包含一个返回布尔值的方法.equals(),因此确保所有对象都具有.equals()方法。如果需要进一步的定义定义,则重写此方法是子类的工作。如果没有它(即使用==),则仅检查两个对象之间的内存地址是否相等。字符串将覆盖此.equals()方法,并且它不使用内存地址,而是返回字符级别的字符串比较以确保相等。

一个重要的注意事项是,字符串存储在一个总池中,因此一旦创建了字符串,便将其永久存储在同一地址的程序中。字符串不变,它们是不可变的。这就是为什么如果您有大量的字符串处理需要使用常规的字符串连接是一个不好的主意的原因。相反,您将使用提供的StringBuilder类。请记住,指向此字符串的指针可以更改,并且如果您有兴趣查看两个指针是否相同,则可以使用==。字符串本身没有。

A21:

All objects are guaranteed to have a .equals() method since Object contains a method, .equals(), that returns a boolean. It is the subclass' job to override this method if a further defining definition is required. Without it (i.e. using ==) only memory addresses are checked between two objects for equality. String overrides this .equals() method and instead of using the memory address it returns the comparison of strings at the character level for equality.

A key note is that strings are stored in one lump pool so once a string is created it is forever stored in a program at the same address. Strings do not change, they are immutable. This is why it is a bad idea to use regular string concatenation if you have a serious of amount of string processing to do. Instead you would use the StringBuilder classes provided. Remember the pointers to this string can change and if you were interested to see if two pointers were the same == would be a fine way to go. Strings themselves do not.

回答22:

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

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

A22:

You can also use the compareTo() method to compare two Strings. If the compareTo result is 0, then the two strings are equal, otherwise the strings being compared are not equal.

The == compares the references and does not compare the actual strings. If you did create every string using new String(somestring).intern() then you can use the == operator to compare two strings, otherwise equals() or compareTo methods can only be used.

回答23:

在Java中,当使用" ==" 运算符比较两个对象时,它将检查对象是否指向内存中的同一位置。换句话说,它检查两个对象名称是否基本上是对相同内存位置的引用。

Java String类实际上覆盖了Object类中默认的equals()实现,并且覆盖了该方法,以便它仅检查字符串的值,而不检查它们在内存中的位置。这意味着如果调用equals()方法比较2个String对象,则只要实际字符序列相等,两个对象就被视为相等。

==运算符检查两个字符串是否完全相同。

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

A23:

In Java, when the “==” operator is used to compare 2 objects, it checks to see if the objects refer to the same place in memory. In other words, it checks to see if the 2 object names are basically references to the same memory location.

The Java String class actually overrides the default equals() implementation in the Object class – and it overrides the method so that it checks only the values of the strings, not their locations in memory. This means that if you call the equals() method to compare 2 String objects, then as long as the actual sequence of characters is equal, both objects are considered equal.

The == operator checks if the two strings are exactly the same object.

The .equals() method check if the two strings have the same value.

回到顶部