Appending the string

Question

Can anyone please explain what is the difference between below implementation of String-

1)

{
    String comma=",";
    return finalStr = "Hello"+comma+"Welcome"+comma+"to"+comma+"Stack"+comma+"overflow";
}

2)

{
    return finalStr = "Hello,Welcome,to,Stack,overflow";
}

How many string object will be created in first (1) block, will there be only one string finalStr which refer to memory location where Hello,Welcome,to,Stack,overflow is stored or will it create multiple locations for each word and then once appended it will create a new memory location.

Like you said yourself it will take all the string values from where you are trying to append i.e. "Hello" + comma it will create 6 copies of the string you have in there and then put them together as a new string and rreturn it's value, If I'm honest use string builder which is much more efficient and it's content is mutable so no copies are created :-) — XAMlMAX, Feb 18 '14 at 08:17
Thanks for your reply, :). yes I am aware of StringBuilder/StringBuffer however, this query was just for clarification on how JVM will handle this scenario of String. — Nikhil, Feb 18 '14 at 08:22
And when I use something like : return new StringBuilder("Hello," + "Welcome,"+"to,"+"Stack,"+"overflow"); } Will this create different Strings for Hello, Welcome, to, ... ? — Nikhil, Feb 18 '14 at 08:26
nope it will just create one string and assign its value to "Hello,Welcome,to,Stack,overflow"; But i think you would have to call ToString method to return srting rather than StringBuilder :-) — XAMlMAX, Feb 18 '14 at 08:49

Abimaran Kugathasan · Accepted Answer · 2014-02-18T08:34:33.493

In both cases, only one String object will be created for each. Since, compiler is smart enough for understand the concatenation in compile time. These are string literals, they will be evaluated at compile time and only one string will be created for each cases.

As per JLS

A long string literal can always be broken up into shorter pieces and written as a (possibly parenthesized) expression using the string concatenation operator + [...] Moreover, a string literal always refers to the same instance of class String.

Strings computed by constant expressions (§15.28) are computed at compile time and then treated as if they were literals.

Strings computed by concatenation at run-time are newly created and therefore distinct.

Could you please explain how in 1st case only one object of string will be created? Thanks in advance. — Nikhil, Feb 18 '14 at 08:30

score 0 · Answer 2 · edited May 23 '17 at 11:50

0

Take a look at this or this answer. The compiler will optimize some things for you. So stick with the most readable solution.

Similar questions have been asked several times, you will find some useful further information about your question if you read those answers.

edited May 23 '17 at 11:50

Community

1
1

answered Feb 18 '14 at 08:33

Ortwin Angermeier

5,957
2
34
34

score 0 · Answer 3 · edited Feb 18 '14 at 12:01

0

As far as I know, In first cast JVM continuously making instant variables to keep Strings like "Hello", "Welcome", etc...

Further more, every appending operation it needs another variable to save appended String for example "Hello," + "Welcome" ...

On the other hand, second case, it allocate once for String. Thanks.

edited Feb 18 '14 at 12:01

Abimaran Kugathasan

31,165
11
75
105

answered Feb 18 '14 at 08:34

Juneyoung Oh

7,318
16
73
121

score 0 · Answer 4 · answered Feb 18 '14 at 09:05

use javap to check how the compiler is trying to optimize the code, i first scenario, a concatenation happen using the StringBuilder and finally toString is called

   Code:
       0: ldc           #16                 // String ,
       2: astore_1      
       3: new           #18                 // class java/lang/StringBuilder
       6: dup           
       7: ldc           #20                 // String Hello
       9: invokespecial #22                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
      12: aload_1       
      13: invokevirtual #25                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      16: ldc           #29                 // String Welcome
      18: invokevirtual #25                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      21: aload_1       
      22: invokevirtual #25                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      25: ldc           #31                 // String to
      27: invokevirtual #25                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      30: aload_1       
      31: invokevirtual #25                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      34: ldc           #33                 // String Stack
      36: invokevirtual #25                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      39: aload_1       
      40: invokevirtual #25                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      43: ldc           #35                 // String overflow
      45: invokevirtual #25                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      48: invokevirtual #37                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      51: astore_2

Scenario 2

52: ldc           #41                 // String Hello,Welcome,to,Stack,overflow
      54: astore_2      
      55: return

Appending the string

4 Answers4