Appending Strings - Java Tutorials

Appending Strings

In java, the two main ways for appending string at the end are :

• First method is using += operator.
• Second method is using append()  method.

In this section, we will compare the performance of these two ways by taking example. We will take three tasks to compare performance. For this we also crate a separate timer class to measure the time taken.

First we will create a timer class to record the time taken. Given below the timer Class:

/**
* Class used to measure the time that a task takes to execute.
* The method "time" prints out how long it took and returns
* the time.
*/
public class Timer {
/**
* This method runs the Runnable and measures how long it takes
* @param r is the Runnable for the task that we want to measure
* @return the time it took to execute this task
*/
public static long time(Runnable r) {
long time = -System.currentTimeMillis();
r.run();
time += System.currentTimeMillis();
System.out.println("Took " + time + "ms");
return time;
}
}

Performance Comparison

In first task, we will append string using += . And in second task,  we will create a StringBuffer  and calls the append function which is the function of StringBuffer. In third task, we will create a StringBuffer of accurate size and after that we append. Given below the example:

public class StringAppendDiff {
public static void main(String[] args) {
System.out.println("String += 10000 additions");
Timer.time(new Runnable() {
public void run() {
String s = "";
for(int i = 0; i < 10000; i++) {
s += i;
}
// we have to use "s" in some way, otherwise a clever
// compiler would optimise it away. Not that I have
// any such compiler, but just in case ;-)
System.out.println("Length = " + s.length());
}
});

System.out.println(
"StringBuffer 300 * 10000 additions initial size wrong");
Timer.time(new Runnable() {
public void run() {
StringBuffer sb = new StringBuffer();
for(int i = 0; i < (300 * 10000); i++) {
sb.append(i);
}
String s = sb.toString();
System.out.println("Length = " + s.length());
}
});

System.out.println(
"StringBuffer 300 * 10000 additions initial size right");
Timer.time(new Runnable() {
public void run() {
StringBuffer sb = new StringBuffer(19888890);
for(int i = 0; i < (300 * 10000); i++) {
sb.append(i);
}
String s = sb.toString();
System.out.println("Length = " + s.length());
}
});
}
}

Output

Conclusion

From this we can conclude that StringBuffer has about 300 times faster in speed than using +=.  Also third task concludes that if we set the correct initial size of the StringBuffer, it only takes 1562ms instead of 2254ms. This is because when the StringBuffer  size increase implicitly, it gets doubled in size, which left extra unusable size. To overcome this wastage, you can define correct initial size of the String Buffer.