How many string objects will be created in memory? [duplicate]

Answer 1

I'll anwser to another, clearer question: how many String instances are involved in the following code snippet:

String s="";
s+=new String("a");
s+="b";

And the answer is 6:

• the empty String literal: "";
• the String literal "a";
• the copy of the String literal "a": new String("a");
• the String created by concatenating s and the copy of "a";
• the String literal "b"
• the String created by concatenating s and "b".

If you assume that the three String literals have already been created by previously-loaded code, the code snippet thus creates 3 new String instances.

Answer 2

Creating New Strings

Earlier we promised to talk more about the subtle differences between the various methods of creating a String. Let's look at a couple of examples of how a String might be created, and let's further assume that no other String objects exist in the pool:

String s = "abc"; // creates one String object and one reference variable

In this simple case, "abc" will go in the pool and s will refer to it.

String s = new String("abc"); // creates two objects, and one reference variable

In this case, because we used the new keyword, Java will create a new String object in normal (nonpool) memory, and s will refer to it. In addition, the literal "abc" will be placed in the pool.

From SCJP Sun Certified Programmer for Java 6 Study Guide (Exam 310-065).pdf

Answer 3

String s="";

creates no objects.

s+=new String("a");

creates five objects. the new String, the StringBuilder and its char[] and the String resulting and its char[]

s+="b";

creates four objects, the StringBuilder and its char[] and the String resulting and its char[]

So I get a total of nine objects of which are three String objects

Note: You can be sure that "" has already been loaded as it appear in many system classes including ClassLoader and Class.

The Strings "a" and "b" may or may not be considered as new Strings for the purpose of this question. IMHO I wouldn't count them as they will only be created at most once and if this code is only run once, it hardly matters how many strings are created. What is more likely to be useful is to know how many objects are created each time the code is run.

Answer 4

The number of objects actually created in a JITC situation is indeterminate. The JITC may well recognize that new String("a") is an identity, and that no intermediate values of s are referenced, so that only the StringBuilder is created. There are several potential side-effects that must be mimicked in the general case (eg, where the argument to new String() may be invalid), but with literals they can't occur.

In fact, javac could very well recognize that the result is "ab", with no potential side-effects, and just produce a String literal of that value. (It does string combining in slightly less complicated cases.)