when to use string literal and String New Object ?

Hi,

As we know string has 2 ways to create objects using literal.

using literals is better , as its creates only one ref variable and assigned it to the String pool.

String str1 = "Prabhat"; // 1 ref variable

String str1 = new String("Prabhat"); // 2 String Object and 1 reference variable

so which one the better to use and when & why ?

Both have their own trade-offs:

If you create a string using String literals , the string stays in the string-pool forever. It is never garbage collected.
The down side of this is that the string-pool has a fixed size and it will get full at sometime.

With 'new' operator new strings objects are created out of the string-pool, and they are eligible for garbage-collection. So if you don't need them anymore you can make the eligible for garbage collection, but the down side of this is that with 'new' operator JVM will always have to create a new object and it is an overload for JVM.

So if i know that my application is going to use some fixed number of string values , i will use string literals for better performance. But if my application will need different string at different times i will use 'new' operator to create them.

There is never a good reason to use version #2 - create a new String explicitly with a string literal as the argument.

The constructor of class String that takes another String is useful in some special cases, but not when passing a string literal.

Jesper de Jong wrote:
The constructor of class String that takes another String is useful in some special cases

just curiosity , can you please tell me the special cases ?

I have never seen in code where we are using version 2 to create a string object..

Ok, here is an example. Note that this is a bit advanced - you have to know something about the inner workings of class String to understand this.

A String objects stores its data in a character array. When you take a substring of a string, by calling the substring() method, then the new String object that is created does not copy part of the data of the original string. Instead, it stores a reference to the underlying data of the original string, along with an offset and length to indicate what part of the old string the new String object represents.

When you have a very long string (for example you read the contents of a file into a String object) and you take a substring out of it, then the JVM will retain all the data of the original string in memory - even if you discard the original String object, because the String object created with substring() still holds a reference to the whole character array with all the data.

To prevent this memory inefficiency, you can explicitly create a new String object using the substring object. That second new String object will copy the data from the substring object, but just the part that you need.
// Suppose this contains 100K characters read from a file String largeString = ...; // This will refer to the 100K char array from largeString, keeping the whole buffer in memory // even though sub represents only 20 characters String sub = largeString.substring(80, 100); // This will copy the 20 characters from sub into a new buffer, so that the whole 100K buffer doesn't need to be kept String sub2 = new String(sub);
If you want to see how exactly it works, then have a look at the source code of class String, which you can find in the file src.zip in your JDK installation directory.

the information you have given is really helpful. thank you Jesper

thanks everyone for your reply on this topic.

ashwin bhawsar wrote:With 'new' operator new strings objects are created out of the string-pool, and they are eligible for garbage-collection. So if you don't need them anymore you can make the eligible for garbage collection, but the down side of this is that with 'new' operator JVM will always have to create a new object and it is an overload for JVM.

The OP was asking about when to use this:
String temp = new String("FRED");
When you do it this way, you get BOTH the literal in the String pool AND the object created on the heap, so this is actually worse.

Jesper de Jong wrote:
When you have a very long string (for example you read the contents of a file into a String object) and you take a substring out of it, then the JVM will retain all the data of the original string in memory - even if you discard the original String object, because the String object created with substring() still holds a reference to the whole character array with all the data.

Nice explanation jasper. But I do have a doubt. Would not JVM retain all data once largeString.substring(80, 100); is invoked.
String sub2 = new String(sub); IMO, Above creates a new String instance but the older one will still resides in the memory.

Let me know if I got it wrong.

I think what was not stated in Jasper example was that largeString could then be set to null (or fall out of scope), and then could be reclaimed by the garbage collector.

if you do this:

String sub = largeString.substring(80, 100);

even if you then set largeString to null, the sub refers to a spot in that object, so the whole thing cannot be reclaimed.

Firstly thanks to all for an in-depth discussion.

Jesper de Jong wrote:
If you want to see how exactly it works, then have a look at the source code of class String, which you can find in the file src.zip in your JDK installation directory.

As suggested by Jesper I was going through the source code of String class.

I have some doubts:

1. Am I getting it right that a native method intern() is called when we use a literal to initialize a String reference.

2. Javadocs for intern() method says : A pool of strings, initially empty, is maintained privately by the class String.
What does "privately" mean here? Is this pool maintained in native code?

As per my knowledge intern() is used when you want to force the JVM for String str = new String("xyz");

str.intern(); // in this statement JVM forces first to search any string literal is there in internal pool or not, if it there then it will point to that pool string literal and will not create new Object of String, if not found then it will create new Object of String.

Piyush Joshi wrote:1. Am I getting it right that a native method intern() is called when we use a literal to initialize a String reference.

This native method is called whenever a String literal is encountered.

2. Javadocs for intern() method says : A pool of strings, initially empty, is maintained privately by the class String.
What does "privately" mean here? Is this pool maintained in native code?

No, it really just means private. The String class keeps a private collection of Strings to keep track of which have been interned.

Stephan van Hulst wrote:

2. Javadocs for intern() method says : A pool of strings, initially empty, is maintained privately by the class String.
What does "privately" mean here? Is this pool maintained in native code?

No, it really just means private. The String class keeps a private collection of Strings to keep track of which have been interned.

I asked this question because I could not find any private field which keeps collection of Strings.

All the private fields of String class are :

value:char[]
offset:int
count:int
hash:int
serialVersionUID:long
serialPersistentFields: ObjectStreamField[]

Is there anything I am missing here?

It's created natively, so the declaration would probably be in some C or C++ code.

Thanks Stephan for quick replies.