Clearing a StringBuilder or StringBuffer

1. Overview

In this tutorial, we’ll present a couple of methods to clear a StringBuilder or StringBuffer, then elaborate on them.

2. Clearing a StringBuilder

2.1. Use the setLength Method

The method setLength updates the inner length of the StringBuilder. All entries after the length are then ignored when manipulating the StringBuilder. Thus, calling it with 0 clears its content:

@Test
void whenSetLengthToZero_ThenStringBuilderIsCleared() {
    StringBuilder stringBuilder = new StringBuilder();
    stringBuilder.append("Hello World");
    int initialCapacity = stringBuilder.capacity();
    stringBuilder.setLength(0);
    assertEquals("", stringBuilder.toString());
    assertEquals(initialCapacity, stringBuilder.capacity();
}

Let’s note that after we call the setLength method, the capacity of the StringBuilder remains the same.

2.2. Use the delete Method

The delete method uses System.arraycopy in the background. All indexes before the start index or after the end index are copied to the same StringBuilder.

Thus, if we call delete with a start index of 0 and an end index equal to the length of the StringBuilder, we’ll copy:

• The indexes before 0: there are none.
• The indexes after stringBuilder.length(): there are none.

As a result, all the content of the StringBuilder is removed:

@Test
void whenDeleteAll_ThenStringBuilderIsCleared() {
    StringBuilder stringBuilder = new StringBuilder();
    stringBuilder.append("Hello World");
    int initialCapacity = stringBuilder.capacity();
    stringBuilder.delete(0, stringBuilder.length());
    assertEquals("", stringBuilder.toString());
    assertEquals(initialCapacity, stringBuilder.capacity();
}

As with the setLength method, the object capacity remains the same after the deletion of its content. Let’s also underline that no new object creation was involved during this process.

3. Clearing a StringBuffer

All the methods that work for StringBuilder work in the same way with StringBuffer. Furthermore, all the remarks on the capacity of the objects remain valid.
Let’s showcase an example with the setLength method:

@Test
void whenSetLengthToZero_ThenStringBufferIsCleared() {
    StringBuffer stringBuffer = new StringBuffer();
    stringBuffer.append("Hello World");
    int initialCapacity = stringBuffer.capacity();
    stringBuffer.setLength(0);
    assertEquals("", stringBuffer.toString());
    assertEquals(initialCapacity, stringBuffer.capacity();
}

It is also possible to use the delete method:

@Test
void whenDeleteAll_ThenStringBufferIsCleared() {
    StringBuffer stringBuffer = new StringBuffer();
    stringBuffer.append("Hello World");
    int initialCapacity = stringBuffer.capacity();
    stringBuffer.delete(0, stringBuffer.length());
    assertEquals("", stringBuffer.toString());
    assertEquals(initialCapacity, stringBuffer.capacity();
}

4. Performance

Let’s do a quick performance comparison with JMH. Let’s compare each of the three methods for our StringBuilder:

@State(Scope.Benchmark)
public static class MyState {
    final String HELLO = "Hello World";
    final StringBuilder sb = new StringBuilder().append(HELLO);
}

@Benchmark
public void evaluateSetLength(Blackhole blackhole, MyState state) {
    state.sb.setLength(0);
    blackhole.consume(state.sb.toString());
}

@Benchmark
public void evaluateDelete(Blackhole blackhole, MyState state) {
    state.sb.delete(0, state.sb.length());
    blackhole.consume(state.sb.toString());
}

We’ve measured the number of operations by second. This benchmark leads to the following result:

Benchmark                  Mode   Cnt         Score          Error  Units
evaluateDelete             thrpt   25  67943684.417 ± 18116791.770  ops/s
evaluateSetLength          thrpt   25  37310891.158 ±   994382.978  ops/s

As we can see, delete seems to be the less time-consuming method of the two by almost a factor of 2.

5. Conclusion

In this article, we’ve detailed three methods to clear a StringBuilder or a StringBuffer.

As always, the code is available over on GitHub.