java String comparison in concat

Question

package data;
public class A {

    String s = "maew";
        String s2 = s + "class";
        String s1 = "maewclass";
        System.out.println(s2 == s1);
    }
}

but both will be in string constant pool and if with same content an object is created one more reference will not get created. s2 and s1 should point to same object in string constant pool.so answer should be true why its giving false

Answer 1

String constant pool is an internal java feature which you should never rely on. For instance the following code will produce "true"

String s1 = "Hello";
String s2 = "Hello";
boolean result = s1 == s2;

But the following code will produce "false":

String s1 = "Hello";
String s2 = new String("Hello");
boolean result = s1 == s2;

String constant pool behavior may change from one java version to another since it is an internal optimization feature. It shouldn't be relied on. In your case, I suspect because you used String s2 = s + "class"; it did create a new instance.

In any case any String comparison MUST be done with method equals() of class String

Answer 2

I haven't look at the documentation, just did my own testing and what i believe that the reason you are getting "false" is because your S2 was a result of concatenation of an object (s) and the other string.

If you run this code

//          String s = "maew";
        String s2 = "maew" + "class";
        String s1 = "maewclass";
        System.out.println(s2 == s1);

The it is indeed returning true. So I believe, that java is not keeping result of Object.toString + "string" in the stringpool.

Answer 3

String grima = "grima";
String gri = "grima";
if (grima == gri)
    System.out.println("grima == gri"); // The message is displayed

Both variables refer to same "grima" in string constant pool.

String pndey = "pandey";
String pan = "pande";
pan = pan + "y"; // The value for pan will be resolved during runtime.
if (pndey == pan)
    System.out.println("pndey == pan"); // The 2 references are different

Now in the second case if I change

pan = pan + "y"; to pan="pande" +"y", then "pndey == pan" message will be displayed, because the compiler resolves the literal during compilation time.

Now as per Java docs on string:

• Literal strings within the same class (§8 (Classes)) in the same package (§7 (Packages)) represent references to the same String object (§4.3.1).
• Literal strings within different classes in the same package represent references to the same String object.
• Literal strings within different classes in different packages likewise represent references to the same String object.
• Strings computed by constant expressions (§15.28) are computed at compile time and then treated as if they were literals.
• Strings computed by concatenation at run time are newly created and therefore distinct.
• The result of explicitly interning a computed string is the same string as any pre-existing literal string with the same contents.

You read more here: https://codingninjaonline.com/2017/09/18/stringstring-constant-pool-in-java/

Answer 4

you need to use s2.equals(s1) instead of == please go through link provided for more here

Answer 5

Update :

When we create object its reference is placed in the string constant pool memory.

So in your case when program is run...

JVM finds the variable s2 which refers to s + "class" in which s is also referencing maew and will be placed in the string constant pool memory.Then it finds another variable s1 which is referring maewclass. JVM finds two different string references so both the variables s2 and s1 will not be refer for same string (say..maewclass).

At point when class is loaded if two same values are passed it is will refer to previous object rather creating the new one...

• String objects with same values will always refer to the same String object.

  String s = "a";
  String s2 = "a";
  
  System.out.println(s.equals(s2));   //-------return true
  System.out.println(s == s2);        //-------return true 
  
  
                            _____
  s   ------------------>  |     |
                           | "a" |
  s2  ------------------>  |_____|    
                              ^
                              |
                   ___________|____________
                   |        Heap          | 
                   | String Constant Pool |
                   |______________________|
  

• String objects created using new operator will be different from literals

  String s = "a";
  String s2 = new String("a");
  System.out.println(s.equals(s2));      //-------return true
  System.out.println(s == s2);           //-------return false