what is the difference between String and StringBuffer?

[zhiqiang zhang]

many people say StringBuffer is more efficient ,that's why?

String str1 = "Hello ";
String str2 = "EveryBody"
str1 +=str2; //when do this ,my friends say will new StringBuffer(),and then call append(),then call toString() to return a String .Is this true?

[Mohamed Sanaulla]

If there are lot of concatenations- Use StringBuffer. For one or two concatenations I dont think StringBuffer is required. For every concatenation creates one new string in the String pool.
May be you can consider StringBuilder if are not concerned about Thread safe operations.

[Rob Spoor]

public class Test
{
    public static void main(String[] args) throws Exception
    {
        String str1 = "Hello "; 
        String str2 = "EveryBody";
        str1 +=str2;
    }
}

When I compile that, then decompile that using JAD I get this:

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   Test.java


public class Test
{

    public Test()
    {
    }

    public static void main(String args[])
        throws Exception
    {
        String s = "Hello ";
        String s1 = "EveryBody";
        s = (new StringBuilder()).append(s).append(s1).toString();
    }
}

You'll see two things:
1) the variable names are changed. That's because local variables are not stored in the compiled byte code.
2) the += is indeed replaced by the creation of a new empty StringBuilder, to which then both Strings are appended, after which it's toString() method is called.

Now about whether or not using a StringBuilder is more efficient, it depends:
1) if you only append two constants or literals, using + is more efficient. For instance, if I write "Hello " + "Everybody", the compiler will use String literal "Hello Everybody". The same holds for final variables for which the value can already be known by the compiler.

final String str1 = "Hello "; // because of final, the compiler knows the value is "Hello "
final String str2 = "Everybody"; // likewise
final String str3 = str1; // because the compiler knows the value of str1 is always "Hello ", it knows that the value of str3 will be as well
String s = str3 + str2; // the compiler turns this into s = "Hello Everybody";

2) if you append only two Strings, String's concat method is actually preferred, because you don't create the intermediate StringBuilder but immediately create a String with the contents of the two source Strings.

String str1 = "Hello ";
String str2 = "EveryBody";
str1 = str1.concat(str2); // because there are only two Strings to concatenate

3) if you only have one statement that creates the String, using + is perfectly fine. The compiler may change the code to use something even better in the future.

String str1 = "Hello ";
String str2 = "Everybody";
String str3 = ", how are you doing?";
String str4 = str1 + str2 + str3;

4) if you add to the Strings conditionally (with an if) or in a loop, an explicit StringBuilder is usually the best choice.

StringBuilder sb = new StringBuilder();
sb.append("Hello Everybody");
if (greet)
{
    sb.append(", how are you doing?");
}
for (int i = 0; i < 3; i++)
{
    sb.append("!");
}

One final word on efficiency: if the StringBuilder's capacity needs to be increased a lot, it may loose a lot of its efficiency. If possible, specify the expected total capacity when creating it: new StringBuilder(expectedCapacity).

[Mohamed Sanaulla]

Thanks Rob for an informative explanation.

[Campbell Ritchie]

Welcome to the Ranch zhiqiang zhang

[Rob Spoor]

You're welcome

By the way, you don't see concat a lot. That's because using + is still easier to write, and it also automatically handles type conversion from anything to String. I can't remember ever having used concat.

[zhiqiang zhang]

thank all of you ,i learn a lot ,thank for Rob Spoor's patience