Counting String objects created by Java code

Question

How many String objects are created by the following code?

String x = new String("xyz");
String y = "abc";
x = x + y;

I have visited many websites where some say that this line of code creates 3 objects and some say it creates 4. I just wanted to know how many objects are created after this line of code is executed.

Answer 1

By the end of the run there will be four String objects:

1. A String that corresponds to the interned "xyz" literal
2. Its copy created by new String("xyz")
3. A String that corresponds to the interned "abc" literal
4. A String that corresponds to concatenation "xyz" + "abc"

The real question is attributing some or all of these objects to your program. One can reasonably claim that as few as two or as many as four Strings are created by your code. Even though there are four String objects in total, objects 1 and 3 may not necessarily be created by your code, because they are in a constant pool, so they get created outside your code's direct control.

Answer 2

This Answer is to correct a misconception that is being put about by some of the other Answers:

For example:

The compiler might substitute x + y with a constant ("xyzabc"), though. @Binkan Salaryman

... and String object 4 [the String that corresponds to concatenation] can be computed by the compiler and turned into an interned constant as well. @dasblinkenlight

This is incorrect. The JLS states this:

15.18.1. String Concatenation Operator +

....

The String object is newly created (§12.5) unless the expression is a constant expression (§15.28).

In order to qualify as a constant expression, the variable names in the expression must be:

Simple names (§6.5.6.1) that refer to constant variables (§4.12.4).

where a "constant variable" is defined as:

A constant variable is a final variable of primitive type or type String that is initialized with a constant expression (§15.28).

In this example, neither x or y are final so they are not constant variables. And even if they were final, y still wouldn't be a constant variable because of the use of the new operator in its initialization.

---

In short, the Java compiler is not permitted to use an intern'd constant "xyzabc" as the result of the concatenation expression.

If I added the following statement at the end:

    System.out.println(x == "xyzabc");

it will always print false ... assuming that the compiler is conformant to the Java Language Specification.

Answer 3

Take a look at decompiled class and you'll see everything :) The answer should be:

• two strings ("xyz" and "abc") are only references to positions in constant pool so these ones are not created by your code
• one string is created directly (new String("xyz"))

• string concatenation is optimised by compiler and changed to StringBuilder so the last string is created indirectly

  public java.lang.String method();
  descriptor: ()Ljava/lang/String;
  flags: ACC_PUBLIC
  Code:
    stack=3, locals=3, args_size=1
   0: new           #2                  // class java/lang/String
   3: dup
   4: ldc           #3                  // String xyz
   6: invokespecial #4                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
   9: astore_1
  10: ldc           #5                  // String abc
  12: astore_2
  13: new           #6                  // class java/lang/StringBuilder
  16: dup
  17: invokespecial #7                  // Method java/lang/StringBuilder."<init>":()V
  20: aload_1
  21: invokevirtual #8                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  24: aload_2
  25: invokevirtual #8                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  28: invokevirtual #9                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
  31: astore_1
  32: aload_1
  33: areturn
  

Answer 4

If you want to test for instances, run this code snippet and look at the output:

import static java.lang.System.identityHashCode;

public class Program {
    public static void main(String... args) {
        String x = new String("xyz");
        String y = "abc";
        String z = x + y;

        System.out.printf("x: %d | %d\n", identityHashCode(x), identityHashCode(x.intern()));
        System.out.printf("y: %d | %d\n", identityHashCode(y), identityHashCode(y.intern()));
        System.out.printf("z: %d | %d\n", identityHashCode(z), identityHashCode(z.intern()));
    }
}

---

I have the following output using jdk1.7.0_67:

x: 414853995 | 1719175803
y: 1405489012 | 1405489012
z: 1881191331 | 1881191331

That's a total of 4 String instances...

Answer 5

The answer is 4.

As you have used the new keyword, Java will create a new String object in normal (non pool) memory and x will refer to it. In addition to this, the literal "xyz" will be placed in the string pool which is again another string object.

So, the 4 string objects are:

1. "xyz" (in non-pool memory)
2. "xyz" (in pool memory)
3. "abc" (in pool memory)
4. "xyzabc" (in non-pool memory)

If your code had been like this:

String x = "xyz";
String y = "abc";
x = x + y;

then the answer would be 3.

Note: String #4 is in non-pool memory because String literals and the strings produced by evaluating constant expressions (see JLS §15.28) are the only strings that are implicitly interned.

Source: SCJP Sun Certified Programmer for Java 6 (Page:434, Chapter 6)

Answer 6

I would say 4 because:

• x + y will be replaced by the compiler with a StringBuilder implementation. +1
• new always creates a new object. +1
• Different constants are different objects. +2

Here's how:

String x = new String("xyz"); // 2 objects created: the variable and the constant
String y = "abc"; // 1 object created: the variable
x = x + y; // 1 object created: the one by the StringBuilder class

Answer 7

new String(”xyz“) for sure creates a new instance. "abc" and "xyz" are stored in the class constant pool, x = x + y creates a StringBuilder under the hood and therefore creates a new String, so the count of strings are 4 here.

---

The compiler might substitute x + y with a constant ("xyzabc"), though.

Answer 8

The reason that you see different answers to the question is (in part) that it is ambiguous.

"How many String objects are created by the following code?"

The ambiguity is in the phrase "created by the following code":

• Is it asking about the number of String objects that are created by (just) the execution of the code?

• Or ... is it asking about the number of String objects that need to exist during the execution of the code?

You could argue that the code implicitly creates the String objects that correspond to the literals, not when it is run, but when it is loaded. However, those objects could be shared with other code that uses the same literals. (And if you look hard enough, it is possible that other string objects containing the same character strings get created during the class loading process.)

---

Another reason you see different answers is that it is not entirely clear how many strings get created. The various specifications state that new String objects will be created at certain points, but there is "wriggle room" on whether intermediate String objects could be created.

For example, the JLS states that new always creates a new object, and that the string concatenation operator creates a new object except under certain clearly specified cases (see my other answer). However, the specs do not forbid creation of other strings behind the scenes.

---

But in this case, if we assume that we are using a modern Hotspot JVM, then:

• 2 string objects exist (for the string literals) before the code starts executing, and
• 2 new string objects are created (by the new and the + operator) when the code is executed.

The existence / creation of these 4 string is guaranteed by the JLS.

Answer 9

The answer is 4

String x = new String("xyz");//First Object

String y = "abc";//Second Object

x = x + y;//Third, fourth Object

Answer 10

Sometime it's better to let byte code speak Examining the code using JAVAP

public static void main(java.lang.String[]);
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, locals=3, args_size=1
         0: new           #16                 // class java/lang/String
         3: dup
         4: ldc           #18                 // String xyz
         6: invokespecial #20                 // Method java/lang/String."<init>":(Ljava/lang/String;)V
         9: astore_1
        10: ldc           #23                 // String abc
        12: astore_2
        13: new           #25                 // class java/lang/StringBuilder
        16: dup
        17: aload_1
        18: invokestatic  #27                 // Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;
        21: invokespecial #31                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
        24: aload_2
        25: invokevirtual #32                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/St
ringBuilder;
        28: invokevirtual #36                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        31: astore_1
        32: return
      LineNumberTable:
        line 6: 0
        line 7: 10
        line 8: 13
        line 9: 32
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
               0      33     0  args   [Ljava/lang/String;
              10      23     1     x   Ljava/lang/String;
              13      20     2     y   Ljava/lang/String;
}

Now as seen form the code

At `0: new` Creates a new String Object 
At `3:dup` ; make an extra reference to the new instance

    At `4:ldc #18` as seen literal "xyz" has been placed in the pool (one string Object) 
At `6: invokespecial;` ; now call an instance initialization method with parameter and creates a object in nonpool memory.
At `9: astore_1` Stores the above reference in local variable 1(i.e x)

So by this time we have two String object

At `10:ldc #23` as seen literal "abc" has been placed in the pool (third string ) 

    At `12: astore_2` Stores the above reference in local variable (i.e y)

so By this time we have three String Object

    28: invokevirtual #36 // Method java/lang/StringBuilder.toString:
()Ljava/lang/String;;(fourth String Object is Created)

So we have total of four String Object in this code.

As i'm new to programming and have started it learning only few months back point me if i went wrong somewhere and what is the correct version of it. Thanks :)

Answer 11

Line 1:String x = new String("xyz");
Line 2:String y = "abc";
Line 3:x = x + y;

Strings are Immutable so if any existing string variable need to be changed then new object will be created for assignment. Line 1,Line 2 are string objects where as Line 3 is modification of the existing string variable so new allocation need to be done to add x+y. So it should create creates 3 Objects.

Answer 12

1.objects created in heap area "xyz" //created by 'String x' and xyzabc //created by 'x+y'(concatenation)

2.objects created in scp(string constant pool) "xyz" //created for future purpose which is not available for garbage collection and "abc" //created by 'String y' literal

so total objects created in this case is 4

Answer 13

The answer is 5

1. xyz in non pool memory
2. xyz in pool memory with no reference
3. abc in pool memory with reference
4. xyz still in non pool memory, reference changed to xyzabc in non pool memory
5. xyzabc in pool memory with no reference