Java 和 Kotlin Lambda 表达式示例详解

1. 什么是 Lambda 表达式？

Lambda 表达式是一种简洁的函数表达方式，可以把函数作为一个方法的参数，或者将代码块转换为数据传递。Lambda 表达式可以帮助减少样板代码，使代码更简洁、可读性更强。

2. Java Lambda 表达式

2.1 基本语法

Java 中的 Lambda 表达式语法如下：

(parameters) -> expression
(parameters) -> { statements; }

2.2 示例

一个简单的示例，使用 Lambda 表达式实现 Comparator 接口：

Comparator<String> comparator = (s1, s2) -> s1.compareTo(s2);

2.3 使用方法

1. 代替匿名类

// 使用匿名类
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello, world!");
    }
};
// 使用 Lambda 表达式
Runnable runnable = () -> System.out.println("Hello, world!");

2. 结合函数式接口
Java 中的 Lambda 表达式需要配合函数式接口使用，即仅包含一个抽象方法的接口，如 Runnable、Callable、Comparator 等。

例如：

List<String> list = Arrays.asList("a", "b", "c");
list.forEach((String s) -> System.out.println(s));

2.4 注意事项

• Lambda 表达式不能脱离函数式接口单独存在。
• Lambda 表达式的类型在编译时会被推断为目标类型，即函数式接口的类型。
• Lambda 表达式中使用的变量必须是 final 或 effectively final。

3. Kotlin Lambda 表达式

3.1 基本语法

Kotlin 中的 Lambda 表达式语法如下：

{ parameters -> body }

3.2 示例

一个简单的示例，使用 Lambda 表达式排序一个字符串列表：

val list = listOf("banana", "apple", "cherry")
val sortedList = list.sortedBy { it.length }
println(sortedList) // 输出: [apple, banana, cherry]

3.3 使用方法

1. 代替匿名类
Kotlin 中的 Lambda 表达式可以用来代替匿名类：

// 使用匿名类
val runnable = object : Runnable {
    override fun run() {
        println("Hello, world!")
    }
}
// 使用 Lambda 表达式
val runnable = Runnable { println("Hello, world!") }

2. 结合高阶函数
Kotlin 具有许多内置的高阶函数，如 map、filter、forEach 等，这些函数可以接受 Lambda 表达式作为参数。

例如：

val list = listOf(1, 2, 3, 4)
val doubled = list.map { it * 2 }
println(doubled) // 输出: [2, 4, 6, 8]

3.4 注意事项

• Kotlin 中的 Lambda 表达式可以作为变量，传递给函数或从函数返回。
• 可以使用带接收者的 Lambda 表达式，这允许在 Lambda 表达式内部调用接收者对象的方法。
• 使用 it 作为单个参数的默认名称，但也可以显式地命名参数。

4. 底层逻辑

4.1 Java 的实现

在 Java 中，Lambda 表达式编译后会生成一个与目标类型兼容的匿名类。Java 8 引入了 invokedynamic 字节码指令来支持 Lambda 表达式，这提高了 Lambda 表达式的性能。

4.2 Kotlin 的实现

在 Kotlin 中，Lambda 表达式被编译成匿名类，但 Kotlin 编译器会进行优化以减少匿名类的数量。Kotlin 的 Lambda 表达式也是基于 Java 的 invokedynamic 指令实现的，确保与 Java 平台的良好兼容性。

5. 示例项目

下面是一个 Java 和 Kotlin 混合的示例项目，展示如何使用 Lambda 表达式：

Java 代码：

public class Main {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        list.forEach(s -> System.out.println(s));
        // 使用自定义函数式接口
        CustomFunctionalInterface custom = s -> System.out.println("Hello, " + s);
        custom.sayHello("world");
    }
}
@FunctionalInterface
interface CustomFunctionalInterface {
    void sayHello(String name);
}

Kotlin 代码：

fun main() {
    val list = listOf("apple", "banana", "cherry")
    list.forEach { println(it) }
    // 使用自定义函数类型
    val custom: (String) -> Unit = { println("Hello, $it") }
    custom("world")
}

这个示例展示了如何在 Java 和 Kotlin 中使用 Lambda 表达式，如何结合函数式接口或高阶函数，以及如何编写跨语言的代码片段。希望对你有所帮助！

https://github.com/micro3721

前面我有提到：Lambda 表达式不能脱离函数式接口单独存在。前面可能我说的不清楚，补充如下：
这句话的意思是，在 Java 中，lambda 表达式必须与一个函数式接口（functional interface）一起使用，不能单独存在。函数式接口是一个具有单一抽象方法（Single Abstract Method, SAM）的接口，它定义了 lambda 表达式的签名（即参数和返回类型）。

具体来说：

函数式接口定义：
一个函数式接口是一个仅包含一个抽象方法的接口。比如，java.util.function 包中的接口，如 Function<T, R>、Consumer<T>、Supplier<T> 等，都是函数式接口。你也可以定义自己的函数式接口：

@FunctionalInterface
public interface MyFunction {
    void execute();
}

lambda 表达式的使用：
Lambda 表达式是一种简洁的表达方式，用于实现函数式接口的抽象方法。例如：

MyFunction myFunction = () -> System.out.println("Hello, World!");
myFunction.execute();

在上面的代码中，lambda 表达式 () -> System.out.println("Hello, World!") 实现了 MyFunction 接口的 execute 方法。lambda 表达式实际上是一个匿名方法，它只能在与函数式接口的实例一起使用时才有意义。

不能单独存在：
Lambda 表达式不能单独存在的原因是，它需要一个上下文来确定其参数和返回类型。函数式接口提供了这种上下文。脱离了函数式接口，lambda 表达式就无法确定其类型，也无法进行编译。

总结来说，lambda 表达式必须与函数式接口一起使用，函数式接口定义了 lambda 表达式的签名，使得 lambda 表达式可以作为函数式接口的实例进行使用。这就是为什么 lambda 表达式不能脱离函数式接口单独存在的原因。

https://github.com/micro3721

到此这篇关于Java 和 Kotlin Lambda 表达式详解的文章就介绍到这了,更多相关Java 和 Kotlin Lambda 表达式内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！