String type and immutability in Kotlin - Step-by-Step Execution

Concept Flow - String type and immutability

Create String variable

↓

Assign value to String

↓

Try to change String content

↓

Immutable: Original String unchanged

↓

New String created if modified

This flow shows that once a String is created, its content cannot be changed. Any modification creates a new String.

Execution Sample

Kotlin

val text = "Hello"
val newText = text.replace('H', 'J')
println(text)
println(newText)

This code creates a String, tries to change a character, and prints both original and new Strings.

Execution Table

Step	Action	Variable	Value	Output
1	Create String variable	text	"Hello"
2	Call replace on text	newText	"Jello"
3	Print original text	text	"Hello"	Hello
4	Print newText	newText	"Jello"	Jello
5	End of program

💡 Program ends after printing both Strings; original String remains unchanged.

Variable Tracker

Variable	Start	After Step 2	Final
text	"Hello"	"Hello"	"Hello"
newText	undefined	"Jello"	"Jello"

Key Moments - 2 Insights

Why does the original String 'text' not change after calling replace?

Because Strings in Kotlin are immutable, the replace function returns a new String without changing the original, as shown in execution_table step 2.

What happens if you try to modify a character directly in a String?

You cannot modify characters directly in a String because it is immutable; you must create a new String with the desired changes.

Visual Quiz - 3 Questions

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

A "Jello"

B "Hello"

C "Hollo"

D undefined

💡 Hint

Check the 'Variable' column for 'text' at step 2 in execution_table.

At which step is the new String 'newText' created?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Look at the 'Action' and 'Variable' columns in execution_table to see when 'newText' gets a value.

If Strings were mutable, what would change in the execution_table?

A The value of 'text' would change after step 2

B A new variable 'newText' would not be needed

C All of the above

D The output of step 3 would be 'Jello'

💡 Hint

Think about how immutability affects variable values and outputs in the execution_table.

Concept Snapshot

String type in Kotlin is immutable.
Once created, String content cannot be changed.
Methods like replace return new Strings.
Original String stays the same after modifications.
Use new variables to hold changed Strings.

Full Transcript

In Kotlin, Strings are immutable, meaning once you create a String, you cannot change its content. For example, when you call the replace method on a String, it does not change the original String but returns a new one with the changes. In the sample code, the variable 'text' holds "Hello". When we call text.replace('H', 'J'), it creates a new String "Jello" and stores it in 'newText'. Printing 'text' still shows "Hello", while printing 'newText' shows "Jello". This immutability ensures Strings are safe and predictable. If you want a changed String, you must assign the result to a new variable or overwrite the old one.