Kotlin ArrayList

ArrayList provides implementation for MutableList interface in Kotlin. It comes under List collection. In this tutorial we will go through features of ArrayList in Kotlin.

Creating an array list
We can create an array list using arrayListOf builtin function. We created String theory of empty cosmos below. Excuse the pun.

fun main(args: Array<String>)
{
    var cosmos = arrayListOf<String>()
}

In the following example, we are creating an arraylist with list of planets and then printing the arraylist.

fun main(args: Array<String>)
{
    var planets = arrayListOf<String>("Mercury", "Venus", "Earth", "Pluto")

    println(planets)
}

Output:
[Mercury, Venus, Earth, Pluto]

Iterating an ArrayList
We can use for loop to iterate through an arraylist in Kotlin. In the following example, we are iterating through array list of planets and printing each planet.

fun main(args: Array<String>)
{
    var planets = arrayListOf<String>("Mercury", "Venus", "Earth", "Pluto")

    for(planet in planets)
    {
        println(planet)
    }
}

Output:
Mercury
Venus
Earth
Pluto

Adding elements to an existing ArrayList
We can use method addAll to add a list of elements to array list. In the following example, we are adding more planets to our list of planets using addAll method.

fun main(args: Array<String>)
{
    var planets = arrayListOf<String>("Mercury", "Venus", "Earth", "Pluto")
    planets.addAll(listOf("Jupiter", "Saturn"))

    for(planet in planets)
    {
        println(planet);
    }
}

Output:
Mercury
Venus
Earth
Pluto
Jupiter
Saturn

Adding element to end of an ArrayList
We can add elements to end of an ArrayList using add function call. In the below example, we are using add method to add Jupiter to the end of planets list.

fun main(args: Array<String>)
{
    var planets = arrayListOf<String>("Mercury", "Venus", "Earth", "Pluto")
    planets.add("Jupiter");

    for(planet in planets)
    {
        println(planet);
    }
}

Output:
Mercury
Venus
Earth
Pluto
Jupiter

Adding element to middle of an ArrayList
We can use add method, specifying an index where to add the element followed by the element. This accomplishes adding element to that location. In the below example, we are using add method to insert Jupiter in between the ArrayList.

fun main(args: Array<String>)
{
    var planets = arrayListOf<String>("Mercury", "Venus", "Earth", "Pluto")
    planets.add(2, "Jupiter");

    for(planet in planets)
    {
        println(planet);
    }
}

Output:
Mercury
Venus
Jupiter
Earth
Pluto

Checking for element in ArrayList
We can use contains method to check if ArrayList contains the element or not. In the below example, we are checking if ArrayList contains the planet Pluto.

fun main(args: Array<String>)
{
    var planets = arrayListOf<String>("Mercury", "Venus", "Earth", "Jupiter")

    if(planets.contains("Pluto"))
    {
        println("Pluto is a Planet!")
    }
    else
    {
        println("Pluto is NOT a Planet!")
    }
}

Output:
Pluto is NOT a Planet!

Removing element from ArrayList
We can use remove method to remove an element from ArrayList. In the below example, we are removing the planet Pluto from the ArrayList of planets.

fun main(args: Array<String>)
{
    var planets = arrayListOf<String>("Mercury", "Venus", "Earth", "Pluto")
    planets.remove("Pluto")

    for(planet in planets)
    {
        println(planet)
    }
}

Output:
Mercury
Venus
Earth

What will happen if the element we try to remove is not present in the ArrayList? Nothing, it just does not remove anything. In the below example, we are trying to remove Jupiter from list of planets, even though Jupiter is not present in the ArrayList of planets.

fun main(args: Array<String>)
{
    var planets = arrayListOf<String>("Mercury", "Venus", "Earth", "Pluto")
    planets.remove("Jupiter")

    for(planet in planets)
    {
        println(planet)
    }
}

Output:
Mercury
Venus
Earth
Pluto

We can remove list of planets altogether using removeAll method. We just need to pass collection of planets to remove. In the below example, we using removeAll method to remove Earth and Pluto from the arraylist of planets.

fun main(args: Array<String>)
{
    var planets = arrayListOf<String>("Mercury", "Venus", "Earth", "Pluto")
    planets.removeAll(listOf("Earth", "Pluto"))

    for(planet in planets)
    {
        println(planet)
    }
}

Output:
Mercury
Venus

We can remove an element at a particular index using removeAt method. In the following example, we are using removeAt method to remove the second element from the planet list.

fun main(args: Array<String>)
{
    var planets = arrayListOf<String>("Mercury", "Venus", "Earth", "Pluto")
    planets.removeAt(2)

    for(planet in planets)
    {
        println(planet)
    }
}

Output:
Mercury
Venus
Pluto

We can remove elements if a certain condition is met, using a predicate filter. For this Kotlin provides removeIf function. In the below example, we check for the condition of planet name starts with E, and only those planets we remove from the list.

fun main(args: Array<String>)
{
    var planets = arrayListOf<String>("Mercury", "Venus", "Earth", "Pluto", "Eldorado")
    planets.removeIf { x -> x.startsWith("E") }

    for(planet in planets)
    {
        println(planet)
    }
}

Output:
Mercury
Venus
Pluto

Reversing an ArrayList
We can reverse the elements in place for the ArrayList using reverse function. In the below example, we are reversing the planets arraylist and printing the arraylist.

fun main(args: Array<String>)
{
    var planets = arrayListOf<String>("Mercury", "Venus", "Earth", "Pluto")
    planets.reverse()

    for(planet in planets)
    {
        println(planet)
    }
}

Output:
Pluto
Earth
Venus
Mercury

If we don't want to touch the original ArrayList and we would like to reverse the list into another arraylist instead, we can use reversed function. In the following example we are reversing the arraylist and collecting the result into another List.

fun main(args: Array<String>)
{
    var planets = arrayListOf<String>("Mercury", "Venus", "Earth", "Pluto")
    var planetsReversed = planets.reversed()

    println("Original Planets = ")
    for(planet in planets)
    {
        println(planet)
    }

    println("\n\nPlanets Reversed = ")
    for(planet in planetsReversed)
    {
        println(planet)
    }
}

Output:
Original Planets =
Mercury
Venus
Earth
Pluto

Planets Reversed =
Pluto
Earth
Venus
Mercury

Clearing an ArrayList
We can clear the contents of ArrayList using clear function. In the following example, we are using the clear function to clear the contents of the ArrayList. We also demonstrate a property of ArrayList called size. size property can be used to find out the number of elements in the arraylist.

fun main(args: Array<String>)
{
    var planets = arrayListOf<String>("Mercury", "Venus", "Earth", "Pluto")
    planets.clear()

    for(planet in planets)
    {
        println(planet)
    }
    println("Size of arraylist = " + planets.size)
}

Output:
Size of arraylist = 0

Count of elements in ArrayList
We can get the count of elements in ArrayList using count function. In the below example, we are using the count function to get the count for the number of planets in the ArrayList.

fun main(args: Array<String>)
{
    var planets = arrayListOf<String>("Mercury", "Venus", "Earth", "Pluto")

    println("Count of elements in arraylist = " + planets.count())
}

Output:
Count of elements in arraylist = 4

We can also pass a predicate filter to count function, if we want to get count based on some condition. In the following example, we are counting the number of planets that start with the letter E.

fun main(args: Array<String>)
{
    var planets = arrayListOf<String>("Mercury", "Venus", "Earth", "Pluto", "Eldorado")
    var numOfPlanetsStartingWithE = planets.count { x -> x.startsWith("E") }

    println("Count of planets starting with E in arraylist = " + numOfPlanetsStartingWithE)
}

Output:
Count of elements in arraylist = 2

Remove duplicates from ArrayList
We can remove duplicate elements from ArrayList and get a new List, using distinct function. In the below example, we have some duplicate entries in our planets arraylist. We then used distinct function call to get a new list without the duplicates.

fun main(args: Array<String>)
{
    var planets = arrayListOf<String>("Mercury", "Venus", "Earth", "Earth", "Venus", "Pluto")
    var uniquePlanets = planets.distinct()

    for(planet in uniquePlanets)
    {
        println(planet)
    }
}

Output:
Mercury
Venus
Earth
Pluto

Check if ArrayList is empty
We can check for emptiness of an ArrayList using isEmpty function. In the following example, we check if arraylist of planets is empty or not and print a message accordingly.

fun main(args: Array<String>)
{
    var planets = arrayListOf<String>("Mercury", "Venus", "Earth", "Earth", "Venus", "Pluto")
    planets.clear()

    if(planets.isEmpty())
    {
        println("Planets list is empty!")
    }
    else
    {
        println("Planets list is NOT Empty!")
    }
}

Output:
Planets list is empty!

Maximum value in ArrayList
We can use the max function on arraylist to find the maximum element. In the below example, we used max function to determine the highest integer in our arraylist.

fun main(args: Array<String>)
{
    var numbers = arrayListOf<Int>(21, 44, 99, 74, 33)
    var maxValue = numbers.max()

    println("ArrayList Max value = " + maxValue)
}

Output:
ArrayList Max value = 99

Minimum value in ArrayList
We can use the min function on arraylist to find the minimum element. In the below example, we used min function to determine the smallest integer in our arraylist.

fun main(args: Array<String>)
{
    var numbers = arrayListOf<Int>(21, 44, 99, 74, 33)
    var minValue = numbers.min()

    println("ArrayList Min value = " + minValue)
}

Output:
ArrayList Min value = 21

Retrieve data from ArrayList
We can use the get function to get value at a given index. In the following example, we used get function to retrieve the value at position 2 of the arraylist.

fun main(args: Array<String>)
{
    var numbers = arrayListOf<Int>(21, 44, 99, 74, 33)
    var value = numbers.get(2)

    println("value = " + value)
}

Output:
value = 99

We can use indexOf function to get the index position of a particular element. In the following example, we used indexOf to get the index position for 99.

fun main(args: Array<String>)
{
    var numbers = arrayListOf<Int>(21, 44, 99, 74, 33)
    var value = numbers.indexOf(99)

    println("value = " + value)
}

Output:
value = 2