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?

12 upvote
  flag
Also its good to know that, if you are overridding .equals () method, make sure you are overridding .hashcode () method, otherwise you will end up with violating equivalence relation b/w equals and hashcode. For more info refer java doc. – Nageswaran
upvote
  flag
Leaving a link to my explanation on why == works the way it does on Objects: //allinonescript.com/a/19966154/2284641 – Johannes H.
upvote
  flag
== will work some of the time, as java has a String pool, where it tries to reuse memory references of commonly used strings. But == compares that objects are equal, not the values... so .equals() is the proper use you want to use. – James Oravec
upvote
  flag
Never use == to test whether Strings are the same, unless you enjoy tracking down subtle errors and studying the intricacies of the Java String interning process. "12"=="1"+2 is false (probably) – Flight Odyssey

23 Answers 11

up vote 4582 down vote accepted

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

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

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

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

You almost always want to useObjects.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.

299 upvote
  flag
I guess in Java you should say "references" instead of "pointers". – Henrik Paul
2 upvote
  flag
If you can do things this way, what is the method compareTo useful for? – xocasdashdash
27 upvote
  flag
@Xokas11: compareTo is generally used for sorting. – Michael Myers
3 upvote
  flag
equals, compareTo and hashCode are all directly related with contracts that must be fulfilled. Only equals and hashCode are polymorphic over all objects. compareTo is from Comparable. – user166390
upvote
  flag
I always think it's a lack of java, if using C++, override operator == method of String class should achieve this – LiuYan 刘研
upvote
  flag
+1 for "test" == "!test".substring(1) ==> false line. I could have marked it as true only... But as you said, compiler can not determine the results at compile time so these 2 will reference two difference memory locations... I would not have detected it.. :-) – Vishal
107 upvote
  flag
Just a note equals() exactly Compares this String to another String, BUT equalsIgnoreCase() Compares this String to another String, ignoring case considerations – Yajli Maclo
2 upvote
  flag
Always use equalsIgnoreCase() unless you have a good reason. There is very little performance tradeoff (if any at all) and the safety if provides your program is much higher. – SnakeDoc
3 upvote
  flag
@LiuYan刘研 I don't think its a lacking feature in Java, using == for multiple things is confusing enough for newbies! A String is an object, and therefore you must call a function on that object to do things with it (compare value in this situation). It would be as if we expected ` 4 == 4 ` to compare the pointer in memory. Different data types must be treated differently. Strings are objects, use them as such! – SnakeDoc
upvote
  flag
@SnakeDoc the "confusing" problem is caused by another lack/feature of java: java does not support pointer. == is straighter than .equals(), i will prefer using == to compare objects if java support overriding operator == : "bool MyString::operator == (const char *sAnotherString) {return strcmp(this.m_String, sAnotherString);}". 2 other lack of java (compared to C++): (a) does not support structure data. (b) does not support unsigned integers. – LiuYan 刘研
6 upvote
  flag
Java does use pointers, but they are abstracted away to Object References, it was a design decision and provides a whole level of program safety that you cannot always guarantee with pointers, even with a high level of understanding of pointers and pointer arithmetic. Structured Data (Struct) I think is coming in Java8 or may have been pushed back to Java9. Anyways, java is java, with it's lumps and it's pearls. :/ – SnakeDoc
4 upvote
  flag
Also note that .equals() does generally the same as ==, String is one of few exceptions, if you will want to compare your own classes you will need to redefine (override) the .equals() method. – kajacx
upvote
  flag
@kajacx good point +1, I don't think anyone mentioned that yet. If you have a custom object, .edquals() doesn't know what to compare the value of inside your object, so override it and implement your own .equals(). – SnakeDoc
upvote
  flag
@SimonNickerson does == compare objects in all objected oriented languages? – Bbvarghe
2 upvote
  flag
@Bbvarghe No. In C# for instance it's overloaded on strings to do value equality... likewise for Python (which has the is operator to do reference equality). – Aaron Maenpaa
34 upvote
  flag
@SnakeDoc — We can say the opposite. Always use equals() unless you have a good reason. What you call safety is entirely context-dependent. For instance, when comparing passwords to determine whether the user has entered the right password, it is unsafe to ignore case differences. – Nicolas Barbulesco
3 upvote
  flag
@NicolasBarbulesco I hope you aren't checking passwords in plain text! Passwords should at the very least be stored as a char[] since String is mutable. (see //allinonescript.com/questions/8881291/…) -- Anyways, it is context dependent of course. My general rule remains: use .equalsIgnoreCase() unless you have a good reason (being case matters or such). Far too many times i've been burned by a user typing in something like SOMESTRING instead of and expected somestring and then report program is busted (caps lock on or something). – SnakeDoc
upvote
  flag
Just to clarify for everyone, .equals() is necessary in Java as it's comparing the Value of two objects, not the object references. == would compare the references (think pointers for simplicity). You can use == to compare two objects, but it won't give you the expected result if the references aren't the same. It may work in some cases, such as with Strings, but isn't reliable. The JVM does some magic when you create a new string with the same value as another in memory, it basically just creates a new reference to the same memory location in some cases. Just use .equals()... – SnakeDoc
11 upvote
  flag
@SnakeDoc — ?? String is not mutable. – Nicolas Barbulesco
upvote
  flag
@SnakeDoc — These are security considerations and, as such, they all depend on the context. Not all applications use perfect security — which does not exist, by the way. Passwords are just an example. And if, instead of passwords, you prefer testing equality on hashes of passwords, same situation : test considering case differences, for security. – Nicolas Barbulesco
1 upvote
  flag
@NicolasBarbulesco I don't see where I said they were mutable. Anyways, I find using .equalsIgnoreCase() happens far more often in my work as I'm often dealing with a file (config file) or direct input that is given by users. If you are expecting a hash, then that would be the "good reason" to use .equals(). Otherwise, it would be silly to expect a string of some_value and have your prog break because user had caps lock on (doh!). It's context sensitive, but again, I find I end up using .equalsIgnoreCase() far more often, usually to protect runtime from bad users... – SnakeDoc
1 upvote
  flag
Another reason why the equality operator does not do what any average human would intuitively think it does is because java does not support operator overloading. – Marquez
1 upvote
  flag
Small extra note: every time you use "myString" in java code, you are actually creating a private static String with an automatically generated name. Using "myString" twice in the same class should yield the same reference, as the compiler uses the same static class field. It's just syntactic sugar, similar to how an anonymous iterator is created for the construction for(Object o: collection) {} – parasietje
upvote
  flag
== is usefull for primitives than you should use instead of Objects when you can. – David Doumèche
1 upvote
  flag
@Marquez - On the other hand, operator overloading (as in C++) is why the equality operator sometimes does not do what any average human would intuitively think it does. Concerning the operators in Java, at least you can just look at code and WYSIWYG. – Ted Hopp
1 upvote
  flag
Regarding concatenation of literals, will this happen at compile-time if String objects created from literals are unconditionally concatenated in a later line? – hexafraction
31 upvote
  flag
One minor edit, == is not "much cheaper" than .equals, because the first statement in String.equals reads: if (this == anObject) { return true; }. – Torque
1 upvote
  flag
@HenrikPaul Yes, thats the Java terminology. But references in Java is more like pointers in C++ terminology, since a reference in C++ behaves like the object it refers to semantically. – user877329
upvote
  flag
This article has good explanation codenuggets.com/2014/06/24/java-equals-method – Jeff
1 upvote
  flag
You have to be kidding that == tests only for reference and not value. – JohnMerlino
upvote
  flag
If you want to compare/check empty strings, then you can use isEmpty() [ from java 1.6]. – Sudip7
1 upvote
  flag
== also only works for primitive data types, like an int. Strings work differently than primitive types – Flotolk
1 upvote
  flag
String is an object, == is true when two objects refer to same memory location,equals() is true when two objects have same content stored inside. e.g.Employee object then we can override equals to specify equality for employees (emp-id or name or both), but if we use == then again it means reference equality. If we want our objects (or strings) to be comparable then implement Comparable interface which has method compareTo(). We can then define how the employee objects must be compared (e.g. using emp-id or name or both). This is useful when you want to sort employees (or strings). – i_am_zero
3 upvote
  flag
@Torque: your conclusion might be incorrect, because most comparisons (in most programs) will be unequal, hence will fail that if test, and have to continue to additional logic. I haven't looked at the implementation, but I presume the next test is a length test. Which usually will be sufficient to distinguish two strings, so the extra cost is usually not huge, but still definitely more than a single comparison. – ToolmakerSteve
upvote
  flag
@ToolmakerSteve but that's irrelevant, if it fails the reference comparison then using it in the first place wouldn't even be valid (for comparing string value), let alone a more efficient operation. – Rogue
1 upvote
  flag
When you are comparing a known constant with a variable that "potentially" has string, start with the constant as the variable could hold null. That way you don't have to check for nulls. Some thing like this : "SOME_CONSTANT".equals(someVariable) – Rose
upvote
  flag
@Rogue - You misunderstand the point raised by Torque, and my response to it. Obviously, if the functionality one wants is equals, then one must use equals. Torque made an incorrect assertion about performance, and I was pointing that out. [I only bothered to point this out, because so many people up-voted Torque's comment, meaning they failed to recognize the incorrectness of his logic.] – ToolmakerSteve
upvote
  flag
"In the rare situation where you know you're dealing with interned strings, you can use ==." Generally you intern so you can use ==. Once you intern you should (as opposed to can) use == – Glenn Teitelbaum
upvote
  flag
Since java has no pointer it is recommended to use he word references instead, and will strongly discourage to use the word pointer....!! – ΦXocę 웃 Пepeúpa ツ
upvote
  flag
what an easy question to take thousands of upvotes :) – okarakose
upvote
  flag
s1.equals(s2) has the potential advantage over Objects.equals(s1, s2) that it tells the reader that I know s1 is not null. And that I will discover if I was wrong about it. Whether it is really an advantage depends on the situation. – Ole V.V.
upvote
  flag
I see where you're coming from, but that's starting to sound like an implicit not null assertion at which point I'd encourage requireNonNull rather than overloading the equals check. – Aaron Maenpaa
upvote
  flag
One more thing to add to make this answer even more awesome: String string1 = "qwe"; String string2 = "qwe"; System.out.println(string1 == string2); // true This is comparison by reference but still it prints true because Java optimises it so 'a' and 'b' refer to the same object. But do not be confused, for all other data types (except String) this will be false. This is a very often asked question during interviews. – Maksim
upvote
  flag
@Maksim That's covered by the "test" == "test" => true example and the comment about interning. – Aaron Maenpaa
1 upvote
  flag
@AaronMaenpaa, totally agree, just syntactically a bit different. Somebody can be tricked. – Maksim
upvote
  flag
apache provides a StringUtils class which has a more useful method for handling the equation and it checks whether it's null or not. – A.Shaheri
upvote
  flag
This was so frustrating to me with java. Thanks posting an answer! – Panos
upvote
  flag
why new String("test") == new String("test") this gives false as result ? – Dinesh Pathak DK
upvote
  flag
new String("test") == new String("test") This gives false as result because two objects are created that have two different references ans == is used to compare references. – Karan
upvote
  flag
Another good example: String s1 = "123" + "456"; String s3 = new String("123456"); s3 == s1 // false String s4 = "123456"; s4 == s1 // true – Jarkid

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.

== 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.

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.

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

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 upvote
  flag
Generally I strongly recommend apache commons library: commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/‌​…, java.lang.String) – Marcin Erbel
upvote
  flag
You can also use .compareTo() method if you want to evaluate order of strings. – MarekM
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.

== 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
nullString1 == nullString2;

// Throws an Exception
nullString1.equals(nullString2);
72 upvote
  flag
Sometimes it looks as if "==" compares values, -- == do always compare values! (It's just that certain values are references!) – aioobe
2 upvote
  flag
Alas, there is no static method for isNullOrEmpty(), and no custom overloading of operators, which makes this part of Java clunkier than in C# or Python. And since Java doesn't have extension methods, you can't write your own utility to extend java.lang.String. Right? Any thoughts on subclassing String, adding that static utility method, and then always using MyString instead? A static method with two parameters for doing null-safe comparisons would be nice to have in that subclass too. – Jon Coombs
5 upvote
  flag
Groovy makes this a little easier with the safe navigation operator (groovy.codehaus.org/…), ?.. That would convert nullString1?.equals(nullString2); into an entirely null statement. However, it doesn't help if you have validString?.equals(nullString); -- that still throws an exception. – Charles Wood
2 upvote
  flag
Short methods to compare nullable strings in java: //allinonescript.com/questions/11271554/… – Vadzim
3 upvote
  flag
@JonCoombs Java supports the subclassing and creating own method. However few classes are marked final due to certain reasons, String is one of them so we cannot extend. We can create other class and make utility class there which take two string as arguments and implement our logic there. Also for null check some other libraries like spring and apache he good collections of methods, one can use that. – Panther
1 upvote
  flag
@CharlesWood validString.equals(null) should return false, not throw an exception. (It is specified this way for object.equals, and String.equals does follow this.) – Paŭlo Ebermann
upvote
  flag
== compares the reference of the object,and .equals() method compares the string content i.e., String.If you wish to compare the string use .equals() method.It is quite useful – smith
upvote
  flag
You Saved my day. I was calling .equals from a possible null value and sometime was erroring out. +1 – DoArNa

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 
5 upvote
  flag
This is generally not a good idea. Interning is relatively expensive and can (paradoxically) >>increase<< your JVMs memory footprint and increase GC costs. In most cases, these outweigh the performance benefits from using == for string comparison. – Stephen C

String 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 that 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.

== 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).

13 upvote
  flag
not to be nit picky, but the equals() method for String is actually in the String class, not in Object. The default equals() in Object would not compare that the contents are the same, and in fact just returns true when the reference is the same. – Jacob Schoen

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.

2 upvote
  flag
"once a string is created it is forever stored in a program at the same address" - This is flat-out wrong. Only compile-time constant string expressions (possibly involving final String variables) and strings that your program explicitly interns are stored in what you call a "lump pool". All other String objects are subject to garbage collection once there are no more live references to them, just like any other type of object. Also, while immutability is required for the whole interning mechanism to work, it's otherwise irrelevant to this. – Ted Hopp
upvote
  flag
String comparison is done either through equals or equalsIgnoreCase method which actually compares the contents of the string. But == sign just check the reference values. For string literals from string pool will work fine for this case. String s1 = new String("a"); String s2 = new String("a"); in this case s1==s2 is false, but s1.equals(s2) is true. – Shailendra Singh

== compares Object reference.

.equals() compares String value.

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

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

This is a because when you create any String literal, the JVM first searches for that literal in 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 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 in heap that reference will be given to b, so b will be given reference in heap not in String Pool.
Now a is pointing to String in String pool while b is pointing to String in heap, because of that we are getting

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

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

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

While .equals() always compares 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.

Hope this will help.

2 upvote
  flag
.equals() compares the two instances however equals is implemented to compare them. That might or might not be comparing the output of toString. – Jacob
2 upvote
  flag
@Jacob Object class .equals() method compares the instances(references/Address) where as String class .equals() methods is overridden to compare content(chars) – Satyadev
upvote
  flag
Good pointing out String pool versus Java heap differences as they are certainly not the same. In the string pool Java tries to "cache" String objects to save memory footprint as String is known for being immutable (I hope, I say it correctly here). Also check //allinonescript.com/questions/3052442/… – Roland

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().

upvote
  flag
Also note that == doesn't work for char[] – Khaled.K
6 upvote
  flag
"char[]" isn't a primitive data type! It's an array of "char". And arrays aren't primitive data types theirselves. – Christian

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);
4 upvote
  flag
How does this differ from other answers? and why do it the way you suggest – Mark
1 upvote
  flag
@Mark The question on difference between == and equals was already answered by other solutions, I just offered a different way to compare strings in a loose way – Khaled.K

== 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).

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

What happens is when you check(compare) two objects using == operator it compares the address equality into the string-pool. If two String objects having 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 equals method.

equals is actually the method of Object class but is Overridden into the String class and 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 equalsIgnoreCase method of the String class.

Lets 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
6 upvote
  flag
I see that this is a late answer to big question. May I ask what it provides that isn't already mentioned in the existing answers? – Mysticial
6 upvote
  flag
@Mysticial he has added equalsIgnoreCase which might be informative for the fresher. – AmitG

always == operator meant for object reference comparison,where as 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)

You can also use 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.

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

4 upvote
  flag
for string literals Like String string1 = "foo bar"; String string2 = "foo bar"; you can directly use == operator to test content equality – JAVA

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

Note that .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 string have same value or not.

  • Case 1

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

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

  • Case 2

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

    Reason: If you create String object using new keyword separate space is allocated to it on heap.

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() everytime a new object is created.

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.

upvote
  flag
unless one of them is null, since s.equals(s2) will crash if s is null, causing the comparison to fail. Of course, this doesn't really contradict the answer; it's just a caveat. – Jon Coombs
upvote
  flag
No, it won't crash, it will throw a NullPointerException, causing the comparison to not take place. – Bludzee

Not the answer you're looking for? Browse other questions tagged or ask your own question.