Is String pool is carried out when two String having same literal ( java)

Question

I have refernced the following links

http://www.xyzws.com/Javafaq/what-is-string-literal-pool/3

Still have some doubts please help me

            `public class StrPool
             { 
               public static void main(String[] args)
               { 
                String abc="hello";
                String abcd="hello";
                System.out.println(abc==abcd);
               }
             }
             `

In the above example OP : true

So we can confirm that both object are refered from same String object Am clear about that.

    `String abc="hello World";
     String abcd="hello";
     System.out.println(abc==abcd);`

This gives output : false

So String pool is carried out when two String object having same literal???

If So two object of String will created in String pool??

Why second output is false ???

I READ THAT String class is immutable

abc and abcd have different object reference then Immutable means

" First String object will created by JVM and give two reference to abc and abcd " Am i right???

Thank you very much........

Harmeet Singh · Accepted Answer · 2012-08-01T09:39:32.567

1

The second output is false as both the string abc and abcd having different content(text)

yes as you said String class is immutable ie their content does not gets changed, if in case you change the string text then JVM will allocate a new space instead of altering it.

Now when you create a new String reference with some text at that time JVM will check if that text already exists in pool and if then will refer your string to that text or else will create new text within pool

edited Aug 01 '12 at 09:39

answered Aug 01 '12 at 09:29

Harmeet Singh

2,555
18
21

So String pool mechanism is then based on the literals. If two object having different literals Jvm allocates new space for each two if i give abc="new hello" will this Literal overrite the exsisting one. – Amith Aug 01 '12 at 09:46
@Amith yes exactly.. abc="new hello" new space will allocate for "new hello" and will pass to `abc` – Harmeet Singh Aug 01 '12 at 09:47
Imutable means it never change so how it could possible – Amith Aug 01 '12 at 09:50
@Amith JVM does not alter within abc space, it allocates abc new space – Harmeet Singh Aug 01 '12 at 09:52
so when gc carried out previous abc="hello"; will removed there is no reference in abc="hello"; is there any method to pick previous value `abc="hello", abc="new hello"` – Amith Aug 01 '12 at 09:55
Will Heap hold Two String object having the same name ?? – Amith Aug 01 '12 at 09:58
@Amith store that value in a temp object before altering – Harmeet Singh Aug 01 '12 at 09:58

Saurabh · Answer 2 · 2012-08-01T09:51:18.237

Consider first code,

While executing statement String abc="hello", JVM will do following things 1. create a reference abc of type String. 2. check if literal "hello" is available in string pool if available, it will assign its reference value to abc, else it will create string literal "hello", assign its reference to abc and add it to String pool.

Same step will be repeated for String abcd="hello". Here, as "hello" is already available in string pool, same will be referred by abcd.

These same steps will be followed in second code block as well, (in fact everytime you create string object with such statement) just that the literal "hello world" and "hello" will be created differently and assigned to their respective variables.

I guess, now you can guess the reason behind the output of above two code samples.

String is immutable, means that you can not change any string object. Instead JVM will create new string object (or fetch one from string pool) and assign it to the reference. e.g.

   String varA = "hello"; -> 1

   String varB = "hello"; -> 2

   varA="world" -> 3

   varB ="world" -> 4

At line 1, JVM will create String object "hello" in string pool and assign its reference to varA. At line 2, JVM will assign the reference of "hello" object already present in String pool to varB. At line 3, JVM will create a new object "world" and assign its reference to varA. Now String pool will have two objects , "hello" and "world". At line 4, JVM will assign the reference of "world" object already present in String pool to varB. String pool will still have two objects , "hello" and "world".

So basically, JVM has not modified any String object, it has just modified the reference.

Hope it helps you. If you have any problem please comment.

Nandkumar Tekale · Answer 3 · 2012-08-01T09:55:50.493

1

So String pool is carried out when two String object having same literal???

--> Not exactly, String pool is carried out when you define literal string. If you create literal string object like String obj = "sometext" and While creating second literal like String obj1 = "some Other Text", obj1 contents will be compared to "sometext" by JVM. If both contents are equal like String str1 = "hello" and String str2 = "hello", then object references str1 and str2 will be pointed to same object("hello").

Why second output is false ???

--> because abc and abcd points to different string objects.

Immutable means: once object is created you can not change its contents.

edited Aug 01 '12 at 09:55

answered Aug 01 '12 at 09:43

Nandkumar Tekale

16,024
8
58
85

if i changed abc="new hello"; can you explain imutable on the basis of this ?? – Amith Aug 01 '12 at 09:49
object pointed by `abc` has contents "new hello", you can not change this content like change contents to "old hello" – Nandkumar Tekale Aug 01 '12 at 09:52

score 1 · Answer 4 · answered Aug 01 '12 at 09:43

Java automatically applies String.intern to double quoted literals. Thus it is guaranteed that

String foo1 = "foo";
String foo2 = "foo";
assert foo1 == foo2;

However, for strings constructed other than as literals this is not guaranteed, i.e. given

String foo1 = "foo";
// contrived example, but imagine foo2 came from reading a file or similar
String foo2 = new String(new char[] { 'f', 'o', 'o' });

it is guaranteed that foo1.equals(foo2) but not necessarily that foo1 == foo2. You can call intern explicitly - it is guaranteed that foo1 == foo2.intern() - but it's generally clearer to use equals when you care about value equality and only use == when you really need reference equality.

Is String pool is carried out when two String having same literal ( java)

4 Answers4