String object using new operator

[Rahul Ba]

How many object are created in each of the following statements.

    String s="ghi" // line 1    
    String s=new String("ghi");  // line 2    
    String s=new String("jkl");  //  line 3 

Please explain me. I know in line 1 only one object is created. What about Line 2 and Line 3?

[Rameshwar Soni]

3 Objects will be created.

Rahul Ba wrote:
I know in line 1 only one object is created. What about Line 2 and Line 3?

Irrespective of what is there in the String pool, if you are using "new" an Object will be created.

[Abhijit Ghatnekar]

String s="ghi" // line 1      
String s=new String("ghi");  // line 2 

One object, it is just that you are re-assigning the same String object on the heap to the same String reference. line 1 and line 2 are two alternatives of creating and initializing a string so one object.

String s=new String("jkl");

The string reference s is now re-assigned to a completely new object on the heap denoted by "jkl". The String instance created above may be garbage collected.....

Do read up on String immutability in Java. You may find it easy to tackle these kinda-questions..

Regds,
Abhijit.

[SCJP 4/5, Zend Certified Engineer for PHP 5, OCPWCD 5, MySQL Certified Associate, Python Certified by OReilly]

[James Boswell]

3 objects, one per line.

[Matthew Brown]

Actually, I'd go for four. Every time you use new String you get a new one. But also, how many different String literals are you creating?

[Matthew Brown]

Abhijit Ghatnekar wrote:
The string reference s is now re-assigned to a completely new object on the heap denoted by "jkl". The String instance created above may be garbage collected.....

Not relevant to the question, though.

[Rahul Ba]

My answer is as follows please correct me If I am wrong

    String s="ghi" // line 1                 One Object is created
    String s=new String("ghi");  // line 2       ....One Object is created, because there is already "ghi" string literal present in the String Pool.
    String s=new String("jkl");  //  line 3     ......Two objects are created...one in String constant pool and then it's copied to Heap.

[Winston Gutkowski]

Rahul Ba wrote:My answer is as follows please correct me If I am wrong

Sounds about right to me, but the fact is that the most important thing is when they're created.
Pool objects (the literals) are created by the compiler and loaded at program initialization; new objects
are created at runtime, probably around the time the statement is actually executed (hard to say
exactly, because of all the optimization that goes on).

Winston

[James Boswell]

So Winston, how many objects do you think are created by the 3 lines of code?

[Jesper de Jong]

Abhijit Ghatnekar wrote:One object, it is just that you are re-assigning the same String object on the heap to the same String reference. line 1 and line 2 are two alternatives of creating and initializing a string so one object.

That's not completely correct: lines 1 and 2 do not do exactly the same.

In the first line, s will refer to a String object which is in the string pool.

In the second line, you are creating a new String object explicitly which will copy its contents from the String object that's in the string pool.

Note that it is wasteful and never necessary to create a String object explicitly by passing it a String literal.

// Never write code like this!
String s = new String("xyz");

// Just do this, which avoids unnecessarily creating a String object
String s = "xyz";

[Jeff Verdegan]

Rahul Ba wrote:
How many object are created in each of the following statements.

    String s="ghi" // line 1    
    String s=new String("ghi");  // line 2    
    String s=new String("jkl");  //  line 3 

Please explain me. I know in line 1 only one object is created. What about Line 2 and Line 3?

Executing that code creates two String objects. Line 1 just assigns to variable s a reference to a String object that was created in the pool when the class was loaded (if some other class hadn't already caused it to be created).

[Jeff Verdegan]

Abhijit Ghatnekar wrote:

String s="ghi" // line 1      
String s=new String("ghi");  // line 2 

One object, it is just that you are re-assigning the same String object on the heap to the same String reference. line 1 and line 2 are two alternatives of creating and initializing a string so one object.

No.

First we don't assign objects, we assign references. Second, the new operator always creates a new object.

Line 1 doesn't create any objects, and line 2 creates one.

Do read up on String immutability in Java.

That's only relevant to the extent that for the constant pool to make any sense, the objects in it need to be immutable. It has no bearing on how many objects are created by this code.

[James Boswell]

Executing that code creates two String objects. Line 1 just assigns to variable s a reference to a String object that was created in the pool when the class was loaded (if some other class hadn't already caused it to be created).

Thanks for this clear explanation Jeff.