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:
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.
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. As always, the example code is available over on GitHub.
