Ultimate Kotlin List Guide: A Step-by-Step Tutorial for Beginners

A list in Kotlin is an ordered collection of data(elements) with an unlimited list size. The size of the list can be increased based on elements. We have all usages List in Java as a beginner. A list in Kotlin is very useful because almost every data is processed and stored using a List. If you are a pro developer then you know about the benefits of using List and if you are a beginner then you are about to know using this tutorial. Using a list can significantly enhance your programming technique. In today’s tutorial, we will be going to learn about List initialization, inserting elements in the list, manipulating list items, and much more.

Lists are divided into 2 parts in Kotlin:

1. Immutable List: Immutable lists are a type of list whose elements cannot be modified. This type of list has fast-ready operations and well optimized for mult-threaded operations.
   
   val fruitList = listOf("Apple", "Banana", "Cherry") println(fruitList) // Output: [Apple, Banana, Cherry]

   1 2 3

   val fruitList = listOf("Apple", "Banana", "Cherry")   println(fruitList) // Output: [Apple, Banana, Cherry]

2. Mutable List: In a mutable list we can perform add, update, and delete CURD operations. It is likely slower than an immutable list.
   
   val mutableFruitList = mutableListOf("Apple", "Banana") mutableFruitList.add("Cherry") println(mutableFruitList) // Output: [Apple, Banana, Cherry]

   1 2 3 4 5

   val mutableFruitList = mutableListOf("Apple", "Banana")   mutableFruitList.add("Cherry")   println(mutableFruitList) // Output: [Apple, Banana, Cherry]

Ultimate Kotlin List Guide: A Step-by-Step Tutorial for Beginners

1. Integer List: In a mutable integer list, we can store integer-type values only.
   
   fun main() { // Using a MutableList instead of List val intList: MutableList<Int> = mutableListOf(10, 20, 30, 40) // Accessing elements println(intList[0]) // Output: 10 // Iterating through the list println("\nBefore adding elements dynamically:") for (num in intList) { println(num) } // Adding elements dynamically intList.add(50) intList.add(60) // Iterating again to see the newly added elements println("\nAfter adding elements dynamically:") for (num in intList) { println(num) } } // Output: 10 Before adding elements dynamically: 10 20 30 40 After adding elements dynamically: 10 20 30 40 50 60

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

   fun main() {     // Using a MutableList instead of List     val intList: MutableList<Int> = mutableListOf(10, 20, 30, 40)          // Accessing elements     println(intList[0])  // Output: 10          // Iterating through the list     println("\nBefore adding elements dynamically:")     for (num in intList) {         println(num)     }          // Adding elements dynamically     intList.add(50)     intList.add(60)       // Iterating again to see the newly added elements     println("\nAfter adding elements dynamically:")     for (num in intList) {         println(num)     } }     // Output:   10   Before adding elements dynamically: 10 20 30 40   After adding elements dynamically: 10 20 30 40 50 60

2. String List – Mutable
   
   fun main() { val stringList: MutableList<String> = mutableListOf("Apple", "Banana", "Cherry") // Adding elements dynamically stringList.add("Date") println("String List: $stringList") // Output: String List: [Apple, Banana, Cherry, Date] }

   1 2 3 4 5 6 7 8 9

   fun main() {          val stringList: MutableList<String> = mutableListOf("Apple", "Banana", "Cherry")          // Adding elements dynamically     stringList.add("Date")       println("String List: $stringList")  // Output: String List: [Apple, Banana, Cherry, Date] }

3. Float List – Mutable
   
   fun main() { val floatList: MutableList<Float> = mutableListOf(1.5f, 2.3f, 4.8f) // Adding elements dynamically floatList.add(6.4f) println("Float List: $floatList") // Output: Float List: [1.5, 2.3, 4.8, 6.4] }

   1 2 3 4 5 6 7 8

   fun main() {     val floatList: MutableList<Float> = mutableListOf(1.5f, 2.3f, 4.8f)          // Adding elements dynamically     floatList.add(6.4f)       println("Float List: $floatList")  // Output: Float List: [1.5, 2.3, 4.8, 6.4] }

4. Double Mutable List
   
   fun main() { val doubleList: MutableList<Double> = mutableListOf(10.12, 15.45, 8.95) // Adding elements dynamically doubleList.add(20.25) println("Double List: $doubleList") // Output: Double List: [10.12, 15.45, 8.95, 20.25] }

   1 2 3 4 5 6 7 8

   fun main() {     val doubleList: MutableList<Double> = mutableListOf(10.12, 15.45, 8.95)          // Adding elements dynamically     doubleList.add(20.25)       println("Double List: $doubleList")  // Output: Double List: [10.12, 15.45, 8.95, 20.25] }

5. Boolean Mutable List
   
   fun main() { val boolList: MutableList<Boolean> = mutableListOf(true, false, true) // Adding elements dynamically boolList.add(false) println("Boolean List: $boolList") // Output: Boolean List: [true, false, true, false] }

   1 2 3 4 5 6 7 8

   fun main() {     val boolList: MutableList<Boolean> = mutableListOf(true, false, true)          // Adding elements dynamically     boolList.add(false)        println("Boolean List: $boolList")  // Output: Boolean List: [true, false, true, false] }

6. Character Mutable list
   
   fun main() { val charList: MutableList<Char> = mutableListOf('A', 'B', 'C', 'D') // Adding elements dynamically charList.add('E') println("Character List: $charList") // Output: Character List: [A, B, C, D, E] }

   1 2 3 4 5 6 7 8 9

   fun main() {     val charList: MutableList<Char> = mutableListOf('A', 'B', 'C', 'D')          // Adding elements dynamically     charList.add('E')       println("Character List: $charList")  // Output: Character List: [A, B, C, D, E]   }

7. Custom Model Mutable List: This list is mainly what we will be using in our Kotlin apps where we want to store different types of custom object-related data into our List. In this type of List first, we will create a Custom Model class in Kotlin as per that class we will store our data in List.
   
   // This Person class is same as custom Model class we created in Java. // There is no need to create Getter and Setter in data class. data class Person(val name: String, val age: Int) fun main() { // Mutable list of Person objects val peopleList: MutableList<Person> = mutableListOf( Person("Tom", 30), Person("Bob", 25) ) // Adding elements dynamically peopleList.add(Person("Jay", 35)) peopleList.add(Person("David", 40)) // Getting single object elements. println(peopleList.get(0).age) println(peopleList.get(0).name) peopleList.forEach { println("${it.name}, Age: ${it.age}") } } // Output 30 Tom Tom, Age: 30 Bob, Age: 25 Jay, Age: 35 David, Age: 40

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

   // This Person class is same as custom Model class we created in Java. // There is no need to create Getter and Setter in data class. data class Person(val name: String, val age: Int)   fun main() {     // Mutable list of Person objects     val peopleList: MutableList<Person> = mutableListOf(         Person("Tom", 30),         Person("Bob", 25)     )          // Adding elements dynamically     peopleList.add(Person("Jay", 35))     peopleList.add(Person("David", 40))          // Getting single object elements.     println(peopleList.get(0).age)     println(peopleList.get(0).name)       peopleList.forEach { println("${it.name}, Age: ${it.age}") }    }     // Output   30 Tom Tom, Age: 30 Bob, Age: 25 Jay, Age: 35 David, Age: 40

8. Nullable Mutable List: In a nullable list, we can store NULL values also but we have to pass ? (Question mark) Safe call operator. The? allow us to store a NULL value and make our variable type nullable.
   
   fun main() { val nullableList: MutableList<Int?> = mutableListOf(10, null, 20) // Adding elements dynamically nullableList.add(30) nullableList.add(null) println("Nullable List: $nullableList") // Output: Nullable List: [10, null, 20, 30, null] }

   1 2 3 4 5 6 7 8 9 10

   fun main() {     val nullableList: MutableList<Int?> = mutableListOf(10, null, 20)          // Adding elements dynamically     nullableList.add(30)     nullableList.add(null)       println("Nullable List: $nullableList")  // Output: Nullable List: [10, null, 20, 30, null]   }

In the above example, we have covered most of the mutable list types we will use in our Kotlin program.

The most commonly used List Methods in Kotlin

In my examples, I am using the custom model class list. As a developer, we all know we use a List to store custom types of data which is associated with Model classes. For this example, I am creating a model class Person which has 2 member variables name and age. In Kotlin we do not have to define a constructor, getter & setter in the data class.

1. add(): The add method in List in Kotlin adds an element to List.
   
   fun main() { // Create a mutable list of Person var people = mutableListOf( Person("Jam", 30), Person("Alice", 25), Person("Bob", 35), Person("Cris", 20) ) // 1. `add()` people.add(Person("Eva", 28)) println("After adding Eva: $people") } data class Person(val name: String, val age: Int) // Output After adding Eva: [Person(name=Jam, age=30), Person(name=Alice, age=25), Person(name=Bob, age=35), Person(name=Cris, age=20), Person(name=Eva, age=28)]

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   fun main() {     // Create a mutable list of Person     var people = mutableListOf(         Person("Jam", 30),         Person("Alice", 25),         Person("Bob", 35),         Person("Cris", 20)     )       // 1. `add()`     people.add(Person("Eva", 28))     println("After adding Eva: $people")      }   data class Person(val name: String, val age: Int)     // Output After adding Eva: [Person(name=Jam, age=30), Person(name=Alice, age=25), Person(name=Bob, age=35), Person(name=Cris, age=20), Person(name=Eva, age=28)]

2. remove(): The remove method in List removes the first occurrence of the given element.
   
   fun main() { // Create a mutable list of Person var people = mutableListOf( Person("Jam", 30), Person("Alice", 25), Person("Bob", 35), Person("Cris", 20) ) people.remove(Person("Bob", 35)) println("After removing Bob: $people") } data class Person(val name: String, val age: Int) // Output After removing Bob: [Person(name=Jam, age=30), Person(name=Alice, age=25), Person(name=Cris, age=20)]

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   fun main() {     // Create a mutable list of Person     var people = mutableListOf(         Person("Jam", 30),         Person("Alice", 25),         Person("Bob", 35),         Person("Cris", 20)     )          people.remove(Person("Bob", 35))     println("After removing Bob: $people")      }   data class Person(val name: String, val age: Int)     // Output After removing Bob: [Person(name=Jam, age=30), Person(name=Alice, age=25), Person(name=Cris, age=20)]

3. contains(): Check whether a List contains a specific element if yes then return True otherwise return False.
   
   fun main() { // Create a mutable list of Person var people = mutableListOf( Person("Jam", 30), Person("Alice", 25), Person("Bob", 35), Person("Cris", 20) ) println("Contains Charlie? ${people.contains(Person("Alice", 25))}") } data class Person(val name: String, val age: Int) // Output: Contains Charlie? true

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

   fun main() {     // Create a mutable list of Person     var people = mutableListOf(         Person("Jam", 30),         Person("Alice", 25),         Person("Bob", 35),         Person("Cris", 20)     )          println("Contains Charlie? ${people.contains(Person("Alice", 25))}")      }   data class Person(val name: String, val age: Int)     // Output: Contains Charlie? true

4. get(): The get function in List returns us the item present on a specific Index position.
   
   fun main() { // Create a mutable list of Person var people = mutableListOf( Person("Jam", 30), Person("Alice", 25), Person("Bob", 35), Person("Cris", 20) ) val firstPerson = people[0] println("First person: $firstPerson") } data class Person(val name: String, val age: Int) // Output: First person: Person(name=Jam, age=30)

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   fun main() {     // Create a mutable list of Person     var people = mutableListOf(         Person("Jam", 30),         Person("Alice", 25),         Person("Bob", 35),         Person("Cris", 20)     )          val firstPerson = people[0]     println("First person: $firstPerson")      }   data class Person(val name: String, val age: Int)     // Output: First person: Person(name=Jam, age=30)

5. size(): The size function returns the total length of the List.
   
   fun main() { // Create a mutable list of Person var people = mutableListOf( Person("Jam", 30), Person("Alice", 25), Person("Bob", 35), Person("Cris", 20) ) println("Size of the list: ${people.size}") } data class Person(val name: String, val age: Int) // Output Size of the list: 4

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

   fun main() {     // Create a mutable list of Person     var people = mutableListOf(         Person("Jam", 30),         Person("Alice", 25),         Person("Bob", 35),         Person("Cris", 20)     )          println("Size of the list: ${people.size}")      }   data class Person(val name: String, val age: Int)   // Output Size of the list: 4

6. clear(): Delete all elements from the list.
   
   fun main() { // Create a mutable list of Person var people = mutableListOf( Person("Jam", 30), Person("Alice", 25), Person("Bob", 35), Person("Cris", 20) ) people.clear() println("After clearing: $people") } data class Person(val name: String, val age: Int) // Output After clearing: []

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   fun main() {     // Create a mutable list of Person     var people = mutableListOf(         Person("Jam", 30),         Person("Alice", 25),         Person("Bob", 35),         Person("Cris", 20)     )          people.clear()     println("After clearing: $people")      }   data class Person(val name: String, val age: Int)     // Output After clearing: []

7. sort(): To sort the list as per key.
   
   fun main() { // Create a mutable list of Person var people = mutableListOf( Person("Jam", 30), Person("Alice", 25), Person("Bob", 35), Person("Cris", 20) ) people.sortBy { it.age } println("Sorted by age: $people") } data class Person(val name: String, val age: Int) // Output Sorted by age: [Person(name=Cris, age=20), Person(name=Alice, age=25), Person(name=Jam, age=30), Person(name=Bob, age=35)]

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   fun main() {     // Create a mutable list of Person     var people = mutableListOf(         Person("Jam", 30),         Person("Alice", 25),         Person("Bob", 35),         Person("Cris", 20)     )          people.sortBy { it.age }     println("Sorted by age: $people")      }   data class Person(val name: String, val age: Int)     // Output Sorted by age: [Person(name=Cris, age=20), Person(name=Alice, age=25), Person(name=Jam, age=30), Person(name=Bob, age=35)]

8. filter(): The list filter function returns us a new List containing all the elements that match the given condition or predicate.
   
   fun main() { // Create a mutable list of Person var people = mutableListOf( Person("Jam", 30), Person("Alice", 25), Person("Bob", 35), Person("Cris", 20) ) val adults = people.filter { it.age >= 30 } println("Adults (age >= 30): $adults") } data class Person(val name: String, val age: Int) // Output Adults (age >= 30): [Person(name=Jam, age=30), Person(name=Bob, age=35)]

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   fun main() {     // Create a mutable list of Person     var people = mutableListOf(         Person("Jam", 30),         Person("Alice", 25),         Person("Bob", 35),         Person("Cris", 20)     )          val adults = people.filter { it.age >= 30 }     println("Adults (age >= 30): $adults")      }   data class Person(val name: String, val age: Int)     // Output Adults (age >= 30): [Person(name=Jam, age=30), Person(name=Bob, age=35)]

9. map(): The map function transforms the list elements according to the given function.
   
   fun main() { // Create a mutable list of Person var people = mutableListOf( Person("Jam", 30), Person("Alice", 25), Person("Bob", 35), Person("Cris", 20) ) val names = people.map { it.name } println("Names of people: $names") } data class Person(val name: String, val age: Int) // Output Names of people: [Jam, Alice, Bob, Cris]

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   fun main() {     // Create a mutable list of Person     var people = mutableListOf(         Person("Jam", 30),         Person("Alice", 25),         Person("Bob", 35),         Person("Cris", 20)     )          val names = people.map { it.name }     println("Names of people: $names")      }   data class Person(val name: String, val age: Int)     // Output Names of people: [Jam, Alice, Bob, Cris]

10. forEach(): The for each is to print all the elements of the List one by one.
    
    fun main() { // Create a mutable list of Person var people = mutableListOf( Person("Jam", 30), Person("Alice", 25), Person("Bob", 35), Person("Cris", 20) ) println("All people:") people.forEach { println(it) } } data class Person(val name: String, val age: Int) // Output All people: Person(name=Jam, age=30) Person(name=Alice, age=25) Person(name=Bob, age=35) Person(name=Cris, age=20)

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

    fun main() {     // Create a mutable list of Person     var people = mutableListOf(         Person("Jam", 30),         Person("Alice", 25),         Person("Bob", 35),         Person("Cris", 20)     )          println("All people:")     people.forEach { println(it) }      }   data class Person(val name: String, val age: Int)     // Output All people: Person(name=Jam, age=30) Person(name=Alice, age=25) Person(name=Bob, age=35) Person(name=Cris, age=20)

11. joinToString(): It concatenates the elements of the List into a single string with a given Char or String.
    
    fun main() { // Create a mutable list of Person var people = mutableListOf( Person("Jam", 30), Person("Alice", 25), Person("Bob", 35), Person("Cris", 20) ) val joinedNames = people.joinToString(", ") { it.name } println("Joined names: $joinedNames") } data class Person(val name: String, val age: Int) //Output Joined names: Jam, Alice, Bob, Cris

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

    fun main() {     // Create a mutable list of Person     var people = mutableListOf(         Person("Jam", 30),         Person("Alice", 25),         Person("Bob", 35),         Person("Cris", 20)     )         val joinedNames = people.joinToString(", ") { it.name }     println("Joined names: $joinedNames")      }   data class Person(val name: String, val age: Int)     //Output Joined names: Jam, Alice, Bob, Cris

12. find(): The find List function in Kotlin returns us the first condition matching element. If not found then return Null.
    
    fun main() { // Create a mutable list of Person var people = mutableListOf( Person("Jam", 30), Person("Alice", 25), Person("Bob", 35), Person("Cris", 20) ) val firstAdult = people.find { it.age >= 30 } println("First adult: $firstAdult") } data class Person(val name: String, val age: Int) //Output First adult: Person(name=Jam, age=30)

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

    fun main() {     // Create a mutable list of Person     var people = mutableListOf(         Person("Jam", 30),         Person("Alice", 25),         Person("Bob", 35),         Person("Cris", 20)     )         val firstAdult = people.find { it.age >= 30 }     println("First adult: $firstAdult")      }   data class Person(val name: String, val age: Int)     //Output First adult: Person(name=Jam, age=30)

13. groupBy(): the groupBy method in the list makes groups of the element by a specified key.
    
    fun main() { // Create a mutable list of Person var people = mutableListOf( Person("Jam", 30), Person("Alice", 25), Person("Bob", 35), Person("Cris", 20) ) val groupedByAge = people.groupBy { it.age >= 30 } println("Grouped by age >= 30: $groupedByAge") } data class Person(val name: String, val age: Int) // Output Grouped by age >= 30: {true=[Person(name=Jam, age=30), Person(name=Bob, age=35)], false=[Person(name=Alice, age=25), Person(name=Cris, age=20)]}

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

    fun main() {     // Create a mutable list of Person     var people = mutableListOf(         Person("Jam", 30),         Person("Alice", 25),         Person("Bob", 35),         Person("Cris", 20)     )         val groupedByAge = people.groupBy { it.age >= 30 }     println("Grouped by age >= 30: $groupedByAge")      }   data class Person(val name: String, val age: Int)     // Output Grouped by age >= 30: {true=[Person(name=Jam, age=30), Person(name=Bob, age=35)], false=[Person(name=Alice, age=25), Person(name=Cris, age=20)]}

14. any(): Checks if the element in the list matches the given predicate condition.
    
    fun main() { // Create a mutable list of Person var people = mutableListOf( Person("Jam", 30), Person("Alice", 25), Person("Bob", 35), Person("Cris", 20) ) val hasMinors = people.any { it.age < 18 } println("Are there any minors? $hasMinors") } data class Person(val name: String, val age: Int) //Output Are there any minors? false

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

    fun main() {     // Create a mutable list of Person     var people = mutableListOf(         Person("Jam", 30),         Person("Alice", 25),         Person("Bob", 35),         Person("Cris", 20)     )         val hasMinors = people.any { it.age < 18 }     println("Are there any minors? $hasMinors")      }   data class Person(val name: String, val age: Int)     //Output Are there any minors? false

    
    I have tried my best to explain the most useful list method available in Kotlin. But there are a lot more also available in the official Kotlin documentation. You can read all of them from HERE.