Kotlin Collections are an essential part of Kotlin programming. They allow developers to store, organize, access, and manipulate multiple values efficiently.
Instead of creating separate variables for every value:
val student1 = "Rahul"
val student2 = "Priya"
val student3 = "Amit"
you can store related values inside a collection:
val students = listOf("Rahul", "Priya", "Amit")
Kotlin provides several collection types, but the three most important ones for beginners are:
- List – stores items in a specific order and can contain duplicates.
- Set – stores unique items and does not allow duplicate elements.
- Map – stores data as key-value pairs.
Kotlin collections are widely used in Android development, backend applications, APIs, databases, and everyday programming.
In this complete guide, you’ll learn:
- What Kotlin Collections are
- Mutable vs immutable collections
- Kotlin List
- Kotlin MutableList
- Kotlin Set
- Kotlin MutableSet
- Kotlin Map
- Kotlin MutableMap
- How to add, remove, and update elements
- How to iterate through collections
- Collection filtering
map(),filter(),find(), andreduce()- Sorting collections
- Converting between collections
- Null values in collections
- Real-world examples
- Best practices
What Are Kotlin Collections?
A collection is an object that contains multiple elements.
For example:
val fruits = listOf("Apple", "Banana", "Mango")
Here, fruits contains three values.
Conceptually:
Fruits
├── Apple
├── Banana
└── Mango
Instead of working with each value separately, you can perform operations on the entire collection.
For example:
println(fruits.size)
Output:
3
Types of Kotlin Collections
Kotlin provides several collection types.
The most commonly used are:
Collections
│
├── List
│
├── Set
│
└── Map
There are also mutable versions:
List → MutableList
Set → MutableSet
Map → MutableMap
The key difference is whether the collection can be changed after creation.
Immutable vs Mutable Collections
One of the first concepts you should understand is the difference between read-only and mutable collections.
Read-Only Collections
Example:
val fruits = listOf("Apple", "Banana", "Mango")
You can read the values, but you cannot directly add or remove elements through the read-only List interface.
For example:
fruits.add("Orange")
is not available.
Mutable Collections
If you need to modify a collection, use a mutable collection.
val fruits = mutableListOf("Apple", "Banana", "Mango")
Now you can add:
fruits.add("Orange")
The collection becomes:
[Apple, Banana, Mango, Orange]
You can also remove items:
fruits.remove("Banana")
Result:
[Apple, Mango, Orange]
Kotlin List
A List is an ordered collection of elements.
Lists:
- Maintain element order
- Allow duplicate values
- Provide index-based access
Example:
val fruits = listOf(
"Apple",
"Banana",
"Mango"
)
The indexes are:
Index Value
0 Apple
1 Banana
2 Mango
Accessing List Elements
You can access an element using its index.
val fruits = listOf("Apple", "Banana", "Mango")
println(fruits[0])
Output:
Apple
You can also use:
println(fruits.get(1))
Output:
Banana
Remember that Kotlin indexes start from 0.
List Size
Use the size property to find the number of elements.
val fruits = listOf("Apple", "Banana", "Mango")
println(fruits.size)
Output:
3
Checking Whether a List Contains an Item
Use contains():
val fruits = listOf("Apple", "Banana", "Mango")
println(fruits.contains("Apple"))
Output:
true
You can also use the in operator:
println("Apple" in fruits)
Output:
true
Checking Whether a List Is Empty
You can use:
val fruits = listOf<String>()
println(fruits.isEmpty())
Output:
true
Or:
println(fruits.isNotEmpty())
MutableList in Kotlin
When you need to add, remove, or update items, use MutableList.
Example:
val fruits = mutableListOf(
"Apple",
"Banana",
"Mango"
)
Adding Items to a MutableList
Use add():
fruits.add("Orange")
You can also add an item at a specific position:
fruits.add(1, "Grapes")
For example:
Before:
[Apple, Banana, Mango]
After:
[Apple, Grapes, Banana, Mango]
Adding Multiple Items
Use addAll():
fruits.addAll(
listOf("Orange", "Grapes")
)
Removing Items From a MutableList
Remove by value:
fruits.remove("Banana")
Remove by index:
fruits.removeAt(0)
Clear the entire list:
fruits.clear()
Updating List Elements
Because a MutableList can be modified, you can update an item:
val fruits = mutableListOf(
"Apple",
"Banana",
"Mango"
)
fruits[1] = "Orange"
Now:
[Apple, Orange, Mango]
Looping Through a List
The simplest way to iterate through a list is using for.
val fruits = listOf(
"Apple",
"Banana",
"Mango"
)
for (fruit in fruits) {
println(fruit)
}
Output:
Apple
Banana
Mango
List With forEach
Kotlin also provides forEach():
fruits.forEach {
println(it)
}
Here, it represents the current element.
You can give the parameter a meaningful name:
fruits.forEach { fruit ->
println(fruit)
}
Kotlin Set
A Set is a collection that stores unique elements.
Unlike a list, a set does not allow duplicate elements.
Example:
val numbers = setOf(
10,
20,
30,
20,
10
)
println(numbers)
The result contains only unique values.
Conceptually:
10
20
30
Duplicate 10 and 20 values are not retained as separate elements.
Why Use a Set?
Sets are useful when uniqueness matters.
For example, imagine you have user-selected categories:
Android
Flutter
Android
Kotlin
Flutter
You can use a Set:
val technologies = setOf(
"Android",
"Flutter",
"Android",
"Kotlin",
"Flutter"
)
The resulting set contains unique entries.
Checking a Set
You can check whether a value exists:
println("Kotlin" in technologies)
Output:
true
MutableSet
If you need to modify a set, use mutableSetOf().
val languages = mutableSetOf(
"Kotlin",
"Java",
"Python"
)
Add:
languages.add("Dart")
Remove:
languages.remove("Java")
Clear:
languages.clear()
Adding Duplicate Values to a Set
Suppose:
val languages = mutableSetOf(
"Kotlin",
"Java"
)
Now:
languages.add("Kotlin")
The set remains:
[Kotlin, Java]
because "Kotlin" already exists.
Kotlin Map
A Map stores data using key-value pairs.
For example:
val users = mapOf(
1 to "Rahul",
2 to "Priya",
3 to "Amit"
)
Here:
Key Value
1 Rahul
2 Priya
3 Amit
A map is useful when you want to retrieve a value using a unique key.
Accessing Map Values
Use the key:
val users = mapOf(
1 to "Rahul",
2 to "Priya"
)
println(users[1])
Output:
Rahul
If the key does not exist:
println(users[10])
the result is:
null
Map Keys and Values
You can access all keys:
println(users.keys)
You can access all values:
println(users.values)
You can get the number of entries:
println(users.size)
MutableMap
Use mutableMapOf() when you need to modify the map.
val users = mutableMapOf(
1 to "Rahul",
2 to "Priya"
)
Adding Items to MutableMap
Add a new key-value pair:
users[3] = "Amit"
Now:
1 → Rahul
2 → Priya
3 → Amit
You can also use:
users.put(4, "Neha")
Updating a Map Value
If the key already exists:
users[1] = "Rohit"
The old value is replaced.
Before:
1 → Rahul
After:
1 → Rohit
Removing Map Entries
Remove an entry using its key:
users.remove(2)
Clear the entire map:
users.clear()
Iterating Through a Map
You can loop through both keys and values:
for ((id, name) in users) {
println("$id → $name")
}
Output could be:
1 → Rahul
2 → Priya
3 → Amit
You can also use:
users.forEach { (id, name) ->
println("$id → $name")
}
List vs Set vs Map
The three major collection types serve different purposes.
| Collection | Stores | Duplicates | Access |
|---|---|---|---|
| List | Ordered elements | Yes | Index |
| Set | Unique elements | No | Element |
| Map | Key-value pairs | Keys are unique | Key |
A simple way to remember them:
List → Order matters
Set → Uniqueness matters
Map → Key-value relationship matters
Kotlin Collection Operations
Kotlin provides many powerful functions for working with collections.
Some of the most useful are:
map()filter()find()first()last()any()all()none()count()sorted()distinct()reduce()fold()
These functions make collection processing concise and readable.
The map() Function
map() transforms every element into another value.
Example:
val numbers = listOf(1, 2, 3, 4)
val doubled = numbers.map {
it * 2
}
println(doubled)
Output:
[2, 4, 6, 8]
The original collection is not changed.
The filter() Function
filter() keeps elements that satisfy a condition.
Example:
val numbers = listOf(
1, 2, 3, 4, 5, 6
)
val evenNumbers = numbers.filter {
it % 2 == 0
}
println(evenNumbers)
Output:
[2, 4, 6]
The find() Function
find() returns the first element matching a condition.
val numbers = listOf(10, 20, 30, 40)
val result = numbers.find {
it > 25
}
println(result)
Output:
30
If no matching item exists, find() returns null.
first() and last()
Get the first element:
val numbers = listOf(10, 20, 30)
println(numbers.first())
Output:
10
Get the last:
println(numbers.last())
Output:
30
Be careful with empty collections because first() and last() can throw an exception.
Safer alternatives include:
numbers.firstOrNull()
numbers.lastOrNull()
any() Function
any() checks whether at least one element matches a condition.
val numbers = listOf(1, 3, 5, 8)
println(numbers.any { it % 2 == 0 })
Output:
true
Because 8 is even.
all() Function
all() checks whether every element matches a condition.
val numbers = listOf(2, 4, 6, 8)
println(numbers.all { it % 2 == 0 })
Output:
true
none() Function
none() checks whether no elements match a condition.
val numbers = listOf(1, 3, 5)
println(numbers.none { it % 2 == 0 })
Output:
true
Counting Collection Elements
You can use:
val numbers = listOf(1, 2, 3, 4, 5)
println(numbers.count())
Output:
5
You can also count based on a condition:
val evenCount = numbers.count {
it % 2 == 0
}
Result:
2
Sorting Kotlin Collections
Kotlin provides convenient sorting functions.
Example:
val numbers = listOf(5, 2, 8, 1, 3)
val sortedNumbers = numbers.sorted()
println(sortedNumbers)
Output:
[1, 2, 3, 5, 8]
For descending order:
val sortedNumbers = numbers.sortedDescending()
Sorting Strings
You can sort strings alphabetically:
val names = listOf(
"Rahul",
"Amit",
"Priya",
"Neha"
)
println(names.sorted())
Removing Duplicates With distinct()
Suppose:
val numbers = listOf(
1, 2, 2, 3, 3, 4
)
Use:
val uniqueNumbers = numbers.distinct()
Result:
[1, 2, 3, 4]
This is useful when you need unique values while retaining a list.
Converting List to Set
You can convert a list to a set:
val numbers = listOf(
1, 2, 2, 3, 3
)
val uniqueNumbers = numbers.toSet()
The result contains unique values.
Converting Set to List
You can convert a set to a list:
val numbers = setOf(
1, 2, 3
)
val numberList = numbers.toList()
Converting Collections
Kotlin provides convenient conversion functions:
toList()
toSet()
toMutableList()
toMutableSet()
toMap()
For example:
val numbers = setOf(1, 2, 3)
val list = numbers.toList()
Nullable Values in Collections
Kotlin allows collections to contain nullable values.
Example:
val names: List<String?> = listOf(
"Rahul",
null,
"Priya",
null
)
You can remove null values with:
val validNames = names.filterNotNull()
Result:
[Rahul, Priya]
Nullable Collections
A collection itself can also be nullable.
For example:
val names: List<String>? = null
This is different from:
val names: List<String?> = listOf(
"Rahul",
null
)
In the first example, the list itself may be null.
In the second example, the list exists, but its elements may be null.
Collection of Objects
Collections become especially useful when working with objects.
For example:
data class Product(
val name: String,
val price: Double
)
You can create a list:
val products = listOf(
Product("Laptop", 70000.0),
Product("Phone", 30000.0),
Product("Tablet", 25000.0)
)
Now you can filter products:
val expensiveProducts = products.filter {
it.price > 30000
}
You can also get product names:
val productNames = products.map {
it.name
}
This type of collection processing is extremely common in real applications.
Real-World Example: Student List
Suppose you are building a student management application.
data class Student(
val name: String,
val age: Int
)
Create students:
val students = listOf(
Student("Rahul", 20),
Student("Priya", 22),
Student("Amit", 19),
Student("Neha", 21)
)
Find students above age 20:
val olderStudents = students.filter {
it.age > 20
}
Get only names:
val names = students.map {
it.name
}
Sort by age:
val sortedStudents = students.sortedBy {
it.age
}
This demonstrates how Kotlin collections can simplify real application logic.
Real-World Example: Product Filtering
Imagine an e-commerce application.
data class Product(
val name: String,
val price: Double,
val category: String
)
Create products:
val products = listOf(
Product("Laptop", 70000.0, "Electronics"),
Product("Phone", 30000.0, "Electronics"),
Product("Shoes", 4000.0, "Fashion"),
Product("Watch", 8000.0, "Fashion")
)
Filter electronics:
val electronics = products.filter {
it.category == "Electronics"
}
Find products under ₹10,000:
val affordableProducts = products.filter {
it.price < 10000
}
Get product names:
val names = products.map {
it.name
}
This type of collection processing is common in e-commerce applications.
List, Set and Map: When Should You Use Each?
Choosing the correct collection depends on your requirements.
Use List When:
- Order matters
- Duplicate values are allowed
- You need index-based access
Example:
val shoppingItems = listOf(
"Milk",
"Bread",
"Milk"
)
Use Set When:
- Values must be unique
- You don’t need duplicate elements
Example:
val categories = setOf(
"Electronics",
"Fashion",
"Books"
)
Use Map When:
- You need key-value relationships
- You frequently retrieve data using a key
Example:
val userRoles = mapOf(
"Rahul" to "Admin",
"Priya" to "User"
)
Kotlin Collections Best Practices
1. Prefer Read-Only Collections When Possible
If you don’t need to modify a collection, prefer:
val users = listOf(
"Rahul",
"Priya"
)
instead of creating a mutable collection unnecessarily.
2. Use Mutable Collections Only When Needed
Use:
mutableListOf()
when your application genuinely needs to modify the collection.
3. Choose the Correct Collection Type
Don’t automatically use List for everything.
Think about your requirements:
Need ordering?
→ List
Need uniqueness?
→ Set
Need key-value lookup?
→ Map
4. Use Collection Functions
Kotlin’s collection functions can make code shorter and easier to understand.
Instead of manually looping:
val result = mutableListOf<Int>()
for (number in numbers) {
if (number % 2 == 0) {
result.add(number)
}
}
you can write:
val result = numbers.filter {
it % 2 == 0
}
The second version clearly expresses the intention.
5. Avoid Unnecessary Conversions
Don’t repeatedly convert:
List → Set → List → Set
unless the conversion is actually required.
Unnecessary conversions can make code harder to understand and may add processing overhead.
Kotlin Collections Cheat Sheet
| Task | Function |
|---|---|
| Create List | listOf() |
| Create MutableList | mutableListOf() |
| Create Set | setOf() |
| Create MutableSet | mutableSetOf() |
| Create Map | mapOf() |
| Create MutableMap | mutableMapOf() |
| Add item | add() |
| Remove item | remove() |
| Clear collection | clear() |
| Check size | size |
| Check item | contains() |
| Transform items | map() |
| Filter items | filter() |
| Find item | find() |
| Sort | sorted() |
| Remove duplicates | distinct() |
| Remove nulls | filterNotNull() |
| Convert to List | toList() |
| Convert to Set | toSet() |
Frequently Asked Questions
What are collections in Kotlin?
Kotlin collections are structures used to store and manage multiple values. The most commonly used collections are List, Set, and Map.
What is a List in Kotlin?
A List is an ordered collection that allows duplicate values and supports index-based access.
val names = listOf("Rahul", "Priya", "Rahul")
What is a Set in Kotlin?
A Set stores unique values and does not keep duplicate elements as separate entries.
val numbers = setOf(1, 2, 2, 3)
What is a Map in Kotlin?
A Map stores data as key-value pairs.
val users = mapOf(
1 to "Rahul",
2 to "Priya"
)
What is the difference between List and Set in Kotlin?
A List preserves order and allows duplicates, while a Set is designed for unique elements.
What is the difference between List and Map?
A List accesses elements primarily by index, while a Map accesses values using keys.
What is a MutableList?
A MutableList is a list that can be modified after creation.
val names = mutableListOf("Rahul", "Priya")
names.add("Amit")
Can Kotlin collections contain null values?
Yes. You can explicitly define nullable elements:
val names: List<String?> = listOf(
"Rahul",
null
)
Which Kotlin collection should I use?
Use List when order matters, Set when uniqueness matters, and Map when you need key-value relationships.
Are Kotlin collections mutable by default?
No. Functions such as listOf(), setOf(), and mapOf() create read-only collection interfaces. Use mutableListOf(), mutableSetOf(), or mutableMapOf() when you need to modify them.
Conclusion
Kotlin Collections make it much easier to work with groups of data.
The three most important collection types are:
List
↓
Ordered values + duplicates allowed
Set
↓
Unique values
Map
↓
Key-value pairs
For beginners, remember these simple rules:
- Use List when order matters.
- Use Set when duplicate values should be avoided.
- Use Map when data needs to be associated with keys.
- Use mutable collections only when you need to change them.
- Use functions such as
map(),filter(),find(), andsorted()to process collections efficiently.
Once you understand Kotlin Collections, you’ll be able to work much more effectively with API responses, database records, user data, product lists, Android UI data, and other real-world application data.
