Kotlin - 35 - Collections Operations (e.g., flatten, groupBy) in Kotlin

Kotlin offers a powerful set of collection operations that allow you to manipulate, transform, and aggregate data in collections such as lists, sets, and maps. These operations are available as extension functions on collections and provide concise and expressive ways to work with data. In this article, we will explore some essential collection operations in Kotlin, including flatten, groupBy, and more, along with examples of how to use them effectively.

The flatten() Operation

The flatten() operation is used to flatten a collection of nested collections into a single flat collection. It is especially useful when dealing with nested lists or arrays. Here’s an example:


val nestedList = listOf(listOf(1, 2), listOf(3, 4, 5), listOf(6))
val flatList = nestedList.flatten()

In this example, nestedList contains three inner lists. Calling flatten() on it results in flatList containing all the elements from the inner lists as a single flat list: [1, 2, 3, 4, 5, 6].

The groupBy() Operation

The groupBy() operation is used to group elements of a collection by a specified key selector function. It returns a map where each key corresponds to a group of elements that share the same key. Here’s an example:


data class Student(val name: String, val age: Int)
val students = listOf(
    Student("Alice", 20),
    Student("Bob", 22),
    Student("Charlie", 20)
)
val groupedByAge = students.groupBy { it.age }

In this code, groupedByAge will be a map where the keys are ages (20 and 22), and the values are lists of students who have the corresponding age. The result might look like this:


{
    20=[Student(name=Alice, age=20), Student(name=Charlie, age=20)],
    22=[Student(name=Bob, age=22)]
}

The filter() Operation

The filter() operation is used to filter elements from a collection based on a predicate function. It returns a new collection containing only the elements that satisfy the predicate. Here’s an example:


val numbers = listOf(1, 2, 3, 4, 5)
val evenNumbers = numbers.filter { it % 2 == 0 }

In this example, evenNumbers will contain the even numbers from the numbers list: [2, 4].

The map() Operation

The map() operation is used to transform elements in a collection based on a transformation function. It returns a new collection with the transformed elements. Here’s an example:


val numbers = listOf(1, 2, 3, 4, 5)
val squaredNumbers = numbers.map { it * it }

In this example, squaredNumbers will contain the square of each number from the numbers list: [1, 4, 9, 16, 25].

The reduce() Operation

The reduce() operation is used to accumulate elements in a collection using a specified operation. It starts with an initial value and applies the operation sequentially to all elements in the collection. Here’s an example using reduce() to calculate the sum of a list of numbers:


val numbers = listOf(1, 2, 3, 4, 5)
val sum = numbers.reduce { acc, value -> acc + value }

In this example, reduce() adds all the numbers together, resulting in sum being equal to 15.

Other Common Collection Operations

Kotlin provides many other collection operations like flatMap() for flattening nested collections, sorted() for sorting elements, distinct() for removing duplicate elements, and forEach() for iterating over elements. These operations can be combined and used together to perform complex data manipulations efficiently.

Conclusion

Kotlin’s collection operations offer powerful ways to work with data in collections, making it easier to filter, transform, group, and aggregate elements. Whether you need to flatten nested collections, group elements by a key, or perform other data manipulations, Kotlin provides concise and expressive functions to simplify your code. Understanding how to use these collection operations effectively is essential for writing clean and efficient Kotlin code.

Kotlin – 35 – Collections Operations (e.g., flatten, groupBy) in Kotlin