String vs. StringBuilder vs. StringBuffer

[stchman]

Hello all. I recently was doing a project that did MASSIVE amounts of String concatenation. After much reading and trial and error it is painfully obvious that the String class is not the way to go.

The String.concat( String ) is indeed faster than the += operator. When in doubt, use either the StringBuffer(thread safe) or StringBuilder(not thread safe but faster than StringBuffer)

Example code:

public class StringTimer {
    public static void main( String[] args ) {
        StringTimer m = new StringTimer();
        m.stringTimer();
    }

    public void stringTimer() {
        double startTime = 0, endTime = 0, totalTime = 0;
        int i = 0;
        
        int numStrings = 70000;        
        
        // String
        String str = new String();
        
        startTime = (double)System.currentTimeMillis();
        for( i = 0; i < numStrings; i++ ){
            //str+="Hello"; // worse than String.concat( String )
            str = str.concat( "Hello" );
        }
        endTime = (double)System.currentTimeMillis();
        
        totalTime = ( endTime - startTime ) / 1000.0;
        
        System.out.println( totalTime + " secs to concatenate " + numStrings + " Strings together using String.concat( String )." );
  
        
        // StringBuilder
        StringBuilder sb = new StringBuilder();
        
        startTime = (double)System.currentTimeMillis();
        for( i = 0; i < numStrings; i++ ){
            sb = sb.append( "Hello" );
        }
        endTime = (double)System.currentTimeMillis();
        
        totalTime = ( endTime - startTime ) / 1000.0;
        
        System.out.println( totalTime + " secs to concatenate " + numStrings + " Strings together using StringBuilder.append( String )." );

        
        // StringBuffer
        StringBuffer sbuf = new StringBuffer();
        
        startTime = (double)System.currentTimeMillis();
        for( i = 0; i < numStrings; i++ ){
            sbuf = sbuf.append( "Hello" );
        }
        endTime = (double)System.currentTimeMillis();
        
        totalTime = ( endTime - startTime ) / 1000.0;
        
        System.out.println( totalTime + " secs to concatenate " + numStrings + " Strings together using StringBuffer.append( String )." );
    }
}

This is the output I get:

>javac StringTimer.java

>java StringTimer
15.75 secs to concatenate 70000 Strings together using String.concat( String ).
0.0 secs to concatenate 70000 Strings together using StringBuilder.append( String ).
0.0 secs to concatenate 70000 Strings together using StringBuffer.append( String ).

[pbrockway2]

What do the times for += look like?

I'm no expert about timing programs like this (all I know is that they can be trickier than they look) but often you see the "experiment" repeated multiple times within a loop because the first time around can have significantly different times. Hard to argue with anything vs 0 though! Perhaps you could report the times in ms or increase 70000.

[pbrockway2]

Also a little point about StringBuilder being faster than StringBuffer: I half remember seeing somewhere that the hotspot compiler is clever enough to figure out if the thread safe version is unnecessary and use the faster one at runtime.

[stchman]

What do the times for += look like?

I'm no expert about timing programs like this (all I know is that they can be trickier than they look) but often you see the "experiment" repeated multiple times within a loop because the first time around can have significantly different times. Hard to argue with anything vs 0 though! Perhaps you could report the times in ms or increase 70000.

Here are the values in ms.

15812.0 ms to concatenate 70000 Strings together using String.concat( String ).
0.0 ms to concatenate 70000 Strings together using StringBuilder.append( String ).
0.0 ms to concatenate 70000 Strings together using StringBuffer.append( String ).

[pbrockway2]

Thanks. I just had a look and it seems you need about 1/2 million strings before you can see StringBuilder/Buffer taking any time at all.

[stchman]

What do the times for += look like?

I'm no expert about timing programs like this (all I know is that they can be trickier than they look) but often you see the "experiment" repeated multiple times within a loop because the first time around can have significantly different times. Hard to argue with anything vs 0 though! Perhaps you could report the times in ms or increase 70000.

The += operator took about 3X longer than the String.concat() method.