Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

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.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

1. Overview

String and StringBuffer are two important classes used while working with strings in Java. In simple words, a string is a sequence of characters. For example, “java”, “spring” and so on.

The main difference between a String and a StringBuffer is that a String is immutable, whereas a StringBuffer is mutable and thread-safe.

In this tutorial, let’s compare String and StringBuffer classes and understand the similarities and differences between the two. 

2. String 

The String class represents character strings. Java implements all string literals, such as “baeldung”, as an instance of this class.

Let’s create a String literal:

String str = "baeldung";

Let’s also create a String object:

Char data[] = {‘b’, ‘a’, ‘e’, ‘l’, ‘d’, ‘u’, ‘n’, ‘g’};

String str = new String(data);

We can also do the following:

String str = new String(“baeldung”);

Strings are constants and immutable, making them shareable.

2.1. String Literal vs. String Object

String literals are immutable strings that are stored inside a special memory space called a string pool inside the heap memory. Java doesn’t allocate a new memory space for string literals having the same value. Instead, it uses the string interning.

In contrast, the JVM allocates separate memory in the heap, outside the string pool, for a newly created String object.

Thus, each string object refers to a different memory address, even though both may have the same value. Note that a String literal is still a String object. However, the reverse is not true.

2.2. String Pool

String literals are stored in a reserved memory area of the Java heap called the String Pool.

2.3. String Interning

String interning is an optimization technique the compiler uses to avoid redundant memory allocation. It avoids allocating memory for a new string literal if a similar value already exists. Instead, it works with the existing copy:

string memory allocation

Common operations on String include concatenation, comparison, and searching. The Java language also provides special support for the string concatenation operator (+) and for the conversion of other objects to strings. It is worth noting that String internally uses StringBuffer and its append method to perform concatenation:

String str = "String"; 
str = str.concat("Buffer");
assertThat(str).isEqualTo("StringBuffer");
assertThat(str.indexOf("Buffer")).isEqualTo(6);

3. StringBuffer

A StringBuffer is a sequence of characters just like a String. However, unlike a String, it’s mutable. We can modify a StringBuffer through method calls such as append() and insert(). The append method adds the character sequence at the end of the StringBuffer, while the insert method inserts a sequence of characters at a specified index. The StringBuffer class has both methods overloaded to handle any object. The object is converted to its string representation before appended or inserted into the StringBuffer:

StringBuffer sBuf = new StringBuffer("String");
sBuf.append("Buffer");
assertThat(sBuf).isEqualToIgnoringCase("StringBuffer");
sBuf.insert(0, "String vs ");
assertThat(sBuf).isEqualToIgnoringCase("String vs StringBuffer");

StringBuffer is thread-safe and can work in a multi-threaded environment. The synchronization ensures the correct order of execution of all statements and avoids data-races situations.

However, Java 1.5 introduced StringBuilder as an alternative to StringBuffer for performance optimization in situations where thread safety is not a concern. It’s recommended to use StringBuilder in places where the string buffer is being used by a single thread, as it will be faster under most implementations.

4. Performance Comparison

String and StringBuffer have similar performance. However, string manipulation is faster with StringBuffer than String because String requires the creation of a new object each time, and all changes happen to the new String, leading to more time and memory consumption.

Let’s do a quick micro-benchmark with JMH to compare the concatenation performance of String and StringBuffer:

@BenchmarkMode(Mode.SingleShotTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Measurement(batchSize = 100000, iterations = 10)
@Warmup(batchSize = 100000, iterations = 10)
@State(Scope.Thread)
public class ComparePerformance {

    String strInitial = "springframework";
    String strFinal = "";
    String replacement = "java-";

    @Benchmark
    public String benchmarkStringConcatenation() {
        strFinal = "";
        strFinal += strInitial;
        return strFinal;
    }

    @Benchmark
    public StringBuffer benchmarkStringBufferConcatenation() {
        StringBuffer stringBuffer = new StringBuffer(strFinal);
        stringBuffer.append(strInitial);
        return stringBuffer;
    }
}
Benchmark                                              Mode  Cnt   Score    Error  Units
ComparePerformance.benchmarkStringBufferConcatenation    ss   10  16.047 ± 11.757  ms/op
ComparePerformance.benchmarkStringConcatenation          ss   10   3.492 ±  1.309  ms/op

5. Comparison Table

To summarise the differences:

String StringBuffer
A String is a sequence of characters and is immutable A StringBuffer is like a String but can be modified, i.e., it’s mutable
It can be shared easily due to its immutability It can be shared across synchronized threads only
Modification requires the creation of a new string Modification requires a call to certain methods
Modification is slow Modification is faster
It uses the string pool for storing data It uses heap memory

6. Conclusion

In this article, we compared String and StringBuffer classes.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

2 Comments
Oldest
Newest