Java - String.format(), Formatter.format(), StringUtils performance

I’m re-writing a module I wrote a few years ago to improve performance and meet the customer requirements – we’re talking about up to 200.000 XML messages per day, with 90 messages / sec at peak times, to get an idea about how many times these methods are being called, every bit of wasted time / resources is considerably multiplied.

I’ve already done various things like reducing number of operations and waste in objects being created, but now I’m down to lower level inner parts.

Been using TreeMaps to cache some search data and avoid trips to the database, and the first implementation was using multi-keyed objects (containing multiple string keys) and comparator classes; although it was nice using typed objects as map keys it was on the other hand a bit wasteful and slower. I’ve since changed those to plain “packed” string keys, to reduce the number of objects being created, with the disadvantage of loosing the typing in the process, but it does run faster.

I did mention in the previous post that I’ve used recently VisualVM to sample application activity and spotted that these little pack() methods took somewhat an unusual amount of time - still looking in reducing the number of operations, but I said hey let’s see if they can be improved with little effort.

What the code does is fairly straight forward, takes multiple strings (“a” - “b” - “c”) and packs them all together into a padded, upper-cased string key, keeping the field lengths as in the database. That to ensure the resulting keys can be ordered and searched using get() and subMap() methods.

Although been using Apache Commons Lang packages for years now and if using Maven in Eclipse you can always look at the sources to see how exactly they do things, I chose String.format() as it should be faster, right? Well, apparently I wasn’t right. Started writing a simple performance test to compare with Formatter and then I thought lets add a StringUtils implementation and see how it fares…

First, it just seems that String.format() was the slowest and StringUtils was the fastest! And second, String.format() is not so bad in Java 7 (although it might not seem so as the tests seem to run in different order).

	Java HotSpot 6 (1.6.0_31 x64) Win 2008 R2 SP1 x64	Java HotSpot 7 (1.7.0_03 x64) Win 2008 R2 SP1 x64
String.format()	110 ms	63 ms
Formatter.format()	47 ms	94 ms
StringUtils	15 ms	16 ms

I repeated the tests a few times and although obviously timings change slightly between runs, but StringUtils is consistently a few times faster. Obviously the test doesn’t measure in any way the garbage collection costs and have no idea how it will fare in the application performance tests just yet, but does promise a slight improvement with little code changes.

Posting the code for review, in case I’m missing something – using junit-4.10.jar and commons-lang-2.6.jar (http://search.maven.org/).

import java.util.Formatter;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.StopWatch;
import org.junit.BeforeClass;
import org.junit.Test;

public class PerfTest {
  /**
   * Constants
   */
  private int MAX_COUNT = 1000;
  
  /**
   * 
   */
  @BeforeClass
  public static void javaInfo() {
      System.out.println(String.format("java version \"%s\"", System.getProperty("java.version")));
      System.out.println(String.format("%s (build %s)",       System.getProperty("java.vm.name"), System.getProperty("java.vm.version")));
      System.out.println();
  }
  
  /**
   * String.format() test
   */
  @Test
  public void test1() {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    
    String result = StringUtils.EMPTY;
    for (int i = 0, n = MAX_COUNT; i < n; i++) {
      result = String.format("|%-5S|%-10S|%-15S|", "a", "bb", "ccc");
    }
    
    stopWatch.stop();
    System.out.println("String.format()    = " + result);
    System.out.println("Execution time     = " + stopWatch.toString());
    System.out.println();
  }
  
  /**
   * Formatter.format() test
   */
  @Test
  public void test2() {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    
    String result = StringUtils.EMPTY;
    for (int i = 0, n = MAX_COUNT; i < n; i++) {
      Formatter formatter = new Formatter();
      result = formatter.format("|%1$-5S|%2$-10S|%3$-15S|", "a", "bb", "ccc").toString();
    }
    stopWatch.stop();
    System.out.println("Formatter.format() = " + result);
    System.out.println("Execution time     = " + stopWatch.toString());
    System.out.println();
  }
  
  /**
   * StringUtils test
   */
  @Test
  public void test3() {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    
    String result = StringUtils.EMPTY;
    for (int i = 0, n = MAX_COUNT; i < n; i++) {
      result = '|' + StringUtils.rightPad(StringUtils.upperCase("a"),    5)
             + '|' + StringUtils.rightPad(StringUtils.upperCase("bb"),  10)
             + '|' + StringUtils.rightPad(StringUtils.upperCase("ccc"), 15)
             + '|';
    }
    stopWatch.stop();
    System.out.println("StringUtils        = " + result);
    System.out.println("Execution time     = " + stopWatch.toString());
    System.out.println();
  }
}