Arrays and Collections

# CHAPTER 10

Arrays and Collections #

1. Chapter Introduction #

2. Learning Objectives #

• Create and manipulate standard Arrays.

• Understand the difference between Immutable and Mutable Collections.

• Use listOf() and mutableListOf().

• Use Sets (setOf) to ensure uniqueness.

• Use Maps (mapOf) for Key-Value pairs.

3. Arrays (Fixed Size) #

fun main() {
    // Creating an array using arrayOf()
    val numbers = arrayOf(10, 20, 30, 40)
    
    // Accessing elements via index (0-based)
    println("First element: ${numbers[0]}") // 10
    
    // Modifying an element
    numbers[1] = 99 
    
    // Iterating over an array
    for (num in numbers) {
        println(num)
    }
}

4. Collections: Immutable vs Mutable #

1. 1. Immutable (Read-Only): You can read items, but you cannot add, remove, or change them. (e.g., listOf()).

1. 2. Mutable: You can add, remove, and change items. (e.g., mutableListOf()).

5. Lists (Ordered Collections) #

#### Read-Only List

fun main() {
    // Immutable: Cannot add or remove items
    val colors = listOf("Red", "Green", "Blue")
    
    println(colors[0])
    // colors.add("Yellow") // ERROR! Unresolved reference: add
}

#### Mutable List

fun main() {
    // Mutable: Can grow and shrink dynamically
    val shoppingList = mutableListOf("Apples", "Milk")
    
    shoppingList.add("Bread")       // Adds to the end
    shoppingList.remove("Apples")   // Removes the item
    
    println(shoppingList) // [Milk, Bread]
}

6. Sets (Unique Collections) #

fun main() {
    val ids = mutableSetOf(101, 102, 103)
    
    ids.add(101) // We try to add a duplicate
    
    println(ids) // [101, 102, 103] - The duplicate was ignored!
}

7. Maps (Key-Value Pairs) #

fun main() {
    // Creating a Mutable Map
    // "to" is a special Kotlin keyword to pair keys and values
    val userAges = mutableMapOf("Alice" to 28, "Bob" to 34)
    
    // Adding a new entry
    userAges["Charlie"] = 22
    
    // Reading a value
    println("Alice's age is ${userAges["Alice"]}")
}

8. Mini Project: Student Marks Manager #

fun main() {
    val gradebook = mutableMapOf<String, Int>()
    
    // Adding students
    gradebook["Alice"] = 95
    gradebook["Bob"] = 82
    gradebook["Charlie"] = 88
    
    // Update Bob's grade
    gradebook["Bob"] = 85 
    
    println("--- CLASS GRADES ---")
    // Iterating through a Map
    for ((name, score) in gradebook) {
        println("Student: $name | Score: $score")
    }
}

9. Common Mistakes #

• Confusing val with Immutability: If you declare val list = mutableListOf("A"), the *variable reference* cannot change (you can't assign a whole new list to it), but you CAN still modify the contents (list.add("B")). val protects the reference; listOf() protects the contents!

• IndexOutOfBounds: Trying to access numbers[5] in an array that only has 3 items will crash the program.

10. Best Practices #

• Default to Read-Only: Always use listOf() by default. Only upgrade to mutableListOf() if your specific business logic requires adding or removing items. Passing read-only lists between functions guarantees data integrity.

11. Exercises #

1. 1. Create a mutableListOf containing three names.

1. 2. Add a fourth name to the list.

1. 3. Remove the first name.

1. 4. Use a for loop to print all remaining names.

12. MCQs with Answers #

13. Interview Questions #

• Q: Explain the difference between val myVar and listOf(). (Answer: val prevents the variable *reference* from being reassigned. listOf() prevents the *contents* of the collection from being altered).

• Q: When would you use a Set instead of a List?

14. Summary #

15. Next Chapter Recommendation #