Kotlin - 10 - Lambda Expressions in Kotlin

Lambda expressions are a powerful feature in Kotlin that allows you to define anonymous functions concisely. They are a fundamental concept in functional programming and can be used for various purposes, including passing functions as arguments, defining operations on collections, and simplifying code. In this guide, we’ll explore lambda expressions in Kotlin, how to use them, and their practical applications.

Lambda Expression Basics

A lambda expression in Kotlin is a block of code that can be treated as an object, assigned to variables, or passed as arguments to functions. It has the following syntax:

{ parameters -> body }

{}: Encloses the lambda expression.
parameters: The input parameters, if any.
->: Separates parameters from the lambda body.
body: The code block to be executed.

Here’s a simple example of a lambda expression that takes two integers and returns their sum:

val sum: (Int, Int) -> Int = { a, b -> a + b }

In this example, sum is a lambda expression that takes two integers a and b and returns their sum as an integer.

Using Lambda Expressions

Lambda expressions can be used in various ways in Kotlin:

1. Function Arguments

You can pass lambda expressions as arguments to functions. This is useful for defining behavior that can be customized by callers. Here’s an example using the filter function to filter even numbers from a list:

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

In this case, the lambda expression { it % 2 == 0 } is used as an argument to filter, which selects even numbers from the numbers list.

2. Variable Assignments

You can assign lambda expressions to variables. This allows you to reuse and reference them as needed. For example:

val square: (Int) -> Int = { it * it }
val result = square(5) // result is 25

In this example, square is a lambda expression that squares an integer, and we later use it to calculate the square of 5.

3. Collections Operations

Lambda expressions are commonly used with collection operations like map, filter, reduce, and forEach. These functions take lambda expressions as arguments to perform operations on elements within a collection. Here’s an example of using map to transform a list of strings:

val names = listOf("Alice", "Bob", "Charlie")
val lengths = names.map { it.length }

In this case, the lambda expression { it.length } is applied to each string in the names list to calculate their lengths, resulting in a list of integers.

4. Sorting

Lambda expressions can also be used for custom sorting logic. For instance, you can sort a list of objects based on a specific property. Here’s an example of sorting a list of people by age:

data class Person(val name: String, val age: Int)

val people = listOf(Person("Alice", 30), Person("Bob", 25), Person("Charlie", 35))
val sortedPeople = people.sortedBy { it.age }

The lambda expression { it.age } is used to extract the age property for sorting.

Capturing Variables

Lambda expressions can capture and access variables from their surrounding scope. These variables are known as captured variables or captured values. Here’s an example:

fun createAdder(x: Int): (Int) -> Int {
    return { y -> x + y }
}

val addFive = createAdder(5)
val result = addFive(3) // result is 8

In this example, the createAdder function returns a lambda expression that captures the x parameter. When we create addFive by calling createAdder(5), it captures the value 5 and can later be used to add 5 to another number.

Command and Example

Here’s an example that demonstrates various uses of lambda expressions in Kotlin:

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6)

    // Using lambda in filter
    val evens = numbers.filter { it % 2 == 0 }
    println("Evens: $evens")

    // Using lambda in map
    val squares = numbers.map { it * it }
    println("Squares: $squares")

    // Using lambda as a variable
    val double: (Int) -> Int = { it * 2 }
    val doubledNumbers = numbers.map(double)
    println("Doubled: $doubledNumbers")

    // Using lambda for custom sorting
    val names = listOf("Alice", "Bob", "Charlie")
    val sortedNames = names.sortedBy { it.length }
    println("Sorted Names: $sortedNames")

    // Capturing variables in lambda
    val x = 10
    val addX = { y: Int -> x + y }
    println("addX(5): ${addX(5)}")
}

This example covers filtering, mapping, assigning lambdas to variables, custom sorting, and capturing variables in lambda expressions. Lambda expressions provide concise and powerful ways to work with functions and functional programming concepts in Kotlin, making your code more expressive and modular.

Kotlin – 10 – Lambda Expressions in Kotlin