StringBuilder and StringBuffer in Java - Step-by-Step Execution

Concept Flow - StringBuilder and StringBuffer

Create StringBuilder/StringBuffer

↓

Append or Modify String

↓

Check if more changes needed?

No→Convert to String or Use

Yes↓

Repeat Append/Modify

↩Back to Check

Create a mutable string object, modify it multiple times efficiently, then convert or use the final string.

Execution Sample

Java

StringBuilder sb = new StringBuilder("Hi");
sb.append(" there");
sb.append("!");
System.out.println(sb.toString());

Builds a string by appending parts and prints the final combined string.

Execution Table

Step	Action	StringBuilder Content	Output
1	Create StringBuilder with "Hi"	"Hi"
2	Append " there"	"Hi there"
3	Append "!"	"Hi there!"
4	Convert to String and print	"Hi there!"	Hi there!
5	End of program	"Hi there!"	Program ends

💡 All append operations done; final string printed and program ends.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
sb	"Hi"	"Hi there"	"Hi there!"	"Hi there!"

Key Moments - 3 Insights

Why do we use StringBuilder instead of just adding strings with +?

StringBuilder changes the string in place without creating new string objects each time, making it faster and more memory efficient. See execution_table steps 2 and 3 where content changes without new objects.

What is the difference between StringBuilder and StringBuffer?

StringBuffer is like StringBuilder but thread-safe (safe for multiple threads). StringBuilder is faster but not thread-safe. Both work similarly as shown in the example.

Why do we call toString() at the end?

toString() converts the mutable StringBuilder content into a regular immutable String for output or other uses. println(sb) implicitly calls toString() and prints the content correctly even without the explicit call (see execution_table step 4).

Visual Quiz - 3 Questions

Look at the execution table, what is the content of sb after step 2?

A "Hi there!"

B "Hi"

C "Hi there"

D " there"

💡 Hint

Check the 'StringBuilder Content' column at step 2 in the execution_table.

At which step is the final string printed?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look for the 'Output' column showing printed text in the execution_table.

If we skip calling toString(), what will System.out.println(sb) print?

A A memory address or object reference string

B The string content like "Hi there!"

C An error message

D Nothing, blank line

💡 Hint

StringBuilder overrides toString() to return its content, so println(sb) prints the string content just like println(sb.toString()).

Concept Snapshot

StringBuilder and StringBuffer create mutable strings.
Use append() to add text efficiently.
StringBuilder is faster but not thread-safe.
StringBuffer is thread-safe but slower.
Call toString() to get final String.
Ideal for many string changes.

Full Transcript

This visual trace shows how StringBuilder works in Java. First, we create a StringBuilder with initial content "Hi". Then we append " there" and "!" step by step, changing the content without making new string objects each time. Finally, we convert the StringBuilder to a String using toString() and print it. This is faster than using + to join strings repeatedly. StringBuffer works similarly but is safe for multiple threads. Remember that println implicitly calls toString() to get the string content for output. This example helps beginners see how mutable strings work and why StringBuilder is useful.

Practice

1.

Which of the following statements about StringBuilder and StringBuffer is true?

easy

A. StringBuffer is faster and not thread-safe, while StringBuilder is thread-safe but slower.

B. StringBuilder is faster but not thread-safe, while StringBuffer is thread-safe but slower.

C. Both StringBuilder and StringBuffer are thread-safe and have the same speed.

D. StringBuilder and StringBuffer cannot be used to modify strings.

Solution

1. Step 1: Understand thread safety difference

   StringBuffer is synchronized, making it thread-safe but slower.

2. Step 2: Understand performance difference

   StringBuilder is not synchronized, so it is faster but not thread-safe.

3. Final Answer:

   StringBuilder is faster but not thread-safe, while StringBuffer is thread-safe but slower. -> Option B

4. Quick Check:

   Thread safety and speed = A [OK]

Hint: Remember: Buffer is safe but slower; Builder is fast but unsafe [OK]

Common Mistakes:

• Confusing which class is thread-safe
• Thinking both have same speed
• Believing they cannot modify strings

2.

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

easy

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

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

C. StringBuilder sb = new StringBuilder(); sb.append("Hello");

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

Solution

1. Step 1: Check constructor syntax

   The correct way to create a StringBuilder with initial content is using new StringBuilder("Hello").

2. Step 2: Verify other options

   StringBuilder sb = StringBuilder("Hello"); misses new, StringBuilder sb = new StringBuilder(); sb.append("Hello"); is valid but not direct initialization, StringBuilder sb = new StringBuffer("Hello"); uses wrong class.

3. Final Answer:

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

4. Quick Check:

   Correct constructor syntax = D [OK]

Hint: Use 'new' keyword and constructor with string inside parentheses [OK]

Common Mistakes:

• Omitting 'new' keyword
• Using StringBuffer instead of StringBuilder
• Trying to assign without constructor

3.

What is the output of the following code?

StringBuilder sb = new StringBuilder("Java");
sb.append(" Programming");
sb.replace(0, 4, "Python");
System.out.println(sb.toString());

medium

A. PythonJava Programming

B. Java Programming

C. Python Programming

D. ProgrammingPython

Solution

1. Step 1: Append " Programming" to "Java"

   After append, string becomes "Java Programming".

2. Step 2: Replace characters from index 0 to 4 with "Python"

   Characters "Java" (index 0 to 4) are replaced by "Python", resulting in "Python Programming".

3. Final Answer:

   Python Programming -> Option C

4. Quick Check:

   Append + replace result = A [OK]

Hint: Replace changes substring; append adds at end [OK]

Common Mistakes:

• Confusing replace indices
• Thinking append replaces text
• Ignoring toString() output

4.

Identify the error in the following code snippet:

StringBuffer sb = new StringBuffer("Test");
sb.insert(5, "ing");
System.out.println(sb);

medium

A. IndexOutOfBoundsException because insert index is invalid

B. NullPointerException because sb is not initialized

C. Compilation error due to wrong method name

D. No error; output is "Testing"

Solution

1. Step 1: Check insert index validity

   StringBuffer length is 4 ("Test"), but insert index is 5, which is out of bounds.

2. Step 2: Understand exception thrown

   Inserting at index greater than length throws IndexOutOfBoundsException.

3. Final Answer:

   IndexOutOfBoundsException because insert index is invalid -> Option A

4. Quick Check:

   Invalid insert index = B [OK]

Hint: Insert index must be between 0 and length inclusive [OK]

Common Mistakes:

• Assuming insert auto-corrects index
• Confusing insert with append
• Expecting no error on invalid index

5.

You want to build a thread-safe string that appends numbers 1 to 3 separated by commas, resulting in "1,2,3". Which code snippet correctly uses StringBuffer to achieve this?

1. StringBuffer sb = new StringBuffer();
   for (int i = 1; i <= 3; i++) {
       sb.append(i);
       if (i != 3) sb.append(",");
   }
   System.out.println(sb.toString());

2. StringBuffer sb = new StringBuffer();
   for (int i = 1; i <= 3; i++) {
       sb.append(i + ",");
   }
   System.out.println(sb.toString());

3. StringBuffer sb = new StringBuffer();
   sb.append("1,2,3,");
   System.out.println(sb.toString());

4. StringBuffer sb = new StringBuffer();
   for (int i = 1; i < 3; i++) {
       sb.append(i);
       sb.append(",");
   }
   System.out.println(sb.toString());

hard

A. Code snippet 1

B. Code snippet 2

C. Code snippet 3

D. Code snippet 4

Solution

1. Step 1: Analyze snippet 1

   Appends numbers 1 to 3 with commas except after last number, producing "1,2,3" correctly.

2. Step 2: Check other snippets

   Snippet 2 adds extra comma at end; snippet 3 hardcodes string but adds extra comma; snippet 4 misses last number 3.

3. Final Answer:

   Code snippet 1 -> Option A

4. Quick Check:

   Correct comma placement in loop = C [OK]

Hint: Add comma only if not last element in loop [OK]

Common Mistakes:

• Adding extra comma at end
• Missing last number in loop
• Hardcoding string without loop