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.

Practice

1. What does it mean that a String in Kotlin is immutable?

easy

A. Strings can only hold numbers, not letters.

B. You can change characters inside the String directly.

C. Once created, the text inside a String cannot be changed.

D. Strings automatically update when variables change.

Solution

1. Step 1: Understand immutability concept

   Immutability means the object cannot be changed after creation.

2. Step 2: Apply to Kotlin String

   Kotlin Strings cannot be modified once created; any change creates a new String.

3. Final Answer:

   Once created, the text inside a String cannot be changed. -> Option C

4. Quick Check:

   String immutability = cannot change text [OK]

Hint: Remember: Strings are like printed paper, not editable [OK]

Common Mistakes:

• Thinking you can change characters inside the same String
• Confusing immutability with variable reassignment
• Believing Strings hold only numbers

2. Which of the following is the correct way to concatenate two Strings str1 and str2 in Kotlin?

easy

A. str1 & str2

B. str1 + str2

C. str1.join(str2)

D. str1.append(str2)

Solution

1. Step 1: Recall Kotlin String concatenation syntax

   Kotlin uses the + operator to join two Strings.

2. Step 2: Check each option

   Only str1 + str2 is valid Kotlin syntax for concatenation.

3. Final Answer:

   str1 + str2 -> Option B

4. Quick Check:

   Use + to join Strings [OK]

Hint: Use + to combine Strings, like adding words together [OK]

Common Mistakes:

• Using methods like append or join which don't exist on Kotlin String
• Using & which is not a Kotlin operator for Strings
• Trying to modify Strings directly

3. What will be the output of this Kotlin code?

val text = "Hello"
val newText = text + " World"
println(text)

medium

A. Hello

B. Hello World

C. World

D. HelloWorld

Solution

1. Step 1: Understand String immutability and concatenation

   The original String text remains unchanged after concatenation.

2. Step 2: Analyze the print statement

   Only text is printed, which is still "Hello".

3. Final Answer:

   Hello -> Option A

4. Quick Check:

   Original String unchanged = Hello [OK]

Hint: Printing original String shows it stays the same [OK]

Common Mistakes:

• Assuming original String changes after + operation
• Confusing newText with text in print
• Ignoring immutability of Strings

4. Identify the error in this Kotlin code snippet:

var greeting = "Hi"
greeting[0] = 'B'
println(greeting)

medium

A. println cannot print Strings.

B. Variable greeting should be val, not var.

C. Single quotes cannot be used for characters.

D. You cannot change characters in a String by index.

Solution

1. Step 1: Check String mutability rules

   Kotlin Strings are immutable; you cannot assign to an index.

2. Step 2: Analyze the code line causing error

   Line greeting[0] = 'B' tries to change a character, which is invalid.

3. Final Answer:

   You cannot change characters in a String by index. -> Option D

4. Quick Check:

   Strings immutable = no index assignment [OK]

Hint: Strings are like frozen text, can't change letters inside [OK]

Common Mistakes:

• Thinking var allows character change inside String
• Confusing char literals with strings
• Believing println can't print Strings

5. Given a list of words, how can you create a new list with each word appended by "!" without changing the original words?

val words = listOf("cat", "dog", "bird")
val excitedWords = ???

Which Kotlin code correctly does this considering String immutability?

hard

A. val excitedWords = words.map { it + "!" }

B. val excitedWords = words.apply { this[0] += "!" }

C. val excitedWords = words.forEach { it + "!" }

D. val excitedWords = words.replace("", "!")

Solution

1. Step 1: Understand immutability and list transformations

   Strings cannot be changed, so create new Strings with + "!".

2. Step 2: Use map to transform each word into a new String

   map returns a new list with transformed elements without modifying original.

3. Final Answer:

   val excitedWords = words.map { it + "!" } -> Option A

4. Quick Check:

   Use map + + operator for new list [OK]

Hint: Use map to create new list with modified Strings [OK]

Common Mistakes:

• Trying to modify list elements directly with apply or forEach
• Using replace on list instead of Strings
• Assuming original list changes