How to Create an Empty List in Kotlin: A Simple Guide

Kotlin, as a modern programming language, offers a robust set of features for working with collections. One such collection type is the list, which can be mutable or immutable. In many scenarios, you might need to work with an empty list, whether it’s initializing a collection, returning an empty result, or avoiding null values in your code.

This blog dives deep into Kotlin's empty list, exploring how to create, use, and manipulate empty lists in Kotlin.

What is an Empty List in Kotlin?

An empty list in Kotlin is simply a list with no elements. It's often used as a placeholder when you don't have any data to populate the list at the time of initialization or when you want to return a list with no items. Kotlin provides a specific way to create an empty list using the emptyList function, which is a part of Kotlin’s standard library.

Why Use an Empty List?

Using an empty list is often preferable to using null because it avoids the potential pitfalls associated with null values, such as null pointer exceptions. By using an empty list, your code becomes more predictable and easier to handle when it comes to iterations, transformations, or when you're implementing functions that should return a list but have no data.

Creating an Empty List in Kotlin

There are several ways to create an empty list in Kotlin, each suited to different use cases. Let's explore the most common methods:

1. Using emptyList Function

The most straightforward way to create an empty list in Kotlin is by using the emptyList function. This function returns a read-only, immutable list that contains no elements.

Copy
val emptyList = emptyList<Int>()
println(emptyList)  // Output: []

The above code snippet shows how to use the emptyList function to create an empty list of integers. Since it’s immutable, you cannot add or modify elements after it’s created.

2. Using listOf Function

Another method to create an empty list in Kotlin is by using the listOf function without passing any elements. This also returns an immutable list.

Copy
val emptyList = listOf<String>()
println(emptyList)  // Output: []

This function definition is similar to emptyList but allows specifying the type directly and is more commonly used when you're dealing with lists initialized with given elements.

3. Using ArrayList Constructor

If you need a mutable list, you can use the ArrayList constructor to create an empty list. This allows you to modify the list by adding or removing elements after its creation.

Copy
val emptyArrayList = ArrayList<String>()
println(emptyArrayList)  // Output: []

4. Using mutableListOf Function

For cases where you need to initialize an empty list that you can modify later, mutableListOf is the go-to function. It creates an empty mutable list that you can add elements to.

Copy
val emptyMutableList = mutableListOf<Double>()
emptyMutableList.add(3.14)
println(emptyMutableList)  // Output: [3.14]

This demonstrates that mutableListOf provides a dynamic array list that can automatically expand as you add elements, giving you the flexibility to create and modify lists on the fly.

Immutable vs. Mutable Lists

Kotlin's collections are divided into immutable lists and mutable lists. An immutable list, such as the one returned by emptyList or listOf, cannot be modified after it's created. This is ideal when you want to guarantee that the data remains constant and cannot be changed by any part of your program.

On the other hand, mutable lists, created with mutableListOf or ArrayList, allow you to add, remove, or modify elements, making them ideal for situations where data needs to change.

Immutable List Example

Mutable List Example

Creating Empty Array Lists

Array lists in Kotlin are part of the ArrayList class, which implements the List interface. You can create an empty array list that is mutable and can automatically expand as you add elements.

Empty Array List Using ArrayList Constructor

This example shows how an empty array list can be created and elements can be added dynamically.

The Singleton Instance of Empty Lists

Kotlin’s emptyList function returns a singleton instance of an immutable list. This means that whenever you call emptyList, you are actually getting the same instance, which is highly efficient because it reduces memory overhead.

This demonstrates that both emptyList1 and emptyList2 refer to the same singleton instance.

Null Safety and Empty Lists

Kotlin encourages avoiding null values by providing constructs like empty lists. If a function returns a list, it’s better to return an empty list rather than null to prevent null pointer exceptions and make your code cleaner and safer.

By using an empty list, you ensure that the returned list will never be null, thus making the function safer and more predictable.

Practical Examples of Using Kotlin Empty List

Example 1: Initializing a Default Parameter with an Empty List

You can use an empty list as a default parameter in function definitions, providing flexibility to the function calls.

Example 2: Filtering Elements and Returning an Empty List

When filtering elements from a list, the function might return an empty list if no elements match the filter condition.

In this example, the filter function can return an empty list when no elements meet the condition.

Conclusion

In this article, we explored the various ways to create and use Kotlin empty lists, including immutable lists with emptyList and listOf, and mutable lists using ArrayList and mutableListOf. Understanding the difference between immutable and mutable lists is crucial, as it determines whether you can modify the list after its creation.

Using a Kotlin empty list helps avoid null values, making your code safer and more predictable. By leveraging Kotlin's powerful list functionalities, you can write cleaner, more efficient code that handles data collections effectively without resorting to nulls.

val immutableList = listOf(1, 2, 3)
println(immutableList)  // Output: [1, 2, 3]
// immutableList.add(4) // Error: Unresolved reference: add

val immutableEmptyList = emptyList<String>()
println(immutableEmptyList)  // Output: []

val mutableEmptyList = mutableListOf<String>()
mutableEmptyList.add("Kotlin")
println(mutableEmptyList)  // Output: [Kotlin]

val emptyArrayList = ArrayList<Int>()
emptyArrayList.add(10)
emptyArrayList.add(20)
println(emptyArrayList)  // Output: [10, 20]

val emptyList1 = emptyList<String>()
val emptyList2 = emptyList<String>()
println(emptyList1 === emptyList2)  // Output: true

fun getItems(): List<String> {
    // Function can return an empty list instead of null
    return emptyList()
}

fun printNames(names: List<String> = emptyList()) {
    if (names.isEmpty()) {
        println("No names provided")
    } else {
        println("Names: $names")
    }
}

printNames()  // Output: No names provided
printNames(listOf("Alice", "Bob"))  // Output: Names: [Alice, Bob]

val numbers = listOf(1, 2, 3, 4, 5)
val evenNumbers = numbers.filter { it % 2 == 0 }
println(evenNumbers)  // Output: [2, 4]

val greaterThanFive = numbers.filter { it > 5 }
println(greaterThanFive)  // Output: []