String, StringBuilder & StringBuffer

#Introduction

One of the most important Java interview topics is the difference between:

• String
• StringBuilder
• StringBuffer

Every Java developer must know:

• Why String is immutable
• Why StringBuilder is faster
• Why StringBuffer is thread-safe
• When to use each one

This topic is asked in almost every Java interview for 2–10 years of experience.

#What is a String?

A String is a sequence of characters.

String name = "Java";

Internally: J A V A

But unlike arrays, a String object cannot be modified after it is created. This property is called Immutability.

#Creating Strings

There are two ways.

Method 1 — Using a String Literal

String s1 = "Java";

Stored in the String Constant Pool (SCP).

Method 2 — Using new

String s2 = new String("Java");

Stored in Heap Memory.

#String Constant Pool (SCP)

Java maintains a special memory area called the String Constant Pool. Purpose: avoid duplicate String objects.

String s1 = "Java";
String s2 = "Java";

Using new

String s1 = new String("Java");
String s2 = new String("Java");

#Why is String Immutable?

String s = "Java";
s.concat("8");

Java

The original object is unchanged. Correct:

s = s.concat("8");

Java8

A new String object is created.

Internal Working

String s = "Java";
s = s.concat("17");

Advantages of Immutability

• Thread-safe
• Secure
• Enables String Pool
• Safe as HashMap keys
• Easy caching
• Better performance in many scenarios

#Common String Methods

String s = "Java Programming";

#StringBuilder

StringBuilder is a mutable sequence of characters.

StringBuilder sb = new StringBuilder("Java");
sb.append("17");

Java17

No new object is created. The existing object is modified.

Internal Working

#StringBuffer

StringBuffer is also mutable.

StringBuffer sb = new StringBuffer("Java");
sb.append("17");

Java17

Works almost like StringBuilder.

#Difference Between StringBuilder and StringBuffer

The major difference is thread safety.

• StringBuffer — uses synchronized methods. Safe for multiple threads.
• StringBuilder — does not use synchronization. Much faster.

#Performance Comparison

String s = "";

for (int i = 0; i < 10000; i++) {
    s = s + i;
}

Every iteration creates a new String object. Very slow.

Using StringBuilder:

StringBuilder sb = new StringBuilder();

for (int i = 0; i < 10000; i++) {
    sb.append(i);
}

Only one object. Much faster.

#String vs StringBuilder vs StringBuffer

#Capacity

Default capacity:

StringBuilder sb = new StringBuilder();
System.out.println(sb.capacity());

16

With Initial String

StringBuilder sb = new StringBuilder("Java");

Capacity = length + 16 = 4 + 16 = 20.

Capacity Expansion

When capacity is exceeded, Java expands using:

newCapacity = (oldCapacity * 2) + 2

#Common Methods

#String Pool Examples

String s1 = "Java";
String s2 = "Java";
System.out.println(s1 == s2);

true

String s1 = new String("Java");
String s2 = new String("Java");
System.out.println(s1 == s2);

false

intern() Method

String s1 = new String("Java");
String s2 = s1.intern();
System.out.println(s2 == "Java");

true

intern() returns the pooled String if it already exists; otherwise it adds the string to the pool.

#Real Project Usage

String

• Configuration values
• JSON keys
• API URLs
• Database column names

StringBuilder

• Building SQL queries
• Generating reports
• Creating JSON or XML
• Constructing log messages

StringBuffer

• Legacy multi-threaded code
• Older APIs requiring synchronized mutable strings