String concatenation vs. StringBuilder.

[stchman]

Indeed the StringBuilder class is FAR faster for VERY LONG Strings.

I have created code to time the two below:

public class StringStuff {
    public static void main( String[] args ) {
        StringStuff m = new StringStuff();
        m.addStrings();
    }
    
    public void addStrings() {    
        int i, j;
        int numberStrings = 100000;
        long initTime, finalTime;
        double totalTime;
        
        System.out.println( "Using String concatenation" );
        String str = "Test";
        // set initial time
        initTime = System.currentTimeMillis();
        for( i = 0; i < numberStrings; i++ ) {
            str += "A";
        }
        // set final time
        finalTime = System.currentTimeMillis();
        totalTime = (double)( finalTime - initTime ) / 1000.0;
        System.out.printf( "Total time to concatenate %d Strings using String concatenation is %f sec\n", i, totalTime );
        
        System.out.println( "Using StringBuilder class" );
        String stp = "Test";
        StringBuilder sb = new StringBuilder();
        stp = sb.append( stp ).toString();
        // set initial time
        initTime = System.currentTimeMillis();
        for( j = 0; j < numberStrings; j++ ) {
            stp = sb.append( "A" ).toString();
        }
        finalTime = System.currentTimeMillis();
        totalTime = (double)( finalTime - initTime ) / 1000.0;
        System.out.printf( "Total time to concatenate %d Strings using StringBuilder class is %f sec\n", i, totalTime );        
    }    
}

For 100000 Strings, the times on my PC are as follows:
String concatenation = 21.5sec
StringBuilder = 5.6sec

With all this being said, I only started to see time differences when I got to 15000 or better. Even at 15K the times were as follows:
String concatenation = 0.48sec
StringBuilder = 0.13sec

[camickr]

Those timings don't include the extra work required by the JVM. For example, at some point in time all those extra String will need to be garbage collected.

Also, your StringBuffer code test doesn't look fair because you a creating a new String every time. There is no need for the toString() to be invoked during every append() operation. The toString() method should only be invoked after the loop has finished executing.

The general rule is to write readable code and only worry about performance when it is an issue. For my two cents I like the append() method anyway.

[stchman]

Excellent, I amended the program as follows:

public class StringStuff {
    public static void main( String[] args ) {
        StringStuff m = new StringStuff();
        m.addStrings();
        System.out.println( args.length );
    }
    
    public void addStrings() {    
        int i, j;
        int numberStrings = 100000;
        long initTime, finalTime;
        double totalTime;
        
        System.out.println( "Using String concatenation" );
        String str = "Test";
        // set initial time
        initTime = System.currentTimeMillis();
        for( i = 0; i < numberStrings; i++ ) {
            str += "A";
        }
        // set final time
        finalTime = System.currentTimeMillis();
        totalTime = (double)( finalTime - initTime ) / 1000.0;
        System.out.printf( "Total time to concatenate %d Strings using String concatenation is %f sec\n", i, totalTime );
        
        System.out.println( "Using StringBuilder class" );
        String stp = "Test";
        StringBuilder sb = new StringBuilder();
        stp = sb.append( stp ).toString();
        // set initial time
        initTime = System.currentTimeMillis();
        for( j = 0; j < numberStrings; j++ ) {
            sb.append( "A" );
        }
        stp = sb.toString();
        finalTime = System.currentTimeMillis();
        totalTime = (double)( finalTime - initTime ) / 1000.0;
        System.out.printf( "Total time to concatenate %d Strings using StringBuilder class is %f sec\n", i, totalTime );        
    }    
}

Using String concatenation still took ~21 secs, but the StringBuilder was near instantaneous.

Thanks!!!!

[Tolls]

It's worth bearing in mind that single statement concatenation should be the same as, under the hood, the compiler uses a StringBuilder to do the work.
So the following two should be pretty similar (and the former is easier to read):

String oneLine = "This is my String. " + anotherString + andAnother + " some more text " + lastBit;
...
String theOtherLine = new StringBuilder().append("This is my String. ").append(anotherString).append(andAnother).append(" some more text ").append(lastBit).toString();

(Hopefully that'll compile...)

[JosAH]

It's worth bearing in mind that single statement concatenation should be the same as, under the hood, the compiler uses a StringBuilder to do the work.
So the following two should be pretty similar (and the former is easier to read):

String oneLine = "This is my String. " + anotherString + andAnother + " some more text " + lastBit;
...
String theOtherLine = new StringBuilder().append("This is my String. ").append(anotherString).append(andAnother).append(" some more text ").append(lastBit).toString();

(Hopefully that'll compile...)

It does ;-) Also note that the following variation of your code:

	  String oneLine = "This is my String. "; 
		  oneLine+= anotherString; 
		  oneLine+= andAnother;
		  oneLine+= " some more text ";
		  oneLine+= lastBit;

... creates a new StringBuilder for every single String catenation operation.

kind regards,

Jos

[Tolls]

Oh yes.
That's one of the things those code checkers tend to throw up.