Stranger and stranger!
sorry I can't answer your question Tom but it did prompt some investigation and experimentation on my part. Check it out.
This is from the source StringBuffer.java:
* String buffers are used by the compiler to implement the binary
* string concatenation operator <code>+</code>. For example, the code:
*
<blockquote><pre>
* x = "a" + 4 + "c"
* </pre></blockquote>
* is compiled to the equivalent of:
*
<blockquote><pre>
* x = new StringBuffer().append("a").append(4).append("c")
* .toString()
* </pre></blockquote>
and here is the implementation of the StringBuffer.append(String) method:
public synchronized StringBuffer append(String str) {
if (str == null) {
str = String.valueOf(str);
}
int len = str.length();
int newcount = count + len;
if (newcount > value.length)
expandCapacity(newcount);
str.getChars(0, len, value, count);
count = newcount;
return this;
}
I read this. So far so good and then I tried this:
class Try2 {
public static void main(String[] args) {
String sb1 = "good";
String sb2 = "";
System.out.println(sb1==(new StringBuffer().append("good").append("").toString()));
System.out.println(sb1=="good"+"");
}}
The first println contains what the documentation "in the source from Sun" says happens when you write what is contained in the second println. The two, according to Suns own docs should be equivalent but they aren't.
The output is, you guessed it: "false" and "true".
My best guess? The compiler is optimizing out the +"" in the second println since it cannot have any affect on the content. And since "good" is a String literal it is added to the classes String pool at compile time so that any String referenced by the class or an instance of the class with the contents "good" will get the same reference.
My second guess? The String is added to the classes string pool as above and there is some mechanism in the JVM itself that short circuits this kind of thing so that the +"" is never actually executed.
Unfortunately we don't have access to the code that implements the operators or the code for the compiler (or the time, patience and knowledge to go through them). I wonder if this code would run differently on a different compiler and/or differenct JVM? Anybody?
One more thing that may be of interest: If you insert the following code between the two println statements in the above code the output is "false" "true" "true":
System.out.println(sb1=="good".concat(""));
The source shows why this is the case:
From String.java
public String concat(String str) {
int otherLen = str.length();
if (otherLen == 0) {
return this;
}
//code snipped for brevity
}
Kinda interesting Huh?
.