String performance test
I found string plus using StringBuffer but not StringBuilder when I was implementing my simple JVM. So I wrote some test case to test it. But it became using StringBuilder but not StringBuffer. So I guess whether use StringBuffer or StringBuilder is depend on compiler option. Any way I got a performance test result between using StringBuffer and StringBuilder. The result is that using StringBuilder is much faster than using StringBuffer . The time consume ratio between using StringBuilder and StringBuffer is about 2:3 .
Here comes my test code.
public class StringAddTest implements Runnable {
static long time1 = 0;
static long time2 = 0;
static long time3 = 0;
/**
* @param args
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException {
Thread thread1 = new Thread(new StringAddTest());
Thread thread2 = new Thread(new StringAddTest());
Thread thread3 = new Thread(new StringAddTest());
Thread thread4 = new Thread(new StringAddTest());
thread1.start();
thread2.start();
thread3.start();
thread4.start();
thread1.join();
thread2.join();
thread3.join();
thread4.join();
System.out.println("stringAdd1 spent " + time1 + " ms");
System.out.println("stringAdd2 spent " + time2 + " ms");
System.out.println("stringAdd3 spent " + time3 + " ms");
}
public static void stringAdd1(int n) {
long start = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
String a = "First";
String b = "Second";
String x = a + b + i;
}
long spent = System.currentTimeMillis() - start;
time1 += spent;
System.out.println("TestStringAdd1 spent " + spent + "ms");
}
public static void stringAdd2(int n) {
long start = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
String a = "First";
String b = "Second";
String x = new StringBuilder().append(a).append(b).append(i).toString();
}
long spent = System.currentTimeMillis() - start;
time2 += spent;
System.out.println("TestStringAdd2 spent " + spent + "ms");
}
public static void stringAdd3(int n) {
long start = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
String a = "First";
String b = "Second";
String x = new StringBuffer().append(a).append(b).append(i).toString();
}
long spent = System.currentTimeMillis() - start;
time3 += spent;
System.out.println("TestStringAdd3 spent " + spent + "ms");
}
public static void StringAddx()
{
String orignal = "Original";
orignal += "What";
}
public void run() {
int n = 1000 * 1000;
for (int i = 0; i < 10; i++) {
stringAdd1(n);
stringAdd2(n);
stringAdd3(n);
stringAdd3(n);
stringAdd2(n);
stringAdd1(n);
stringAdd2(n);
stringAdd3(n);
stringAdd1(n);
}
}
}
I ran it for several times. The results are closed to each other. One test result on my machine is
DirectStringAdd spent 138057 ms StringBuilderAppend spent 152647 ms StringBufferAppend spent 256578 ms
From the result can see that use direct string plus is a little faster than use StringBuilder. I was trying to figure it out by analyze the binary code generated and add two more test case. Here comes my new test code.
public class StringAddTest implements Runnable {
static long timeDirectStringAdd = 0;
static long timeStringBuilderAppend = 0;
static long timeStringBufferAppend = 0;
static long timeStringBuilderAppend2 = 0;
static long timeStringBufferAppend2 = 0;
/**
* @param args
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException {
Thread thread1 = new Thread(new StringAddTest());
Thread thread2 = new Thread(new StringAddTest());
Thread thread3 = new Thread(new StringAddTest());
Thread thread4 = new Thread(new StringAddTest());
thread1.start();
thread2.start();
thread3.start();
thread4.start();
thread1.join();
thread2.join();
thread3.join();
thread4.join();
System.out.println("DirectStringAdd spent " + timeDirectStringAdd + " ms");
System.out.println("StringBuilderAppend spent " + timeStringBuilderAppend + " ms");
System.out.println("StringBufferAppend spent " + timeStringBufferAppend + " ms");
System.out.println("StringBuilderAppend2 spent " + timeStringBuilderAppend2 + " ms");
System.out.println("StringBufferAppend2 spent " + timeStringBufferAppend2 + " ms");
}
public static void directStringAdd(int n) {
long start = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
String a = "First";
String b = "Second";
String x = a + b + i;
}
long spent = System.currentTimeMillis() - start;
timeDirectStringAdd += spent;
System.out.println("DirectStringAdd spent " + spent + "ms");
}
public static void stringBuilderAppend(int n) {
long start = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
String a = "First";
String b = "Second";
String x = new StringBuilder().append(a).append(b).append(i).toString();
}
long spent = System.currentTimeMillis() - start;
timeStringBuilderAppend += spent;
System.out.println("StringBufferAppend spent " + spent + "ms");
}
public static void stringBuilderAppend2(int n) {
long start = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
String a = "First";
String b = "Second";
String x = new StringBuilder(a).append(b).append(i).toString();
}
long spent = System.currentTimeMillis() - start;
timeStringBuilderAppend2 += spent;
System.out.println("StringBufferAppend2 spent " + spent + "ms");
}
public static void stringBufferAppend(int n) {
long start = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
String a = "First";
String b = "Second";
String x = new StringBuffer().append(a).append(b).append(i).toString();
}
long spent = System.currentTimeMillis() - start;
timeStringBufferAppend += spent;
System.out.println("StringBuilderAppend spent " + spent + "ms");
}
public static void stringBufferAppend2(int n) {
long start = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
String a = "First";
String b = "Second";
String x = new StringBuffer(a).append(b).append(i).toString();
}
long spent = System.currentTimeMillis() - start;
timeStringBufferAppend2 += spent;
System.out.println("StringBuilderAppend2 spent " + spent + "ms");
}
public static void StringAddx()
{
String orignal = "Original";
orignal += "What";
}
public void run() {
int n = 1000 * 1000;
for (int i = 0; i < 5; i++) {
directStringAdd(n);
stringBuilderAppend(n);
stringBuilderAppend2(n);
stringBufferAppend2(n);
stringBufferAppend(n);
stringBufferAppend(n);
stringBufferAppend2(n);
stringBuilderAppend2(n);
stringBuilderAppend(n);
directStringAdd(n);
stringBuilderAppend(n);
stringBuilderAppend2(n);
stringBufferAppend2(n);
stringBufferAppend(n);
directStringAdd(n);
}
}
}
And the test result is like
DirectStringAdd spent 67991 ms StringBuilderAppend spent 76464 ms StringBufferAppend spent 120135 ms StringBuilderAppend2 spent 65543 ms StringBufferAppend2 spent 118215 ms
I picked up the binary code snippet from the test case and list it in following table.
1:
String x = a + b + i;
17 new java.lang.StringBuilder [56]
20 dup
21 aload 4 [a]
23 invokestatic java.lang.String.valueOf(java.lang.Object) : java.lang.String [106]
26 invokespecial java.lang.StringBuilder(java.lang.String) [60]
2:
String x = new StringBuilder().append(a).append(b).append(i).toString();
17 new java.lang.StringBuilder [56]
20 dup
21 invokespecial java.lang.StringBuilder() [125]
24 aload 4 [a]
26 invokevirtual java.lang.StringBuilder.append(java.lang.String) : java.lang.StringBuilder [69]
3:
String x = new StringBuilder(a).append(b).append(i).toString();
17 new java.lang.StringBuilder [56]
20 dup
21 aload 4 [a]
23 invokespecial java.lang.StringBuilder(java.lang.String) [60]
1: String.valueOf(String) only cost a little. It only need return the reference.
2: append need a string copy. It cost quite much.
3: it even don't need valueOf. So it is the fastest.