String vs StringBuilder in Java - Visual Side-by-Side Comparison

Concept Flow - String vs StringBuilder

Create String or StringBuilder

↓

Modify content?

↓

String: create new String

↓

Use updated value

↓

End

Shows how String creates new objects on change, while StringBuilder modifies content without new objects.

Execution Sample

Java

String s = "Hi";
s = s + "!";

StringBuilder sb = new StringBuilder("Hi");
sb.append("!");

System.out.println(s);
System.out.println(sb.toString());

This code shows adding "!" to a String and a StringBuilder, then prints both.

Execution Table

Step	Variable	Action	Value After Action	Notes
1	s	Initialize with "Hi"	"Hi"	String s points to "Hi"
2	s	Concatenate "!" to s	"Hi!"	New String created, s points to "Hi!"
3	sb	Create StringBuilder with "Hi"	StringBuilder("Hi")	sb holds mutable sequence "Hi"
4	sb	Append "!" to sb	StringBuilder("Hi!")	sb content changed in place
5	s	Print s	"Hi!"	Outputs Hi!
6	sb	Print sb.toString()	"Hi!"	Outputs Hi!
7	-	End of program	-	Execution stops

💡 Program ends after printing both values.

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
s	"Hi"	"Hi!"	"Hi!"	"Hi!"
sb	null	null	StringBuilder("Hi!")	StringBuilder("Hi!")

Key Moments - 3 Insights

Why does String s change reference after concatenation?

Because Strings are immutable, concatenation creates a new String object; see execution_table row 2 where s points to a new value.

Does StringBuilder create a new object when appending?

No, StringBuilder modifies its internal content in place without creating a new object, as shown in execution_table row 4.

Why do both s and sb print the same output even though they behave differently?

Because both end up holding the string "Hi!" at print time, but s is a new String object while sb is a mutable sequence converted to String.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of s after step 2?

A "Hi"

B null

C "Hi!"

D "!"

💡 Hint

Check the 'Value After Action' column for step 2 in execution_table.

At which step does StringBuilder content change?

A Step 4

B Step 2

C Step 1

D Step 6

💡 Hint

Look at the 'Action' column for StringBuilder in execution_table.

If we replaced String s concatenation with StringBuilder append, how would variable s behave?

A s would become null

B s would point to a new String object each time

C s would modify content in place without new objects

D s would throw an error

💡 Hint

Recall from key_moments that String is immutable and creates new objects on concatenation.

Concept Snapshot

String vs StringBuilder in Java:
- String is immutable; changes create new objects.
- StringBuilder is mutable; changes happen in place.
- Use StringBuilder for many modifications to improve performance.
- String concatenation creates new Strings each time.
- StringBuilder has append() method to add content efficiently.

Full Transcript

This visual trace compares Java String and StringBuilder. Initially, String s is "Hi". When concatenated with "!", a new String "Hi!" is created and s points to it. StringBuilder sb starts with "Hi" and appends "!" by modifying its content in place. Both print "Hi!" at the end. Key points: String is immutable and creates new objects on change; StringBuilder is mutable and changes content without new objects. This helps understand performance and behavior differences.

Practice

1. Which statement best describes when to use StringBuilder instead of String in Java?

easy

A. Use StringBuilder when you need to change text many times efficiently.

B. Use StringBuilder for fixed text that never changes.

C. Use String when you want faster text modifications.

D. Use String to save memory when changing text repeatedly.

Solution

1. Step 1: Understand the nature of String and StringBuilder

   String objects are immutable, meaning they cannot be changed once created. Changing text creates new objects, which is slow and uses more memory.

2. Step 2: Identify when StringBuilder is better

   StringBuilder allows changing text without creating new objects, making it efficient for many modifications.

3. Final Answer:

   Use StringBuilder when you need to change text many times efficiently. -> Option A

4. Quick Check:

   Many changes = StringBuilder [OK]

Hint: Use StringBuilder for many text changes, String for fixed text [OK]

Common Mistakes:

• Thinking String is better for many changes
• Confusing immutability of String
• Assuming StringBuilder uses more memory always

2. Which of the following is the correct way to create a StringBuilder object with initial text "Hello"?

easy

A. StringBuilder sb = StringBuilder("Hello");

B. StringBuilder sb = "Hello";

C. StringBuilder sb = new StringBuilder[] {"Hello"};

D. StringBuilder sb = new StringBuilder("Hello");

Solution

1. Step 1: Recall the correct constructor syntax for StringBuilder

   The StringBuilder class requires the new keyword and parentheses with the initial string inside.

2. Step 2: Check each option for syntax correctness

   StringBuilder sb = new StringBuilder("Hello"); uses new StringBuilder("Hello"), which is correct. Options A, B, and D have syntax errors or wrong usage.

3. Final Answer:

   StringBuilder sb = new StringBuilder("Hello"); -> Option D

4. Quick Check:

   Use new + constructor for StringBuilder [OK]

Hint: Always use 'new StringBuilder("text")' to create StringBuilder [OK]

Common Mistakes:

• Omitting 'new' keyword
• Using assignment without constructor
• Using array syntax mistakenly

3. What is the output of this Java code?

StringBuilder sb = new StringBuilder("Hi");
sb.append("!");
sb.append(" How are you?");
System.out.println(sb.toString());

medium

A. Hi!How are you?

B. Hi How are you?

C. Hi! How are you?

D. Hi

Solution

1. Step 1: Understand what append() does on StringBuilder

   Each append() adds the given text to the end of the current StringBuilder content without spaces unless explicitly added.

2. Step 2: Trace the code execution

   Initial text is "Hi". First append adds "!" making "Hi!". Second append adds " How are you?" (with leading space), resulting in "Hi! How are you?".

3. Final Answer:

   Hi! How are you? -> Option C

4. Quick Check:

   Appends add text exactly as given [OK]

Hint: Append adds text exactly; watch spaces carefully [OK]

Common Mistakes:

• Ignoring spaces in appended strings
• Assuming append replaces text
• Printing StringBuilder object directly without toString()

4. Identify the error in this code snippet:

StringBuilder sb = new StringBuilder("Test");
sb = sb + "ing";
System.out.println(sb);

medium

A. Cannot use + operator to concatenate StringBuilder and String.

B. Missing semicolon after StringBuilder initialization.

C. StringBuilder cannot be printed directly with println.

D. StringBuilder must be declared final.

Solution

1. Step 1: Check the use of + operator with StringBuilder

   The + operator cannot be used to add a String to a StringBuilder object directly. This causes a compile-time error.

2. Step 2: Understand correct way to append text to StringBuilder

   Use sb.append("ing") to add text instead of + operator.

3. Final Answer:

   Cannot use + operator to concatenate StringBuilder and String. -> Option A

4. Quick Check:

   Use append(), not +, with StringBuilder [OK]

Hint: Use append() to add text to StringBuilder, not + [OK]

Common Mistakes:

• Trying to use + with StringBuilder
• Thinking println can't print StringBuilder
• Forgetting semicolons

5. You want to build a sentence by adding words one by one in a loop. Which approach is best for performance and why?

Option A:
String sentence = "";
for (String word : words) {
    sentence += word + " ";
}

Option B:
StringBuilder sentence = new StringBuilder();
for (String word : words) {
    sentence.append(word).append(" ");
}

hard

A. Option A is better because String is simpler to use.

B. Option B is better because StringBuilder avoids creating many new objects.

C. Both are equally efficient for building strings in loops.

D. Option A is better because it uses less memory.

Solution

1. Step 1: Analyze Option B is better because String is simpler to use. (String concatenation in loop)

   Each concatenation with += creates a new String object because Strings are immutable, causing slow performance and more memory use.

2. Step 2: Analyze Option B is better because StringBuilder avoids creating many new objects. (StringBuilder in loop)

   StringBuilder modifies the same object without creating new ones, making it faster and more memory efficient for repeated changes.

3. Final Answer:

   Option B is better because StringBuilder avoids creating many new objects. -> Option B

4. Quick Check:

   Use StringBuilder for repeated string changes in loops [OK]

Hint: Use StringBuilder in loops to build strings efficiently [OK]

Common Mistakes:

• Using String concatenation in loops thinking it's fast
• Ignoring immutability of String
• Assuming simpler code is always better