String is not working as i supposed it to work

[Sumit Khurana]

Hi friends,

public class Practice {
	public static void main(String[] args) {
		String h1="hello";
		String h2="hello";
		System.out.println(h1==h2);
		h1=h1.concat("world");
		h2=h2.concat("world");
		System.out.println(h1==h2);                                //line1
		String h3="helloworld";
		System.out.println(h3==h2+" ");                          //line2
		System.out.println(h3==h1);                                //line3
		h3.toString();
	}
}
true
false
false
false

I read in sierra bate book that to make java more memory efficient,String uses String constant pool that means it will create a single object for two different
references h1 and h2 . so,h1==h2 should return true. but unexpectedly jvm gives false.......why???

I am also confused about the output of line2 and line3 also.so,please explain me this also.
Thanks for reading my post,

regards
Sumit

[Piyush Joshi]

Its because concat() method creates a new String object by calling one of String class constructors, and you know that if a String is created by calling a constructor then
its not taken from the String literal pool. This explains the output of the above program.

See the source code of String class, and check the concat() method.

[Scotty Mitchell]

The string objects h1 = h1.concat("world"), and h2 = h2.concat("world") are not pulled from the literal pool as they create new string objects. Thats why you have an output as false. Of course, all these string objects are on the heap, just the reference to the literal pool is not there.

[John Stark]

But even if we don't use concat() but the + operator:

 h1=h1 + "world";   
 h2=h2 + "world";   

The result is still
true
false
false
false

But if we replace

h1=h1 + "world";   
h2=h2 + "world";   

by

h1="hello" + "world";   
h2="hello" + "world";  

then the result is:
true
true
false
true
(replacing

 System.out.println(h3==h2+" ");                          //line2   

by

System.out.println(h3==h2);                          //line2   

gives true true true true).

I think as in

 h1=h1 + "world";  

h1 is calculated at runtime a new string is generated.
In

h1="hello" + "world";  

h1 is calculated by using a string constant expression. In this case using + means the constant from the pool is taken, using concat() means a new string is generated.

John

[Piyush Joshi]

We need to understand the difference between the concat() function and String concatenation operator +.

1. concat() function:

concat() function uses new String(int offset, int count, char value[]) constructor to create the new concatenated String. (source : java.lang.String source code)

so new String will not be pulled from the String literal pool.

See this:

   String s1="helloworld";
   String s2 = "hello".concat("world");
   System.out.println(s1 == s2);
   output is false

2. String concatenation operator +

there are two cases here:

2.1. Both the operands are String literals:

If both the operands are String literals then the resulting String object is resolved at compile-time.

From Java Language Specification:

   "This is a " +                          // actually a string-valued constant expression,
   "two-line string"               //              formed from two string literals

Therefore:

		String s1 = "helloworld";
		String s2 = "hello" + "world"; //Resolved at compile-time as "helloworld"
		System.out.println(s1 == s2);
will print true

2.2. one or both the operands are reference variables:

If one or both of the operands are reference variables (other than String <<edit: one reference variable must be of String type>>) then at run-time String Conversion takes place.

If one or both of the operands are references of String type, then String conversion is not required for that variable.

Thereafter: "String concatenation is implemented through the StringBuilder(or StringBuffer) class and its append method". (Source Javadocs for String class )

So in this case a new String object is created instead of pulled out from the pool.

therefore:

		String s1 = "helloworld";
		String s2 = "hello";
		String s3 = s2 + "world";
		String s4 = s2 + "world";
		System.out.println(s1 == s3); //false
		System.out.println(s3 == s4); //false

[John Stark]

Good point.

[Sam Hazim]

Also if you make s2 compile time constant with the final keyword:

		String s1 = "helloworld";
		final String s2 = "hello";
		String s3 = s2 + "world";
		String s4 = s2 + "world";
		System.out.println(s1 == s3); //true
		System.out.println(s3 == s4); //true

It works as a String literal compile time constant, and is considered identical to:

String s3 = "hello" + "world";
String s4 = "hello" + "world";

so the results again show true.