Java String Concatenation Performance

Hello everyone!
In the previous post, I showed you how to create a JMH project with Gradle. In this article, I will compare the performance of different string concatenation methods in Java.

At the end of that post, I shared a report as follows:

This is the result of comparing the performance of different string concatenation approaches in Java.

Now, I will explain why we get these results.

1. String Plus (Addition Operator)

This is the most common way to concatenate strings in Java. For example:

1
2

String str = "Hello ";
str += "world";

Line 1 creates a String object with the value "Hello", line 2 creates another String with the value "Hello world". However, before creating a new String, Java checks whether that string literal is already in the String Pool. If it is, Java reuses the string from the pool instead of allocating a new one; otherwise, it creates a new String and adds it to the pool (I will write a dedicated post with more details).

As shown in the benchmark results, this method performs well for x1 and x5 iterations, but is the worst for x1000. This is because with fewer concatenations Java only creates a few objects, but with high iteration counts, repeated object allocations severely degrade performance.

2. String Concat

Compared to String Plus, the performance difference is substantial. Why is there such a big difference? Let’s take a look at the source code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public String concat(String str) {
    int otherLen = str.length();
    if (otherLen == 0) {
        return this;
    }
    int len = value.length;
    char buf[] = Arrays.copyOf(value, len + otherLen);
    str.getChars(buf, len);
    return new String(buf, true);
}

The code above creates a new String by copying the char arrays of both strings directly. This bypasses the String Pool mechanism and saves significant overhead.

3. String Builder

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public AbstractStringBuilder append(String str) {
    if (str == null)
        return appendNull();
    int len = str.length();
    ensureCapacityInternal(count + len);
    str.getChars(0, len, value, count);
    count += len;
    return this;
}

private void ensureCapacityInternal(int minimumCapacity) {
    // overflow-conscious code
    if (minimumCapacity - value.length > 0) {
        value = Arrays.copyOf(value,
                newCapacity(minimumCapacity));
    }
}

Above are the two methods invoked when we call the append() method. As we can see, the principle is similar to concat, except that it modifies an internal buffer and returns AbstractStringBuilder instead of allocating a new String on every append.

4. String Buffer

StringBuffer is the thread-safe version of StringBuilder, so being slower is expected. We can look at the code below to see how thread safety is implemented:

1
2
3
4
5

public synchronized StringBuffer append(String str) {
    toStringCache = null;
    super.append(str);
    return this;
}

The synchronized keyword ensures that only one thread can execute this method at any given moment, guaranteeing thread safety at the cost of synchronization overhead.

5. String Join

Conclusion

If there are any other string concatenation methods you’d like to see benchmarked, feel free to comment or open a merge request so I can update the post! ;))