Clearing a StringBuilder or StringBuffer

Last updated: January 27, 2024

Written by: baeldung

Reviewed by: Sam Millington

Java String

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

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.