Why didn't someone tell me?

Question

I have been following these forums for a little while now. I was looking at one that used a StringBuffer to build strings instead of ...
String out = "";
out += "Another String...".. etc. I decided I would do a test. I know this may be stupid but I never even considered using a buffer. I was thrown into the Java world and just went with things I learned along the way. I build the following test..
// Method to test wether or not Adding items to a string
// using a string buffer.add() is faster than creating
// it other ways....
import java.lang.StringBuffer;
import java.util.Random;
public class stringMethodTest {
  private static Random generator = new Random();
  private static String[] list = {
    "A","B","C","D","E","F","G","H","I","J","K","L","M","N","O",
    "P","Q","R","S","T","U","V","W","X","Y","Z",
    "0","1","2","3","4","5","6","7","8","9"};
  private static String give(){
    return
      list[generator.nextInt(list.length)] +
      list[generator.nextInt(list.length)] +
      list[generator.nextInt(list.length)] +
      list[generator.nextInt(list.length)] +
      list[generator.nextInt(list.length)] +
      list[generator.nextInt(list.length)] +
      list[generator.nextInt(list.length)];
  private static void buildUsingPlus(){
    // This will create a String using 4000 iterations
    // and a native String.
    String out = "";
    for(int a = 0; a < 4000; a++){
      out += give();
    System.out.println(out.length());
  private static void buildUsingPlusAndIntern(){
    // This will create a String using 4000 iterations
    // and a native String.
    String out = "";
    for(int a = 0; a < 4000; a++){
      out += give().intern();
    System.out.println(out.length());
  private static void buildUsingBuffer(){
    StringBuffer SB = new StringBuffer("");
    for(int a = 0; a < 4000; a++){
      SB.append(give());
    String out = SB.toString();
    System.out.println(out.length());
  private static void buildUsingBufferAndIntern(){
    StringBuffer SB = new StringBuffer("");
    for(int a = 0; a < 4000; a++){
      SB.append(give().intern());
    String out = SB.toString();
    System.out.println(out.length());
// main method just runs each of the above and times the execution.
// Putting all code in here truncated my post for some reason.I was amazed to see that when building a string using SbringBuffer.append(), with 4000 7 character words randomly generated, it took 0 ms compared to 7 sec or more in the +String way.  !!!!  OK.  Is this magic?  Can it really take 0 ms?  If all of my tests are true why don't more code examples I see around use StringBuffer?                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           

Answer 1

It's true... kinda. First off, the system time is only accurate to something like 1/20 of a second or so. That being said, StringBuffer is TREMENDOUSLY more efficient for that type of use than good ole' String.
In case you don't know why... Strings are immutable. They NEVER change. Everytime you want to append something to a String, you are actually creating a new instance of String. The following:String foo = "hello ";
foo += "world!";Does this: It creates an instance of String in the first line and gives it the value "hello ". In the second line, it does not just alter the value of foo. What it REALLY does is create a new instance of String with the value "hello world!" and assigns it to the reference foo. As you can see (especially with your test you did), this can cause BIG TIME performance problems if you're using a large set. Creating instances is expensive, plain and simple. (which is why they have StringBuffer at all).