String Q

[Kedar Dravid]

Is the += opertaor overloaded for the String class?

[S.L.Narayanan]

Yes...Obviously...

[Raghu Shree]

Java provides special support for the String concatenation opeartor (+). String concatenation is implemented through the StringBuffer class and its append method.

if u concat two string like X= "Raj" + " Mohan";. Internally it creates a new string buffer and append each string, and then convert the contents of the string buffer to string. for example x = new StringBuffer().append("Raj").append(" Mohan");.

x="raj";
x+="mohan";

. += operator is overloaded and execute like binary + operator.

[Tony Morris]

if u concat two string like X= "Raj" + " Mohan";. Internally it creates a new string buffer and append each string

No it doesn't.
The two operands are concatenated at compile-time to form a single literal String. A StringBuffer is never used. This is because both operands are constants (JLS 15.28).
Since 1.5, runtime concatenation is performed using a StringBuilder, not a StringBuffer.

[Raghu Shree]

Hi Tony
I am confused. Refer the following url.
http://java.sun.com/j2se/1.4.2/docs/api/java/lang/String.html
http://java.sun.com/j2se/1.4.2/docs/api/java/lang/StringBuffer.html

[Joe Sondow]

Raghu, in 1.4 using a StringBuffer for the implementation of + is optional for the compiler writer, as described in the JLS at JLS 15.18.1.2

15.18.1.2 Optimization of String Concatenation

An implementation may choose to perform conversion and concatenation in one step to avoid creating and then discarding an intermediate String object. 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.

For primitive types, an implementation may also optimize away the creation of a wrapper object by converting directly from a primitive type to a string.

[Jim Yingst]

Well, using a StringBuffer (or now in 1.5, StringBuilder) is optional, yes. But that's not the main point of Tony's statement. He's pointing out that since both "Raj" and " Mohan" are compile-time constants, the expression

"Raj" + " Mohan"

is also a compile-time constant, and so it will be evaluated at compile time so that the class file contains a single constant, "Rajjava Mohan", rather than two separate ones. So at runtime, there's nothing to concatenate with a StringBuffer or StringBuilder; it's already been done.