List creation (listOf, mutableListOf) in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does listOf() create in Kotlin?

listOf() creates an immutable list, which means you cannot change its elements after creation.

beginner

What is the difference between listOf() and mutableListOf()?

listOf() creates an immutable list, while mutableListOf() creates a mutable list that allows adding, removing, or changing elements.

beginner

How do you add an element to a list created with mutableListOf()?

Use the add() function. For example: val list = mutableListOf(1, 2); list.add(3) adds 3 to the list.

beginner

Can you change elements in a list created with listOf()?

No, lists created with listOf() are immutable. You cannot add, remove, or change elements.

beginner

Write Kotlin code to create a mutable list of strings with elements "apple" and "banana".

val fruits = mutableListOf("apple", "banana")

Which Kotlin function creates an immutable list?

A setOf()

B listOf()

C arrayListOf()

D mutableListOf()

listOf() creates an immutable list that cannot be changed after creation.

How do you add an element to a mutable list in Kotlin?

A Using add() function

B Using set() function

C Using push() function

D Using insert() function

The add() function adds an element to a mutable list.

What happens if you try to add an element to a list created with listOf()?

A Runtime exception

B Element is added successfully

C Compilation error

D Element replaces the last item

Lists created with listOf() are immutable, so adding elements causes a runtime exception.

Which of these is a mutable list in Kotlin?

A val list = listOf(1, 2, 3)

B val list = arrayOf(1, 2, 3)

C val list = setOf(1, 2, 3)

D val list = mutableListOf(1, 2, 3)

mutableListOf() creates a mutable list that can be changed.

Which method would you use to remove an element from a mutable list?

A pop()

B delete()

C remove()

D discard()

The remove() method removes an element from a mutable list.

Explain the difference between listOf() and mutableListOf() in Kotlin.

Think about whether you can change the list after making it.

How would you create a list of numbers that you can change later? Write the Kotlin code.

Use mutableListOf and add some numbers inside parentheses.

Practice

1. Which Kotlin function creates a list that cannot be changed after it is created?

easy

A. listOf

B. mutableListOf

C. arrayListOf

D. setOf

Solution

1. Step 1: Understand listOf behavior

   listOf creates a fixed list that cannot be changed after creation.

2. Step 2: Compare with mutableListOf

   mutableListOf creates a list that can be changed (add/remove items).

3. Final Answer:

   listOf -> Option A

4. Quick Check:

   Fixed list = listOf [OK]

Hint: Use listOf for fixed lists, mutableListOf for changeable lists [OK]

Common Mistakes:

• Confusing mutableListOf as fixed list
• Thinking arrayListOf is immutable
• Using setOf which creates a set, not a list

2. Which of the following is the correct syntax to create a mutable list of integers with values 1, 2, and 3?

easy

A. val list = listOf(1, 2, 3)

B. val list = mutableListOf(1, 2, 3)

C. val list = mutableList(1, 2, 3)

D. val list = list(1, 2, 3)

Solution

1. Step 1: Identify correct function name

   The correct function to create a mutable list is mutableListOf.

2. Step 2: Check syntax correctness

   Options C and D use invalid function names. val list = listOf(1, 2, 3) creates an immutable list.

3. Final Answer:

   val list = mutableListOf(1, 2, 3) -> Option B

4. Quick Check:

   Mutable list syntax = mutableListOf(...) [OK]

Hint: Remember mutableListOf has 'Of' at the end [OK]

Common Mistakes:

• Using listOf instead of mutableListOf for mutable lists
• Misspelling mutableListOf as mutableList
• Using list() which does not exist

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

val list = listOf("apple", "banana", "cherry")
println(list[1])

medium

A. banana

B. IndexOutOfBoundsException

C. cherry

D. apple

Solution

1. Step 1: Understand list indexing

   Kotlin lists use zero-based indexing, so index 1 refers to the second item.

2. Step 2: Identify the item at index 1

   The list is ["apple", "banana", "cherry"], so index 1 is "banana".

3. Final Answer:

   banana -> Option A

4. Quick Check:

   Index 1 = second item = banana [OK]

Hint: Remember list indexes start at 0 in Kotlin [OK]

Common Mistakes:

• Thinking index 1 is the first item
• Expecting an error for valid index
• Confusing listOf with mutableListOf output

4. What is wrong with this Kotlin code?

val list = listOf(1, 2, 3)
list.add(4)

medium

A. add() method requires a mutableListOf list

B. Syntax error in listOf declaration

C. listOf creates an immutable list; add() is not allowed

D. No error; code runs fine

Solution

1. Step 1: Check list type

   listOf creates an immutable (read-only) list.

2. Step 2: Understand add() method

   The add() method is only available on mutable lists, not on immutable lists.

3. Final Answer:

   listOf creates an immutable list; add() is not allowed -> Option C

4. Quick Check:

   Immutable list cannot add items [OK]

Hint: Use mutableListOf to add or remove items [OK]

Common Mistakes:

• Trying to add to listOf list
• Ignoring immutability of listOf
• Assuming add() works on all lists

5. You want to create a list of strings that you can add items to later. Which Kotlin code correctly creates this list and adds "orange" to it?

hard

A. val fruits = mutableListOf("apple", "banana")
fruits = fruits + "orange"

B. val fruits = listOf("apple", "banana")
fruits.add("orange")

C. val fruits = listOf("apple", "banana")
fruits += "orange"

D. val fruits = mutableListOf("apple", "banana")
fruits.add("orange")

Solution

1. Step 1: Choose a mutable list

   To add items later, the list must be mutable, so use mutableListOf.

2. Step 2: Use add() method correctly

   Calling add("orange") on a mutable list adds the item successfully.

3. Step 3: Check other options

   val fruits = listOf("apple", "banana") fruits.add("orange") tries to add to immutable list (error). val fruits = listOf("apple", "banana") fruits += "orange" uses += on immutable list (creates new list but does not modify original). val fruits = mutableListOf("apple", "banana") fruits = fruits + "orange" tries to reassign val which is not allowed.

4. Final Answer:

   val fruits = mutableListOf("apple", "banana") fruits.add("orange") -> Option D

5. Quick Check:

   Mutable list + add() = correct way [OK]

Hint: Use mutableListOf and add() to change list after creation [OK]

Common Mistakes:

• Adding to immutable list
• Trying to reassign val variable
• Using += on immutable list expecting mutation