A list is a generic collection of elements. Kotlin has three Collections while List is one of those. The other two collections are Set and Map.
The List is mutable i.e. you cannot add or update the elements in the original list.
If you require to update or add new elements in a list then Kotlin provides MutableList class.
Kotlin Lists main points to note:
- The Kotlin List<out T> is an interface.
- Just like Java, it inherits from the Collection<T>.
- The List<out T> provides operations like size, get, etc. that are read-only.
- The methods for changing a list e.g add, removeAt, replaceAll, etc. are added by MutableList<T> interface.
The section below shows how to initialize and perform operations in mutable and immutable lists.
How to initialize a list in Kotlin?
The read-only list (immutable) can be created by using the listOf() method as shown below:
val a_list = listOf(“Kotlin”, “Programing”, “Language”)
You may also create a list by specifying its type:
val a_list = listOf<String>(“Kotlin”, “Programing”, “Language”)
For creating a mutable list, you may use the mutableListOf() method as follows:
val a_list = mutableListOf(“Kotlin”, “Programing”, “Language”)
Now, let us look at a few useful list methods for performing tasks like accessing elements, iterating through the list, deleting, adding and updating elements (in the case of mutable lists).
An example of creating and accessing a read-only list – the get method
In the example below, a list of five elements is created and then we accessed its elements by using the get() method.
The get() method takes an argument, which is the index in the list. Note that, the index of a list starts at zero. See how it works:
fun main(args: Array<String>) {
val a_list = listOf(5, 10, 15, 20, 25, 30)
println("The element at index 0: " +a_list.get(0))
println("The element at index 2: " +a_list.get(2))
}
The output:
The element at index 0: 5
The element at index 2: 15
You may also access the elements by using double brackets []. See an example below:
fun main(args: Array<String>) {
val a_list = listOf(5, 10, 15, 20, 25, 30)
println("The element at index 1: " +a_list[0])
println("The element at index 3: " +a_list[2])
}
The result:
The element at index 1: 5
The element at index 3: 15
The example of the size property
For knowing how many elements a list has, you may use the size property. The example below shows how to use it:
fun main(args: Array<String>) {
val list_chars = listOf('a', 'b', 'f', 'g', 'k')
println("Size of the list = " +list_chars.size)
}
The output of the above code:
Size of the list = 5
The example of min, max and avg functions of list
Again, I am using a read-only list for showing how these simple functions work.
- The min() function returns the minimum item in the list.
- The max() function returns the maximum item in the list.
- While the and() function returns the average.
The example code shows the usage of all these functions with a list of numeric elements:
fun main(args: Array<String>) {
val list_nums = listOf(100, 200, 50, 70, 300)
println("The minmum value int the list:" +list_nums.min())
println("Maximum value int the list:" +list_nums.max())
println("Average:" +list_nums.average())
}
The result:
The minimum value int the list:50
Maximum value int the list:300
Average:144.0
Getting the total elements in a list by count() method
The count method returns the total number of elements in the list. In the example below, a list is created with a number of numeric items and then I used the count method to get the total number of elements:
fun main(args: Array<String>) {
val list_chars = listOf('a', 'b', 'f', 'g', 'k')
println("Total elements in the list by count = " +list_chars.count())
}
The result:
Total elements in the list by count = 5
The distinct function
A list may contain duplicate elements and in certain scenarios, you may require to get only the unique element in a list. For that, the distinct() function can be used. The list below contains duplicate numeric items and see distinct returns only unique elements:
The code:
fun main(args: Array<String>) {
val list_num = listOf(100, 200, 500, 100, 300, 200, 500)
println("The unique elements in the list: " +list_num.distinct())
}
The output:
The unique elements in the list: [100, 200, 500, 300]
Using drop and dropLast functions example
If you need to get a list with the specified number of items removed from the start or end of the list, you may use the drop and dropLast functions.
- The drop function returns the list with elements except for the n number from the beginning.
- The dropLast also returns a list except for the n number of elements from the last.
See the usage below:
The code:
fun main(args: Array<String>) {
val list_num = listOf(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
println("List after dropping first three elements: " +list_num.drop(3))
println("List after dropping last three elements: " +list_num.dropLast(3))
}
The result:
List after dropping first three elements: [40, 50, 60, 70, 80, 90, 100]
List after dropping last three elements: [10, 20, 30, 40, 50, 60, 70]
Getting the first and last elements example
The first() and last() are the functions that return the first and last elements for the given list, respectively. See the example code below for their usage:
Example code:
fun main(args: Array<String>) {
val list_names = listOf<String>("Hina", "Tina", "Mina", "Mike", "Haynes")
println("First elements in the list: " +list_names.first())
println("Last element: " +list_names.last())
}
The output:
First elements in the list: Hina
Last element: Haynes
Performing changes in the original list – the mutable list example
In all the above examples, we used read-only lists that are immutable. Now let us look at a few examples of modifying the original list.
For creating a mutable list, we can use the mutableListOf() method and then may perform the operations like deleting an item, modifying the existing element etc.
The clear method example
The clear() function removes all elements from the list.
In the example below, I created a mutable list of numbers and then iterated through that list for displaying its elements.
This is followed by using the clear() function and we “iterated” through the list again. See the list before and after using the clear() function:
The code:
fun main(args: Array<String>) {
val List_langs = mutableListOf("Kotlin", "Java", "Python", "C$")
println("########List Before Clear")
for (ele in List_langs) {
println("$ele ")
}
List_langs.clear()
println("########List After Clear")
for (ele in List_langs) {
println("$ele ")
}
}
The output:
Using the remove() function
If you require removing a single instance of the specified element then use the remove() function.
The remove() function is used to delete the first occurrence of the element. See an example below:
The code:
fun main(args: Array<String>) {
val List_langs = mutableListOf("Kotlin", "Java", "Python", "C$")
println("########List Before Remove##########")
for (ele in List_langs) {
println("$ele ")
}
List_langs.remove("Python")
println("########List After Removing Python element##########")
for (ele in List_langs) {
println("$ele ")
}
}
The output:
########List Before Remove##########
Kotlin
Java
Python
C$
########List After Removing Python element##########
Kotlin
Java
C$
You can see, the element “Python” is removed from the list.
The removeAt() function example
Want to remove an item by index? Use the removeAt() function. It takes a parameter which is the index of the element that you intend to remove. Have a look:
The example code:
fun main(args: Array<String>) {
val List_nums = mutableListOf(5, 50, 500, 5000, 50000)
println("########List Before RemoveAt##########")
for (i in 0 until List_nums.size) {
println("${List_nums[i]} ")
}
List_nums.removeAt(2)
println("########List After RemoveAt##########")
for (i in 0 until List_nums.size) {
println("${List_nums[i]} ")
}
}
The output:
########List Before RemoveAt##########
5
50
500
5000
50000
########List After RemoveAt##########
5
50
5000
50000
The second element which value is 500 is removed from the list.
Adding an element example – the add() function
The add() function adds the specified element at the end of the list. You may also add an element at the specified position if the second argument is given.
See a demo below for both cases:
fun main(args: Array<String>) {
val List_subjects = mutableListOf("Phy", "Che", "Bio", "Math")
println("########List Before add function##########")
for (i in 0 until List_subjects.size) {
println("${List_subjects[i]} ")
}
List_subjects.add("History")
println("########List After add function##########")
for (i in 0 until List_subjects.size) {
println("${List_subjects[i]} ")
}
}
The list before and after:
Adding element at the specified position example
fun main(args: Array<String>) {
val List_subjects = mutableListOf("Phy", "Che", "Bio", "Math")
println("########List Before add function##########")
for (i in 0 until List_subjects.size) {
println("${List_subjects[i]} ")
}
List_subjects.add(2, "Zoology")
List_subjects.add(4, "Social Studies")
println("########List After add function##########")
for (i in 0 until List_subjects.size) {
println("${List_subjects[i]} ")
}
}
The output:
########List Before add function##########
Phy
Che
Bio
Math
########List After add function##########
Phy
Che
Zoology
Bio
Social Studies
Math
Adding multiple elements – the addAll() function
The addAll() function adds multiple elements at the end of the list.
Just like add() function, you may also provide the second argument for specifying the position of newly added elements. See the code and output below:
fun main(args: Array<String>) {
val list_num = mutableListOf(1,2,3,4,5,6)
println("########List Before addAll function##########")
for (i in 0 until list_num.size) {
println("${list_num[i]} ")
}
list_num.addAll(listOf(7,8,9,10))
println("########List After addAll function##########")
for (i in 0 until list_num.size) {
println("${list_num[i]} ")
}
}
The result:
########List Before addAll function########## 1 2 3 4 5 6 ########List After addAll function########## 1 2 3 4 5 6 7 8 9 10
A shuffle function example
For randomly re-arranging the elements in a list, you may use the shuffle() function. Be careful as using this function because it changes the original list.
The demo code:
fun main(args: Array<String>) {
val list_num = mutableListOf(1,2,3,4,5,6)
println("Before :" +list_num)
list_num.shuffle()
println("After shuffle: " +list_num)
}
The output as I executed this code:
Before :[1, 2, 3, 4, 5, 6]
After shuffle: [2, 3, 1, 4, 6, 5]
