Pages

Difference between String literal and New String object in Java

String is a special class in Java API and has so many special behaviours which is not obvious to many programmers. In order to master Java, first step is to master String class, and one way to explore is checking what kind of String related questions are asked on Java interviews. Apart from usual questions like why String is final, or equals vs == operator, one of the most frequently asked question is what is difference between String literal and String object in Java. For example, what is the difference between String object created in following two expression :

String strObject =newString("Java");

and

String strLiteral ="Java";

Both expression gives you String object, but there is subtle difference between them. When you create String object using new() operator, it always create a new object in heap memory. On the other hand, if you create object using String literal syntax e.g. "Java", it may return an existing object from String pool (a cache of String object in Perm gen space, which is now moved to heap space in recent Java release), if it's already exists. Otherwise it will create a new string object and put in string pool for future re-use. In rest of this article, why it is one of the most important thing you should remember about String in Java.

What is String literal and String Pool

Since String is one of the most used type in any application, Java designer took a step further to optimize uses of this class. They know that Strings will not going to be cheap, and that's why they come up with an idea to cache all String instances created inside double quotes e.g. "Java". These double quoted literal is known as String literal and the cache which stored these String instances are known as as String pool. In earlier version of Java, I think up-to Java 1.6 String pool is located in permgen area of heap, but in Java 1.7 updates its moved to main heap area. Earlier since it was in PermGen space, it was always a risk to create too many String object, because its a very limited space, default size 64 MB and used to store class metadata e.g. .class files. Creating too many String literals can cause java.lang.OutOfMemory: permgen space. Now because String pool is moved to a much larger memory space, it's much more safe. By the way, don't misuse memory here, always try to minimize temporary String object e.g. "a", "b" and then "ab". Always use StringBuilder to deal with temporary String object.

Difference between String literal and String object

At high level both are String object, but main difference comes from the point that new() operator always creates a new String object. Also when you create String using literal they are interned. This will be much more clear when you compare two String objects created using String literal and new operator, as shown in below example :

In general you should use the string literal notation when possible. It is easier to read and it gives the compiler a chance to optimize your code. By the way any answer to this question is incomplete until you explain what is String interning, so let's see that in next section.

String interning using inter() method

Java by default doesn't put all String object into String pool, instead they gives you flexibility to explicitly store any arbitrary object in String pool. You can put any object to String pool by calling intern() method of java.lang.String class. Though, when you create using String literal notation of Java, it automatically call intern() method to put that object into String pool, provided it was not present in the pool already. This is another difference between string literal and new string, because in case of new, interning doesn't happen automatically, until you call intern() method on that object. Also don't forget to use StringBuffer and StringBuilder for string concatenation, they will reduce number

That's all about this question, what is difference between String literal and String object in Java. Always remember that literal Strings are returned from string pool and Java put them in pool if not stored already. This difference is most obvious, when you compare two String objects using equality operator (==). That's why it's suggested as always compare two String object using equals() method and never compare them using == operator, because you never know which one is coming from pool and which one is created using new() operator. If you know the difference between string object and string literal, you can also solve questions from Java written test, which also test this concept. It's something, every Java programmer should know. of temporary String object in heap space.

In first statement one String is created using literal syntax so that will go to the String pool, which is also part of heap from Java 1.7 but was part of permgen area in Java 1.6. In second statement, "Java" will not create another object instead it will reuse the object created in previous step, had it been any other word e.g. "java" it would have created another object. By the way new String() will create another object in Java heap space. No object in stack but reference variables language and anotherLanugage will be created and stored in stack.

I'm a little bit confused about the second statement in the expressions above executed:

String language = "Java";String anotherLanguage = new String("Java");

After the execution of first statement, the String Literal "Java" is created in String Pool.But then in second statement, I think that the "Java" will be created in Heap area, although I may be wrong in this but to the point I know I think that's the way it is. Although I'm not confirm about where the "Java"in the second statement parenthesis will be created/or not.

Yes, both interned String and literals are subject to garbage collection. when a String literl doesn't have any active reference it becomes eligible for garbage collection and this is true for all Java versions. In Java 7, String pool is moved to heap space, but even when it was in PermGen space untile Java 6, String constants were garbage collected.

I am still confused about how many objects created when u create string using new operator.as per me if I write String s = new String("ABC") then two objects are created one in heap and one in String pool.Please provide your feedback.

Actually two objects are created, first the "ABC" object which is created in String pool and second the new String() object which is created in heap. String pool is also now part of Java heap from JDK 7 release update 40 I guess.

Hi. What is the use of creating two object i.e using new keyword . For Ex. String S=new String("abc");In this example there will be 2 objects. 1 in string Pool and 1 in NonPool Memory. But what is the relevance of String pool object when using new Keyword. Is it available for next time when we create another object using new keyword with same value and if not then why it is there?

there will be two objects created s will be in heap and by "abc" literal object will be go in the string constant pool.if there is already a "abc" present than it will not create new and give the reference of previous "abc".Take A example:class intern{public static void main(String... s){String s6 = "arpan";String s5 = "arpan";if(s5==s6)System.out.println("true");}}

when you say if we call itern() on string object it moves to string constant pool.

System.out.println("Testing intern"); String test = "intern"; String test1 = new String("intern"); System.out.println(test == test1);// it will return false no doubt about it test1.intern();// moved string object into pool having same literal System.out.println(test == test1); // it should have written true but its not

Hello @Anonymous, the intern() method has no effect on existing object. Now, if you create another object with literal e.g. "intern" then same object is returned instead of creating a new one. See my post when to use intern() method of String in Java to learn more about intern

But this is an exception, a trick and any exception makes our life harder and it pales the beauty of Java. Why Java designers did not automatically decide if a string in PermGen to use it no matter it is literal or new object? So if after a String s1="Java"; //coming with String s2 = new String("Java"); to return also s1 as it is already there?

This in idea that Java is a tool in our hands not vice-verse. And we prefer simple but effective tools.

I think there are false sentences in the article. Or I may have misunderstood me. When I search on the internet, when I say new String ("abc"), 2 values are created in memory, including a heap and a String pool. I agree that there is no value in the pool.Then the following sentences in the article attract my attention. And I can not understand. It says that it will not be put in the pool without calling the intern () method. Do I get it wrong?

"Java by default doesn't put all String object into String pool, instead they gives you flexibility to explicitly store any arbitrary object in String pool. You can put any object to String pool by calling intern() method of java.lang.String class."

According to these sentences, when I say new String ("abc"), if I don't call the intern () method, it will not be put in the pool. However, it does not write like this on the Internet.Can you explain it to me?

Hello OMER,When you write String str = new String ("abc") there are two objects created here, string literal "abc" which is created in String pool and an object refereed by str, both contains "abc" but one is in heap and other is in string pool. if you do str.intern() then it will refer to same object as "abc". You can try it yourself by comparing using == operator to find out more.