My Question is what's the use of creating string object in string pool as well as on Heap when we declare String as String a = new String("abc"); What is the advantage ?
And why not we create string in heap when we create string as String a = "abc".
The java language was designed like that. Anything you use between double quotes is a compile time constant and goes into the String pool. So, in your case :
String a = new String("abc");
"abc" will be resolved as a compile time constant and thus will be added to the String constants pool for the current JVM.
Next, the value of a will be resolved at run-time and will be added to the heap during run-time.
abcs one in heap and another on String constants pool.. in this case, there is no advantage.. actually you are creating additional objects for the GC to work on.. If you had done char[] c = {'a','b','c'}; String s = new String(c); then abc will not be in the String constants pool. SO, you will be good to go.
First, I recommend that you not use new String("abc") because it behaves as you described. Second, when you use new you should expect a new Object instance will be created and it is.
First of all let me clear you when you write
String str=new String("abc");
new object is created irrespective of content in the variable. Secondly when you create String using
String str="abc";
at this time this content will be searched in the pool. If any string matching same content as that of new one then only reference will be created on stack but it will point to older one heap location. Got it?
I believe string object creation by using new operator, don't create object in string constant pool due to the below 2 reason.
Intern() method is used to add the string object to string constant pool. If string object is present in string constant pool, then there is no use of intern() method.
String literal = "abc"; String object = new String("abc"); System.out.println("result = " + literal == object); // false
If string object is present in string constant pool at compile time, then the result should be true.
Please correct me if I am wrong.
When you use a new keyword the string doesnot go to string pool. For example when you do String c = new String("David"); String d = new String("David"); Here you will have two reference variables c and d both pointing to two different objects having same value "David". But when you do String a ="Rahul"; here "Rahul" lives in the string pool. Now again if you do String b= "Rahul"; first Java will search if there is "Rahul" living in the string pool, and there is. So now reference variable b will point to the same "Rahul" living in the string pool. So here you have reference variable "a" and "b" both pointing to the same "Rahul" in the string pool. But since strings are immutable changing "a" won't have any impact on "b" or vice versa. So you can use any one you like based on your need and requirement
newdoes not create a string pool entry. The literal does that before you even callnew. If you donew String(a), nothing is created in the string pool.Integer x = 123;also does not create an object in the heap (it takes it from a pool, same as with Strings).