Mfcttrf

I was asked in an interview about the number of objects that will be created on the given problem:

String str1 = "First";
String str2 = "Second";
String str3 = "Third";
String str4 = str1 + str2 + str3;

So I am not sure that the answer I gave was correct or not.

I answered that there would be 6 objects created in the string pool.

3 would be for all three variables.

1 would be for str1 + str2 (let's say str).

1 would be for str2 + str3.

1 would be for the str + str3 (str = str1 + str2).

Please help me out on this confusion.

With the given information, the question cannot be definitely answered. As is stated in the JLS, §15.18.1:

... To increase the performance of repeated string concatenation, a Java compiler may use the StringBuffer class or a similar technique to reduce the number of intermediate String objects that are created by evaluation of an expression.

This means that the answer depends at least on the concrete Java compiler used.

I think the best we can do is give an interval as answer:

• a smart compiler may be able to infer that str1 to str3 are never used and fold the concatenation during compilation, such that only one String-object is created (the one referenced by str4)


• The maximum sensible number of Strings created should be 5: one each for str1 to str3, one for tmp = str1 + str2 and one for str4 = tmp + str3.

So... my answer would be "something between one to five String-objects". As to the total number of objects created just for this operation... I do not know. This may also depend how exactly e.g. StringBuffer is implemented.

As an aside: I wonder what the reason behind asking such questions is. Normally, one does not need to care about those details.

Java 8 will likely create 5 objects:

• 3 for the 3 variables


• 1 StringBuilder


• 1 for the concatenated String

With Java 9 things changed though and String concatenation does not use StringBuilder anymore.

It should be 5:

• three for the three literals (assigned to str1, str2 and str3)




• one for str1 + str2




• one for (result from the previous operation) + str3 (assigned to str4)

Any answer to your question will be dependant on the JVM implementation and the Java version currently being used. It's a stupid question to ask in an interview.

Java 1.8.0_201

On my machine, with Java 1.8.0_201, your snippet results in this bytecode

 L0
 LINENUMBER 13 L0
 LDC "First"
 ASTORE 1
 L1
 LINENUMBER 14 L1
 LDC "Second"
 ASTORE 2
 L2
 LINENUMBER 15 L2
 LDC "Third"
 ASTORE 3
 L3
 LINENUMBER 16 L3
 NEW java/lang/StringBuilder
 DUP
 INVOKESPECIAL java/lang/StringBuilder.<init> ()V
 ALOAD 1
 INVOKEVIRTUAL java/lang/StringBuilder.append (Ljava/lang/String;)Ljava/lang/StringBuilder;
 ALOAD 2
 INVOKEVIRTUAL java/lang/StringBuilder.append (Ljava/lang/String;)Ljava/lang/StringBuilder;
 ALOAD 3
 INVOKEVIRTUAL java/lang/StringBuilder.append (Ljava/lang/String;)Ljava/lang/StringBuilder;
 INVOKEVIRTUAL java/lang/StringBuilder.toString ()Ljava/lang/String;
 ASTORE 4
 L4
 LINENUMBER 19 L4
 RETURN

which proves that 5 objects are being created (3 constant String literals, 1 StringBuilder, 1 dynamically produced String instance by StringBuilder#toString).

Java 12.0.2

On my machine, with Java 12.0.2, the bytecode is

 L0
 LINENUMBER 13 L0
 LDC "First"
 ASTORE 1
 L1
 LINENUMBER 14 L1
 LDC "Second"
 ASTORE 2
 L2
 LINENUMBER 15 L2
 LDC "Third"
 ASTORE 3
 L3
 LINENUMBER 16 L3
 ALOAD 1
 ALOAD 2
 ALOAD 3
 INVOKEDYNAMIC makeConcatWithConstants(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String; [
 // handle kind 0x6 : INVOKESTATIC
 java/lang/invoke/StringConcatFactory.makeConcatWithConstants(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/invoke/CallSite;
 // arguments:
 "u0001u0001u0001"
 ]
 ASTORE 4
 L4
 LINENUMBER 17 L4
 RETURN

which magically changes "the correct answer" to 4 objects since there is no intermediate String[Buffer/Builder] involved.