StringBuilder for performance in Kotlin - Step-by-Step Execution

Concept Flow - StringBuilder for performance

Create StringBuilder

↓

Append strings one by one

↓

StringBuilder holds combined string

↓

Call toString() to get final string

↓

Use final string

This flow shows how StringBuilder is created, strings are appended efficiently, and the final combined string is obtained.

Execution Sample

Kotlin

val sb = StringBuilder()
sb.append("Hello")
sb.append(", ")
sb.append("World!")
val result = sb.toString()
println(result)

This code builds a string "Hello, World!" step-by-step using StringBuilder for better performance.

Execution Table

Step	Action	StringBuilder Content	Result/Output
1	Create StringBuilder	""
2	Append "Hello"	"Hello"
3	Append ", "	"Hello, "
4	Append "World!"	"Hello, World!"
5	Call toString()	"Hello, World!"	Hello, World!
6	Print result	"Hello, World!"	Hello, World!

💡 All strings appended; final string printed; execution ends.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	Final
sb (StringBuilder content)	""	"Hello"	"Hello, "	"Hello, World!"	"Hello, World!"	"Hello, World!"
result	null	null	null	null	"Hello, World!"	"Hello, World!"

Key Moments - 2 Insights

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

Using + creates a new string each time, which is slow. StringBuilder changes one object, making it faster (see steps 2-4 in execution_table).

When do we get the final combined string from StringBuilder?

Only when we call toString() (step 5), the combined string is created for use or printing.

Visual Quiz - 3 Questions

Look at the execution_table, what is the content of StringBuilder after step 3?

A "Hello"

B "Hello, "

C "Hello, World!"

D ""

💡 Hint

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

At which step is the final string stored in variable 'result'?

A Step 2

B Step 4

C Step 5

D Step 6

💡 Hint

Look at the variable_tracker row for 'result' and see when it changes from null.

If we replaced StringBuilder with simple string concatenation (+), what would change in the execution_table?

A More steps creating new strings each append

B Fewer steps because + is faster

C No change in steps or content

D StringBuilder content would be empty

💡 Hint

Recall key_moments explanation about performance difference between + and StringBuilder.

Concept Snapshot

StringBuilder lets you build strings efficiently by appending pieces without creating new strings each time.
Create with StringBuilder(), append with append(), then get final string with toString().
Better performance than using + for many string joins.
Use when building strings in loops or many steps.

Full Transcript

This example shows how to use StringBuilder in Kotlin to build a string step-by-step. First, we create an empty StringBuilder. Then, we append "Hello", then ", ", then "World!". Each append adds to the same object, so it is fast. After all parts are added, we call toString() to get the final combined string "Hello, World!". Finally, we print the result. Using StringBuilder avoids creating many temporary strings, improving performance especially when joining many pieces.