Difference Between String and StringBuffer in Java

In Java, String is immutable, meaning we cannot change it once after created. Makes it less efficient for frequently modified text. Conversely, StringBuffer is mutable and thread-safe, ideal for strings undergoing frequent changes, especially in multi-threaded contexts.

String in Java

In Java, a string is a collection of characters. It is found in the java.lang package, it is one of the most popular classes in Java. One of the unique characteristics of a string is that, once generated, it cannot be altered. An entirely new String object is created for every change.

To read more StringBuffer in Java

Syntax:

Declaration of a String

Strings can be declared in two ways:

1. Using string literals (stored in String Constant Pool)

2. Using the new keyword (stored in heap memory)

Example 1: Concatenation

The code demonstrates that Java String objects are immutable; the concat(" World") method creates a new string, but since it is not assigned back to s, the original string remains unchanged and outputs "Hello".

Output:

Hello

Example 2: String Comparison

This code shows how string storage works in Java: s1 and s2 point to the same object in the String Constant Pool, so == returns true, while s3 creates a new heap object, making s1 == s3 false; however, equals() checks content, so it returns true.

Output:

true 
false 
true

Example 3: String Methods

This code demonstrates various String methods in Java: toUpperCase() and toLowerCase() change case, substring() extracts part of the string, charAt() retrieves a character at a given index, length() gives the total characters, indexOf() finds the position of a character, equals() compares content, and replace() substitutes characters.

Output:

PROGRAMMING 
Progra 
g 
11 
programming 
6 
true 
PrograXXing

StringBuffer in Java

A Java class called StringBuffer is used to construct mutable strings. In contrast to String, a StringBuffer object is modifiable after it is created. Because it is synchronized, multi-threaded programs can use it without bothering about thread safety.

To read more StringBuffer in Java

Syntax:

Declaration of a StringBuffer

Example 1: Append Operation

This code shows that StringBuffer is mutable in Java; the append(" World") method directly modifies the existing object's content, so printing sb outputs "Hello World".

Output:

Hello World 

Example 2: Insert and Delete

This code demonstrates StringBuffer mutability using insert() to add "Java " at index 6, temporarily modifying the string, and delete() to remove characters from index 6 to 11, restoring it back to "Programming".

Output:

PrograJava mming 
Programming

Example 3: Reverse and Replace

This code illustrates StringBuffer operations where reverse() inverts the entire sequence of characters, and replace(1, 3, "XX") substitutes the characters from index 1 to 2 with "XX", updating the content accordingly.

Output:

EDCBA 
EXXBA

Java String Vs. StringBuffer

Usage of String

• We have text that will not change or changes very rarely.
• We are dealing with a small number of string concatenations or operations where the overhead of creating new String objects is negligible.
• We prioritize immutability and inherent thread safety.

Usage of StringBuffer

• We need to perform frequent modifications (insertions, deletions, appends) on a string.
• An application operates in a multi-threaded environment where thread safety for string manipulation is a critical concern.

Conclusion

The main difference between String and StringBuffer is essential for effective Java character sequence handling. String objects are immutable, making them naturally thread-safe and ideal for constant text. In contrast, frequent modifications with Strings cause performance overhead, as each operation creates a new object.

Java String and StringBuffer Class MCQs

1. Which of the following correctly describes the mutability of String and StringBuffer in Java?

1. Both are immutable
2. String is immutable, StringBuffer is mutable
3. String is mutable, StringBuffer is immutable
4. Both are mutable

2. Consider the following code and find the output.

1. Prints "Hello"
2. Prints "Hello World"
3. Prints null
4. Compilation error

3. Which of the following is true about StringBuffer?

1. It is not synchronized and unsafe for multithreading
2. It is mutable and thread-safe due to synchronization
3. It is immutable and faster than String
4. It stores values in the String Constant Pool

4. Which operation in StringBuffer allows directly modifying the content of the same object instead of creating a new one?

1. substring()
2. concat()
3. append()
4. equals()

5. Consider the following code and find the output.

1. true false true
2. false true false
3. true true true
4. false false true