Literal string creation vs String object creation

问题

How many String object are created

I am studying for the SCJP I cant seem to get my head round this String problem. I seem to see several possible answers depending on how i look at a question.

In the following initialization, how many string objects are created?

String s1 = "A" + "B" + "C" + "D";
System.out.println(s1)

Initially i thought 5 objects, i.e.

"A"
"B"
"C"
"D"
"ABCD"

But then thinking about it i am not really sure because for example will the compiler concatenate "A" + "B" as one object? i.e creating 7 objects?

"A"
"B"
"C"
"D"
"AB"
"ABC"
"ABCD"

Also, how many objects will be created if the code was changed to be

String s1 = new String("A" + "B" + "C" + "D");
System.out.println(s1);

And finally how about:

String s1 = "A";
String s2 = new String("A");

In the above example i think only 2 objects will be created

object 1 - "A"
object 2 - a String object that refers to the "A" object above.

Is this correct or will they not be related? i.e. the object referred to from the constant pool will be different from the one referred to by the s2 reference.

Thanks

Edit

Also, please note i am interested in knowing the total number of objects created including those that are discarded not just those that eventually end up in the constant pool.

Edit

Looking at Jon's answer i might have totally misunderstood the way the objects are created. I know that a String is created only once in the constant pool and it is reused but im not sure of the process that goes through when the 'final' string is constructed. Here is the section from the book i am reading which seems to suggest that temporary objects get created which is a complete opposite to the answers here. (Or maybe the book is wrong or i misunderstood the book)

The code sample was

String s1 = "spring ";  
String s2 = s1 + "summer ";  
s1.concat("fall ");  
s2.concat(s1);  
s1 += "winter";  
System.out.println(s1 + " " + s2);

The question was

What is the output? For extra credit, how many String objects and how many reference varibles were created prior to the println statement.

And the answer

The result of this code fragment is spring water spring summer. There are two reference variables, s1 and s2. There were a total of eight String objects created as follows "spring", "summer" (lost), "spring summer", "falls"(lost), "spring fall" (lost), "spring summer spring" (lost), "winter" (lost), "spring winter" (at this point "spring" is lost). Only two of the eight String objects are not lost in this process

Thanks

回答1:

The compiler will concatenate the whole of "A" + "B" + "C" + "D" into a single constant - so in your first example, only a single string ends up created at all. That same string will be reused if you execute the same code multiple times. The constant is put in the class file, and when the class is loaded the VM checks whether an equal string is already in the string pool - so it will reuse it even if you have the same code in multiple classes.

You can verify that only a single string is in the constant pool within the class with javap:

javap -v Test

Constant pool:
   #1 = Methodref   #6.#17     //  java/lang/Object."<init>":()V
   #2 = String      #18        //  ABCD
   #3 = Fieldref    #19.#20    //  java/lang/System.out:Ljava/io/PrintStream;

However, here:

String s1 = "A";
String s2 = new String("A");

you do end up with two separate string objects. One (the constant) will be reused every time you execute the code (and is shared between the two statements), and a new one will be created due to the constructor call each time.

So for example, this method:

public static void foo() {
    for (int i = 0; i < 5; i++) {
        String s1 = "A";
        String s2 = new String("A");
    }
}

... will end up using six string objects - one for the constant, and five new ones created each time you call the method.

回答2:

How many objects created?

String s1 = "A" + "B" + "C" + "D";
System.out.println(s1)

One or none. This is reduced to one String literal which could be already loaded.

String s1 = new String("A" + "B" + "C" + "D");
System.out.println(s1);

This always creates an extra object.

BTW: A string usually consists of two objects, the String and the char[] it wraps.

回答3:

String s1 = "A" + "B" + "C" + "D";

The compiler will create only one string literal "ABCD" and put it in the String pool. One object will be created (the one in the String Pool).

String s1 = new String("A" + "B" + "C" + "D");

Same here, except that you are copying it from the String literal. So, 2 object will be created here. One by the new and one in the String Pool.

String s1 = "A";
String s2 = new String("A");

Same here, "A" will be a constant in the string pool. The constructor will copy it. So here two objects will be created.

来源：https://stackoverflow.com/questions/8316687/literal-string-creation-vs-string-object-creation

标签

java

string

scjp