Kotlin Array Vs List: Choosing The Right Collection

What’s the difference between arrays and lists in Kotlin?

If you’ve been coding with Kotlin, you’ve probably used both arrays and lists but may have wondered when to choose one over the other.

In this blog, we’ll break down Kotlin Array vs List so you can understand their key differences and best use cases.

Keep reading to find the right option for your projects!

What is a List in Kotlin?

A list in Kotlin is an ordered collection of elements that can be either mutable or immutable. Lists are part of the Kotlin standard library and are widely used due to their flexibility and ease of use. In a Kotlin list, you can store elements of the same type or, with a generic type parameter, elements of different types. Mutable lists are often preferred in scenarios requiring dynamic resizing, frequent insertion, removal, or modifications.

Immutability and Mutability

In Kotlin, lists come in two flavors:

1. Immutable lists: Created using listOf. You cannot modify their contents after initialization.

Copy
1fun main() {
2    val immutableList = listOf("Apple", "Banana", "Cherry")
3    println(immutableList[0]) // Accessing the first element
4}

2. Mutable lists: Created using mutableListOf. You can insert elements, update elements, or remove elements as needed.

Copy
1fun main() {
2    val mutableList = mutableListOf("Apple", "Banana")
3    mutableList.add("Cherry") // Adding a new element
4    println(mutableList) // Output: [Apple, Banana, Cherry]
5}

Features of List

• Lists maintain the order of elements as they are added.
• Support operations like removing elements, searching for a specified element, and replacing an existing value.
• Lists can hold null elements if the type is declared nullable (e.g., List<String?>).

What is an Array in Kotlin?

An array in Kotlin is a fundamental data structure that stores a fixed-size sequence of elements in contiguous memory locations. Arrays are optimized for performance and are a good choice when the size and type of elements are known in advance, especially in performance-critical applications.

Fixed Size and Type

Unlike lists, arrays have a fixed size, meaning you must specify the number of elements at the time of creation. Additionally, all elements in an array must be of the same type.

Example of creating an array of strings:

Copy
1fun main() {
2    val array = arrayOf("Apple", "Banana", "Cherry")
3    println(array.size) // Output: 3
4}

Features of Array

• Efficient accessing of elements using specific indices.

Copy
1fun main() {
2    val array = arrayOf("Apple", "Banana", "Cherry")
3    println(array[1]) // Accessing the second element: Output: Banana
4}

• Avoid overhead of boxing by directly storing primitive types, consuming less memory compared to lists.

Copy
1fun main() {
2    val intArray = intArrayOf(1, 2, 3, 4)
3    println(intArray[2]) // Accessing the third element: Output: 3
4}

• No resizing: Once created, you cannot add or remove elements from an array, but you can modify specific elements.

Copy
1fun main() {
2    val array = arrayOf("Apple", "Banana", "Cherry")
3    array[1] = "Blueberry" // Updating an element
4    println(array.joinToString()) // Output: Apple, Blueberry, Cherry
5}

Syntax and Usage

Creating and Using Lists

Immutable lists, created using the listOf function, cannot be modified after creation:

Copy
1fun main() {
2    val immutableList = listOf("Apple", "Banana", "Cherry")
3    println(immutableList[0]) // Access the first element
4}

Mutable lists, created using the mutableListOf function, allow adding, removing, or modifying elements. You can also specify the type explicitly, e.g., mutableListOf<String>("Apple", "Banana"):

Copy
1fun main() {
2    val mutableList = mutableListOf("Apple", "Banana")
3    mutableList.add("Cherry") // Adding an element
4    mutableList.removeAt(1) // Removing the second element
5    println(mutableList) // Output: [Apple, Cherry]
6}

Creating and Using Arrays

1. Using arrayOf Function:

Copy
1fun main() {
2    val array = arrayOf("Apple", "Banana", "Cherry")
3    println(array.size) // Output: 3
4}

2. Using Specialized Functions for Primitive Types:

Copy
1fun main() {
2    val intArray = intArrayOf(1, 2, 3)
3    println(intArray[1]) // Output: 2
4}

3. Using Lambda Expressions to Create Arrays:

Copy
1fun main() {
2    val array = Array(5) { it * 2 } // Creates an array [0, 2, 4, 6, 8]
3    println(array.joinToString()) // Output: 0, 2, 4, 6, 8
4}

Performance and Practical Considerations

Memory Usage

• Array: Arrays are stored in contiguous memory locations, which makes them efficient for indexed access and memory usage. Primitive arrays avoid boxing overhead.

Copy
1fun main() {
2    val intArray = intArrayOf(1, 2, 3, 4)
3    println(intArray[2]) // Output: 3
4}

• List: Lists, especially mutable ones, introduce memory overhead due to object references and dynamic resizing capabilities.

Copy
1fun main() {
2    val mutableList = mutableListOf(1, 2, 3, 4)
3    mutableList.add(5)
4    println(mutableList) // Output: [1, 2, 3, 4, 5]
5}

Performance in Different Scenarios

• Arrays are faster for indexed access due to their contiguous memory layout.
• Lists are better suited for scenarios requiring dynamic size and frequent updates, such as filtering or sorting data.

Comparison Table and Conclusion

Final Thoughts and Recommendations

Both lists and arrays are integral to Kotlin’s collection types, with lists providing flexibility for dynamic operations and arrays excelling in performance-critical tasks with fixed datasets.

Choose wisely based on your application needs. Happy coding!