Collections (List, Map, Set) in Android Kotlin

Introduction

Collections help you store and organize multiple items together. They make it easy to work with groups of data in your app.

When you want to keep a list of names or items in order.

When you need to find a value by a key, like a phone number by a contact name.

When you want to store unique items without duplicates, like a set of tags.

When you want to loop through many items to show them on the screen.

When you want to add or remove items easily from a group.

Syntax

Android Kotlin

val list: List<Type> = listOf(item1, item2, item3)
val mutableList: MutableList<Type> = mutableListOf(item1, item2)

val map: Map<KeyType, ValueType> = mapOf(key1 to value1, key2 to value2)
val mutableMap: MutableMap<KeyType, ValueType> = mutableMapOf(key1 to value1)

val set: Set<Type> = setOf(item1, item2)
val mutableSet: MutableSet<Type> = mutableSetOf(item1)

List keeps items in order and can have duplicates.

Map stores key-value pairs for quick lookup by key.

Set stores unique items without duplicates.

Mutable collections let you add or remove items after creation.

Examples

A list of fruits with duplicates allowed.

Android Kotlin

val fruits: List<String> = listOf("Apple", "Banana", "Apple")

A map to find phone numbers by name.

Android Kotlin

val phoneBook: Map<String, String> = mapOf("Alice" to "1234", "Bob" to "5678")

A set that keeps only unique tags, so "kotlin" appears once.

Android Kotlin

val uniqueTags: Set<String> = setOf("kotlin", "android", "kotlin")

An empty list with no items.

Android Kotlin

val emptyList: List<Int> = listOf()

Sample App

This program shows how to create and change a list, map, and set. It prints the collections before and after adding new items.

Android Kotlin

fun main() {
  val shoppingList: MutableList<String> = mutableListOf("Milk", "Eggs")
  println("Before adding: $shoppingList")
  shoppingList.add("Bread")
  println("After adding Bread: $shoppingList")

  val contacts: MutableMap<String, String> = mutableMapOf("John" to "111-222")
  println("Contacts before update: $contacts")
  contacts["Mary"] = "333-444"
  println("Contacts after adding Mary: $contacts")

  val colors: MutableSet<String> = mutableSetOf("Red", "Green")
  println("Colors before adding Red again: $colors")
  colors.add("Red")
  println("Colors after adding Red again: $colors")
}

Important Notes

Lists keep order and allow duplicates; sets do not allow duplicates and have no order.

Maps let you find values fast by their keys.

Mutable collections let you change items; immutable ones do not.

Adding an existing item to a set does nothing because sets keep unique items.

Summary

Use List to keep ordered items, duplicates allowed.

Use Map to store key-value pairs for quick lookup.

Use Set to store unique items without duplicates.

Practice

1. Which Kotlin collection type should you use to store a list of names where order matters and duplicates are allowed?

easy

A. List

B. Map

C. Set

D. Array

Solution

1. Step 1: Understand collection types

   List keeps items in order and allows duplicates, Map stores key-value pairs, Set stores unique items without duplicates.

2. Step 2: Match requirement to collection

   Since order matters and duplicates are allowed, List fits best.

3. Final Answer:

   List -> Option A

4. Quick Check:

   Order + duplicates = List [OK]

Hint: Remember: List = ordered + duplicates allowed [OK]

Common Mistakes:

• Choosing Set which disallows duplicates
• Choosing Map which stores key-value pairs
• Confusing Array with List in Kotlin

2. Which of the following is the correct syntax to create a mutable map in Kotlin?

easy

A. val map = mutableListOf()

B. val map = mapOf()

C. val map = mutableMapOf()

D. val map = setOf()

Solution

1. Step 1: Identify mutable map syntax

   mutableMapOf creates a mutable map; mapOf creates an immutable map.

2. Step 2: Check other options

   mutableListOf creates a list, setOf creates a set; both are incorrect for map.

3. Final Answer:

   val map = mutableMapOf() -> Option C

4. Quick Check:

   Mutable map uses mutableMapOf [OK]

Hint: Mutable map uses mutableMapOf() function [OK]

Common Mistakes:

• Using mapOf which is immutable
• Using mutableListOf instead of mutableMapOf
• Using setOf which creates a set, not a map

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

val set = setOf(1, 2, 2, 3)
println(set.size)

medium

A. 3

B. 2

C. 4

D. Error

Solution

1. Step 1: Understand set behavior

   Set stores unique elements only, so duplicates are removed.

2. Step 2: Count unique elements

   Elements are 1, 2, 3 so size is 3.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   Set removes duplicates, size = 3 [OK]

Hint: Set size counts unique elements only [OK]

Common Mistakes:

• Counting duplicates in set size
• Assuming set keeps duplicates
• Expecting runtime error for duplicates

4. Identify the error in this Kotlin code snippet:

val map = mapOf("a" to 1, "b" to 2)
map["c"] = 3

medium

A. map["c"] = 3 is correct syntax

B. Syntax error in map declaration

C. Key "c" already exists

D. mapOf creates an immutable map, cannot add elements

Solution

1. Step 1: Check mapOf mutability

   mapOf creates an immutable map, so you cannot add or change elements.

2. Step 2: Analyze assignment

   map["c"] = 3 tries to add a new key-value pair, which is not allowed on immutable map.

3. Final Answer:

   mapOf creates an immutable map, cannot add elements -> Option D

4. Quick Check:

   mapOf = immutable map, no additions allowed [OK]

Hint: mapOf is immutable; use mutableMapOf to add items [OK]

Common Mistakes:

• Assuming mapOf is mutable
• Thinking syntax is wrong
• Ignoring immutability of mapOf

5. Given a list of words, how can you create a map that counts how many times each word appears? Choose the correct Kotlin code snippet.

hard

A. val counts = words.filter { it.length > 1 }

B. val counts = words.groupingBy { it }.eachCount()

C. val counts = words.distinct()

D. val counts = words.toSet().map { it.length }

Solution

1. Step 1: Understand the goal

   We want a map with words as keys and their counts as values.

2. Step 2: Analyze options

   val counts = words.groupingBy { it }.eachCount() uses groupingBy and eachCount to count occurrences correctly. Others do not count frequencies.

3. Final Answer:

   val counts = words.groupingBy { it }.eachCount() -> Option B

4. Quick Check:

   groupingBy + eachCount counts items [OK]

Hint: Use groupingBy and eachCount to count list items [OK]

Common Mistakes:

• Using toSet which removes duplicates but doesn't count
• Using map to get lengths instead of counts
• Filtering instead of counting