String Comparison in Java…? [duplicate]

Answer 1

Don't use == to compare strings, it tests reference equality (do two names refer to the same object). Try s1.equals(s2);, which actually tests the elements for equality.

Answer 2

String one = "Arsalan";
String two = "Arsalan";

1. one == two

   // Returns true because in memory both Strings are pointing to the SAME object

2. one.equals(two)

   // Will ALWAYS return true because the VALUES of the Strings are the same (would not matter if the objects were referenced differently).

Answer 3

If "Arsalan" is not found in the pool of Strings, a "Arsalan" string will be created and s1 will refer it. Since "Arsalan" string already exists in the pool of Strings s2 will refer to the same Object as s1. Because the new keyword is used for s3, Java will create a new String object in normal (nonpool) memory, and s3 will refer to it. This is the reason why s1 and s3 don't refer to the same object.

Answer 4

The reason is string interning. It's complicated. The compiler is "smart" enough to use the same exact object for s1 and s2, even though you might think they are different. But s3, which uses new String("Arsalan"), doesn't intern.

Some guidelines:

1. You should almost always use equals(), not ==, to compare strings
2. You should almost never use String s = new String("foo"). Instead, use String s = "foo".

Answer 5

This has to do with the fact that you cannot compare strings with == as well as compiler optimizations.

== in Java only compares if the two sides refer to the exact same instance of the same object. It does not compare the content. To compare the actual content of the strings, you need to use s1.equals(s2).

Now the reason why s1 == s2 is true and s1 == s3 is false is because the JVM decided to optimize the code so that s1 and s2 are the same object. (It's called, "String Pooling.")

---

Per 3.10.5: Pooling of string literals is actually mandated by the standard.

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.

Answer 6

Don't use ==, use s1.equals(s2) or s1.equals(s3) instead.