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.
By the end of the run there will be four String objects:
String that corresponds to the interned "xyz" literalnew String("xyz")String that corresponds to the interned "abc" literalString 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.
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.
x + y in the OP's question is NOT a constant expression. Therefore it is not implicitly interned. In this case, the "optimization" is not permitted by the JLS. –
Haugh Take a look at decompiled class and you'll see everything :) The answer should be:
"xyz" and "abc") are only references to positions in constant pool so these ones are not created by your codenew 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
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...
Strings at runtime-time (keyword: new) and the compiler adds Strings - created at compile-time - to the constant pool (intern) –
Clairclairaudience 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:
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)
String.intern() go into the string pool. (That is how the classloader creates the string objects that correspond to string literals, and string constant expressions ... for example.) –
Haugh new keyword. This is the only case where you actually need to invoke intern() method if you need the string created using new to be interned. –
Stepdame intern method create them using new String(....) under the hood. Read the source code for java.lang.String here: grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/…. It will confirm that fact. –
Haugh I would say 4 because:
x + y will be replaced by the compiler with a StringBuilder implementation. +1new always creates a new object. +1Here'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
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.
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:
new and the + operator) when the code is executed.The existence / creation of these 4 string is guaranteed by the JLS.
The answer is 4
String x = new String("xyz");//First Object
String y = "abc";//Second Object
x = x + y;//Third, fourth Object
x + y expression always generates a new String because x and y are not constant variables. –
Haugh 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 :)
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.
4 Objects are created .
String x = new String("xyz"); it creates 2 objects one in scp and one in heap.
String y = "abc"; it creates one object in scp
x = x + y; it creates one more object in scp and it is referenced by x replacing its old object reference in scp.
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
The answer is 5
© 2022 - 2024 — McMap. All rights reserved.
xadds an important consideration here. – Slacken