lambda语法在Java中已经被广泛的运用,我们在开发Android中几乎上每一个项目也会在项目中接入Lambda插件,因为Lambda确实能简少很多的代码量。
目前创新互联建站已为1000多家的企业提供了网站建设、域名、网络空间、网站运营、企业网站设计、七星关区网站维护等服务,公司将坚持客户导向、应用为本的策略,正道将秉承"和谐、参与、激情"的文化,与客户和合作伙伴齐心协力一起成长,共同发展。
无独有偶,在Kotlin中也是Lambda语法的,在这篇文章中就详细的为大家讲解Lambda语法的编写与使用
- fun
lock(lock: Lock, body: () -> T): T { - lock.lock()
- try {
- return body()
- }
- finally {
- lock.unlock()
- }
- }
body 拥有函数类型:() -> T,所以它应该是一个不带参数并且返回 T 类型值的函数。它在 try{: .keyword }-代码块内部调用、被 lock 保护,其结果由lock()函数返回。如果我们想调用lock()函数,我们可以把另一个函数传给它作为参数(参见函数引用)
函数类型,基本规则如下:
(String,Int) -> Unit
现在将上述函数类型添加到某个函数的参数声明或者返回值声明上,那么这个函数就是一个高阶函数了,例如
fun example(func: (String, Int) -> Unit) {
func("hello", 123)
}
可以看到这里的 example() 函数接收到了一个函数类型参数,因此 example() 函数就是一个高阶函数;
这里我准备定义一个叫作 num1AndNum2() 的高阶函数,让它接收两个整形和一个函数类型的参数。我们会在 num1AndNum2() 函数中对传入的两个整型参数进行某种运算,并返回运行结果。但具体进行什么运算是由传入的函数类型参数决定的
新建一个名为 Test1.kt 文件
- fun num1AndNum2(num1:Int,num2:Int,operation:(Int,Int)->Int):Int{
- val result = operation(num1,num2)
- return result
- }
- fun plus(num1: Int, num2: Int): Int {
- return num1 + num2
- }
- fun minus(num1: Int, num2: Int): Int {
- return num1 - num2
- }
- main() 函数
- fun main(){
- val num1 = 100
- val num2 = 80
- val result1 = num1AndNum2(num1,num2, ::plus)
- val result2 = num1AndNum2(num1,num2,::minus)
- println("result1:"+result1)
- println("result2:"+result2)
- }
- result1:180
- result1:20
::plus 和 ::minus 的写法,这是一种函数引用方式的写法,表示将 plus() 和 minus() 函数作为参数传递给 num1AndNum2() 函数
如果每次调用任何高阶函数时都还得先定义一个与其函数类型参数相匹配的函数,是不是太复杂了?没错,因此 Kotlin 还支持其他多种方式来调用高阶函数,比如 Lambda 表达式、匿名函数、成员引用等。其中 Lambda 表达式是最常见也是最普遍的高阶函数调用方式,刚才的代码使用 Lambda 表达式来实现(Lambda 表达式最后一行自动作为返回值),plus() 和 minus() 函数可以删掉了
- fun main() {
- val num1 = 100
- val num2 = 80
- val result1 = num1AndNum2(num1, num2) { n1, n2 ->
- n1 + n2
- }
- val result2 = num1AndNum2(num1, num2) { n1, n2 ->
- n1 - n2
- }
- println("result1:" + result1)
- println("result2:" + result2)
- }
- fun num1AndNum2(num1: Int, num2: Int, operation: (Int, Int) -> Int): Int {
- val result = operation(num1, num2)
- return result
- }
闭包函数 一个函数的返回值是函数,函数的内部包含另一个函数,可以是有参无参的匿名函数
- fun main(args: Array
) { - val mm = aaa()
- println(mm())
- println(mm())
- println(mm())
- println(mm())
- println(mm())
- val kk = bbb()
- println(kk("shadow")) //shadow --- 1
- println(kk("shadow")) //shadow --- 2
- println(kk("shadow")) //shadow --- 3
- println(kk("shadow")) //shadow --- 4
- println(kk("shadow")) //shadow --- 5
- }
- //闭包函数 就是函数作为返回参数
- fun aaa(): () -> (Int) {
- var current = 10
- return fun(): Int {
- return current++
- }
- }
- fun bbb(): (String) -> (String) {
- var current = 0;
- return fun(str: String): String {
- current++;
- return "$str --- $current";
- }
- }
map 变换
- fun main(args: Array
) { - val list = listOf(1, 2, 3, 4, 5, 6)
- val newList = list.map {
- //对集合中的数据进行操作,然后赋值给新的集合
- (it * 2).toString()
- }.forEach(::println) //2 4 6 8 10 12
- val doubleList = list.map {
- it.toDouble()
- }.forEach(::print) //1.0 2.0 3.0 4.0 5.0 6.0
- //函数作为参数的第二种方式调用 类名::方法名
- val doubleList2 = list.map(Int::toDouble).forEach(::print) ////1.0 2.0 3.0 4.0 5.0 6.0
- }
flatMap 对集合的集合进行变换
- fun main(args: Array
) { - val list = arrayOf(
- 1..5,
- 50..55
- )
- //把多个数组集合变成一个数组,并且对数据进行变换
- val mergeList = list.flatMap { intRange -> //集合内的集合 1..5 , 50..55
- intRange.map { intElement -> //集合内集合遍历 1,2,3,4,5
- "No.$intElement"
- }
- }
- //No.1 , No.2 , No.3 , No.4 , No.5 , No.50 , No.51 , No.52 , No.53 , No.54 , No.55 ,
- mergeList.forEach { print("$it , ") }
- println()
- //直接多个数组集合变换成一个结集合
- val newList = list.flatMap {
- it
- }
- //1 , 2 , 3 , 4 , 5 , 50 , 51 , 52 , 53 , 54 , 55 ,
- newList.forEach { print("$it , ") }
- }
filter 筛选
- fun main(args: Array
) { - val list = arrayOf(
- 1..5,
- 2..3
- )
- val newList = list.flatMap {
- it
- }
- //筛选 集合中数据 > 2的item
- val filterList = newList.filter { it > 2 }
- filterList.forEach(::print) //3453
- //筛选 集合中下标是奇数item
- val filterIndexList = newList.filterIndexed { index, i -> index % 2 == 0; }
- filterIndexList.forEach { print(it) } //1 3 5 3
- }
forEach
- fun main(args: Array
) { - var list = listOf(1, 2, 3, 4, 5, 6)
- list.forEach(::println)
- val newList = arrayListOf
() --->1,2,3,4,5,6 - list.forEach {
- newList.add((it * 2).toString()) --->2,4,6,8,10,12
- }
- newList.forEach(::println)
- }
下面我们就来介绍Lambda
Lambda表达式基础语法结构如下:
- (parameters) -> expression
- 或
- (parameters) ->{ statements; }
其中 () 用来描述参数列表,{} 用来描述方法体,-> 为 lambda运算符 ,读作(goes to),parameters表示参数,expression表示表达式,statements表示代码块。
结构说明如下:
一个 Lambda 表达式可以有零个或多个参数
参数的类型既可以明确声明,也可以根据上下文来推断。
例如:
(int a)与(a)效果相同
所有参数需包含在圆括号内,参数之间用逗号相隔。
例如:
- (a, b) 或 (int a, int b) 或 (String a, int b, float c)
空圆括号代表参数集为空。例如:() -> 42
当只有一个参数,且其类型可推导时,圆括号()可省略。
例如:a -> return a*a
Lambda 表达式的主体可包含零条或多条语句
如果 Lambda 表达式的主体只有一条语句,花括号{}可省略。匿名函数的返回类型与该主体表达式一致;
如果 Lambda 表达式的主体包含一条以上语句,则表达式必须包含在花括号{}中(形成代码块)。匿名函数的返回类型与代码块的返回类型一致,若没有返回则为空;
①什么是函数式接口
函数式接口在java中是指只有一个抽象方法的接口。
函数式接口,就是适用于函数式编程场景的接口。在java中函数式编程就体现在Lambda,因此函数式接口就是能够适用于lambda使用的接口。只有确保接口中有且仅有一个抽象方法,lambda才能进行顺利的推导;
②语法
@FunctionalInterface注解
注解和@override注解的作用类似。该住处应用于函数式接口的定义上。
一旦使用了该注解来定义函数式接口,编译器就会检查该接口是否是有且仅有一个抽象方法
- @FunctionalInterface
- public interface MyFunctionalInterface {
- void myMethod();
- }
- 将函数式接口作为方法的参数
- public class Demo {
- private static void dos(FunctionInterface fi){
- fi.method();
- }
- public static void main(String[] args) {
- Demo.dos(()->{System.out.println("lambda表达式");});
- }
表达式基本使用案例
- // 1. 不需要参数,返回值为 5
- () -> 5
- // 2. 接收一个参数(数字类型),返回其2倍的值
- x -> 2 * x
- // 3. 接受2个参数(数字),并返回他们的差值
- (x, y) -> x – y
- // 4. 接收2个int型整数,返回他们的和
- (int x, int y) -> x + y
- // 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
- (String s) -> System.out.print(s)
- 定义6个接口,后面我们都会基于这6个接口来演示案例
- /**多参数无返回*/
- @FunctionalInterface
- public interface NoReturnMultiParam {
- void method(int a, int b);
- }
- /**无参无返回值*/
- @FunctionalInterface
- public interface NoReturnNoParam {
- void method();
- }
- /**一个参数无返回*/
- @FunctionalInterface
- public interface NoReturnOneParam {
- void method(int a);
- }
- /**多个参数有返回值*/
- @FunctionalInterface
- public interface ReturnMultiParam {
- int method(int a, int b);
- }
- /** 无参有返回*/
- @FunctionalInterface
- public interface ReturnNoParam {
- int method();
- }
- /**一个参数有返回值*/
- @FunctionalInterface
- public interface ReturnOneParam {
- int method(int a);
- }
- 案例代码:
- public class Test2 {
- public static void main(String[] args) {
- //1.简化参数类型,可以不写参数类型,但是必须所有参数都不写
- NoReturnMultiParam lamdba1 = (a, b) -> {
- System.out.println("简化参数类型");
- };
- lamdba1.method(1, 2);
- //2.简化参数小括号,如果只有一个参数则可以省略参数小括号
- NoReturnOneParam lambda2 = a -> {
- System.out.println("简化参数小括号");
- };
- lambda2.method(1);
- //3.简化方法体大括号,如果方法条只有一条语句,则可以省略方法体大括号,类似if或for
- NoReturnNoParam lambda3 = () -> System.out.println("简化方法体大括号");
- lambda3.method();
- //4.如果方法体只有一条语句,并且是 return 语句,则可以省略方法体大括号
- ReturnOneParam lambda4 = a -> a+3;
- System.out.println(lambda4.method(5));
- ReturnMultiParam lambda5 = (a, b) -> a+b;
- System.out.println(lambda5.method(1, 1));
- }
- }
①引用方法的语法为:方法归属者::方法名
注意:静态方法的归属者为类名,普通方法归属者为对象。该代码案例结合最上面的自定义函数式接口:
- public class Exe1 {
- public static void main(String[] args) {
- ReturnOneParam lambda1 = a -> doubleNum(a);
- System.out.println(lambda1.method(3));
- //lambda2 引用了已经实现的 doubleNum 方法
- ReturnOneParam lambda2 = Exe1::doubleNum;
- System.out.println(lambda2.method(3));
- Exe1 exe = new Exe1();
- //lambda4 引用了已经实现的 addTwo 方法
- ReturnOneParam lambda4 = exe::addTwo;
- System.out.println(lambda4.method(2));
- }
- /**
- * 要求
- * 1.参数数量和类型要与接口中定义的一致
- * 2.返回值类型要与接口中定义的一致
- */
- public static int doubleNum(int a) {
- return a * 2;
- }
- public int addTwo(int a) {
- return a + 2;
- }
- }
②构造方法的引用
一般我们需要声明接口,该接口作为对象的生成器,通过 类名::new 的方式来实例化对象,然后调用方法返回对象。
- interface ItemCreatorBlankConstruct {
- Item getItem();
- }
- interface ItemCreatorParamContruct {
- Item getItem(int id, String name, double price);
- }
- public class Exe2 {
- public static void main(String[] args) {
- ItemCreatorBlankConstruct creator = () -> new Item();
- Item item = creator.getItem();
- ItemCreatorBlankConstruct creator2 = Item::new;
- Item item2 = creator2.getItem();
- ItemCreatorParamContruct creator3 = Item::new;
- Item item3 = creator3.getItem(119, "电脑", 5888.88);
- }
- }
使用匿名类与 Lambda 表达式的一大区别在于关键词的使用。
对于匿名类,关键词 this 解读为匿名类,而对于 Lambda 表达式,关键词 this 解读为写就 Lambda 的外部类
1、Lambda和高阶函数理解起来有点绕,需要大量的练习和实验才能慢慢的理解
2、Lambda很深,我们一起来学习进步
分享标题:Android进阶之Kotlin高阶函数和Lambda表达式详细讲解
URL链接:http://www.shufengxianlan.com/qtweb/news22/189972.html
网站建设、网络推广公司-创新互联,是专注品牌与效果的网站制作,网络营销seo公司;服务项目有等
声明:本网站发布的内容(图片、视频和文字)以用户投稿、用户转载内容为主,如果涉及侵权请尽快告知,我们将会在第一时间删除。文章观点不代表本网站立场,如需处理请联系客服。电话:028-86922220;邮箱:631063699@qq.com。内容未经允许不得转载,或转载时需注明来源: 创新互联