List creation (listOf, mutableListOf) in Kotlin

Introduction

Lists help you keep many items together in order. You use listOf to make a list you cannot change, and mutableListOf to make a list you can change later.

When you want to store a fixed set of names that won't change.

When you need a list of numbers that you will add or remove items from.

When you want to keep a shopping list that you can update.

When you want to group related data like colors or days of the week.

When you want to pass a list of items to a function without changing it.

Syntax

Kotlin

fun main() {
    val fixedList = listOf<Type>(item1, item2, item3)
    val changeableList = mutableListOf<Type>(item1, item2, item3)
}

listOf creates a list that cannot be changed (read-only).

mutableListOf creates a list that you can add, remove, or change items in.

Examples

This creates an empty list of strings that cannot be changed.

Kotlin

val emptyList = listOf<String>()

A list with one number, fixed and unchangeable.

Kotlin

val singleItemList = listOf(42)

A list you can add items to after creating it.

Kotlin

val mutableList = mutableListOf("apple", "banana")
mutableList.add("cherry")

Start with an empty mutable list and add an item later.

Kotlin

val mutableEmptyList = mutableListOf<Int>()
mutableEmptyList.add(10)

Sample Program

This program shows how to create a fixed list and a mutable list. It prints the fixed list, then adds and removes items from the mutable list, printing the list each time.

Kotlin

fun main() {
    // Create a fixed list of fruits
    val fruits = listOf("apple", "banana", "cherry")
    println("Fixed list of fruits: $fruits")

    // Create a mutable list of numbers
    val numbers = mutableListOf(1, 2, 3)
    println("Mutable list before adding: $numbers")

    // Add a number to the mutable list
    numbers.add(4)
    println("Mutable list after adding: $numbers")

    // Remove a number from the mutable list
    numbers.remove(2)
    println("Mutable list after removing: $numbers")
}

Important Notes

Time complexity: Accessing items by index is fast (O(1)). Adding or removing items in mutableListOf is usually fast but can be slower if the list needs to resize.

Space complexity: Lists use space proportional to the number of items they hold.

A common mistake is trying to add or remove items from a list created with listOf, which is not allowed.

Use listOf when you want a list that should not change, and mutableListOf when you need to change the list after creating it.

Summary

listOf creates a fixed, read-only list.

mutableListOf creates a list you can change by adding or removing items.

Choose the right list type based on whether you need to change the list later.

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