String type and immutability in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

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

It means once a String is created, its content cannot be changed. Any modification creates a new String.

beginner

How do you create a String in Kotlin?

You create a String by enclosing text in double quotes, for example: val greeting = "Hello".

beginner

Can you change a character inside a Kotlin String directly?

No, you cannot change characters inside a String directly because Strings are immutable. You must create a new String if you want changes.

beginner

What happens when you use the plus operator (+) to add text to a String in Kotlin?

A new String is created that combines the original and the added text. The original String stays unchanged.

intermediate

Why is String immutability useful in programming?

It helps avoid unexpected changes, makes programs safer, and allows sharing Strings without copying.

In Kotlin, what happens if you try to change a character in a String directly?

A You get a compile-time error because Strings are immutable.

B The character changes successfully.

C The program crashes at runtime.

D The String automatically converts to a mutable type.

Strings in Kotlin are immutable, so you cannot change characters directly.

How do you create a new String by adding text to an existing String in Kotlin?

A Modify the original String directly.

B Use the plus (+) operator to combine them.

C Use the minus (-) operator.

D Call a special mutableString() function.

The plus (+) operator creates a new String combining the original and added text.

Which of these is true about Kotlin Strings?

A They are immutable and cannot be changed after creation.

B They are mutable and can be changed anytime.

C They are stored as arrays of characters that can be edited.

D They automatically update when variables change.

Kotlin Strings are immutable, meaning their content cannot be changed after creation.

Why might immutability of Strings improve program safety?

A Because immutability allows Strings to be deleted automatically.

B Because Strings run faster when mutable.

C Because Strings cannot be changed unexpectedly, reducing bugs.

D Because it allows direct memory access.

Immutability prevents unexpected changes, which helps avoid bugs.

What is the correct way to declare a String variable in Kotlin?

A name := "Alice"

B var name = 'Alice'

C String name = "Alice"

D val name = "Alice"

In Kotlin, Strings are declared with val or var and double quotes for text.

Explain what immutability means for the String type in Kotlin and why it matters.

Think about what happens if you try to change a letter inside a String.

Describe how you would add text to an existing String in Kotlin and what happens behind the scenes.

Remember Strings are immutable, so adding text creates something new.

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