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?

itemprop="text">

class="normal">Answer

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

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

href="http://docs.oracle.com/javase/7/docs/api/java/util/Objects.html#equals(java.lang.Object,%20java.lang.Object)"
rel="noreferrer">Objects.equals() checks for null
before calling .equals() so you don't have to (available as of
JDK7, also available in href="https://github.com/google/guava/wiki/CommonObjectUtilitiesExplained#equals"
rel="noreferrer">Guava).

href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#contentEquals-java.lang.CharSequence-"
rel="noreferrer">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 href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#intern--"
rel="noreferrer">interned strings, you can use
==.

From href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.5"
rel="noreferrer">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 ( href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.28"
rel="noreferrer">§15.28) - are "interned" so as to share unique instances,
using the method
String.intern.

Similar
examples can also be found in href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#d5e1634"
rel="noreferrer">JLS 3.10.5-1.