Lambda表达式👀
1. Lambda表达式
1.1 函数式编程思想概述
- 面向对象思想强调: “必须通过对象的形式来做事情”
- 函数式思想则尽量忽略面向对象的复杂语法: “强调做什么,而不是以什么形式去做”。Lambda表达式就是函数式思想的体现
1.2 体验Lambda表达式
需求:启动一个线程,在控制台输出一句话:多线程程序启动了
方式1:
- 定义一个MyRunnable类实现Runnable接口,重写run()方法
- 创建MyRunnable类的对象
- 创建Thread类的对象,把MyRunnable的对象作为构造参数传递
- 启动线程
方式2:
- 匿名内部类改进
方式3:
- Lambda表达式改进
1.3 Lambda表达式的标准格式
匿名内部类的方式改进
// 改进:匿名内部类
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("多线程程序启动了");
}
}).start();
- 方法形式参数为空,说明调用方法时不需要传递参数
- 方法返回值类型为void,说明方法执行没有结果返回
- 方法体重的内容,是我们具体要做的事情
Lambda表达式的代码分析(更简洁一些,只关注了要做的事情)
// Lambda表达式的方式改进
new Thread(() -> {
System.out.println("多线程程序启动了");
}).start();
- ():里面没有内容,可以看成是方法形式参数为空
- -> : 用箭头指向后面要做的事情
- {}: 包含一段代码,我们称之为代码块,可以看成是方法体中的内容
组成Lambda表达式的三要素:
- 形式参数
- 箭头
- 代码块
Lambda表达式的标准格式
- 格式: (形式参数) -> {代码块}
- 形式参数:如果有多个参数,参数之间用逗号隔开;如果没有参数,留空即可
- -> :由英文中画线和大于符号组成,固定写法。代表指向动作
- 代码块:使我们具体要做的事情,也就是我们以前要写的方法体中的内容
1.4 Lambda表达式的练习
Lambda表达式的使用前提
- 有一个接口
- 接口中有且仅有一个抽象方法
练习1:
定义一个接口(Eatable),里面定义一个抽象方法:void eat();
定义一个测试类(EatableDemo),在测试类中提供两个方法
- useEatable(Eatable e)
- 主方法,在主方法中调用useEatable方法
public static void main(String[] args) {
// 使用Lambda表达式
useEatable(()->{
System.out.println("吃鱼鱼...");
});
}
public static void useEatable(Eatable e) {
e.eat();
}
练习2:
定义一个接口(Flyable),里面定义一个抽象方法void fly(String s)
定义一个测试类(FlyableDemo),在测试类中提供两个方法
- useFlyable(Flyable f)
- 主方法:在主方法中调用useFlyable
public static void main(String[] args) {
useFlyable((String s)->{
System.out.println(s);
System.out.println("hhhhhhhhhhhhhhh");
});
}
public static void useFlyable(Flyable f) {
f.fly("傻了吧,爷会飞!");
}
练习2:
定义一个接口(Addable),里面定义一个抽象方法int add(int x, int y);
定义一个测试类(AddableDemo),在测试类中提供两个方法
- useAddable(Addable a)
- 主方法:在主方法中调用useAddable方法
public static void main(String[] args) {
useAddable((int x, int y) -> {
return x + y;
});
}
public static void useAddable(Addable a) {
int sum = a.add(20, 30);
System.out.println("sum=" + sum);
}
1.5 Lambda表达式的省略模式
省略规则:
- 参数类型可以省略。但是有多个参数的情况下必须全部省略,不能之省略一个。要么都省略,要么都不省略
- 当仅有一个形参时,不仅可以省略掉参数类型,还可以把小括号省略掉
- 如果代码块的语句只有一条,可以省略大括号和分号,甚至是return
1.6 Lambda表达式注意事项
- 使用Lambda必须要有接口,并且要求接口有且仅有一个抽象方法
- 必须有上下文环境,才能推导出Lambda对应的接口
- 根据局部变量的赋值得知Lambda对应的接口:
Runnable r = () -> System.out.println("Lambda表达式");
- 根据调用方法的参数得知Lambda对应的接口:
new Thread(()-> System.out.println("Lambda表达式")).start();
- 根据局部变量的赋值得知Lambda对应的接口:
1.7 Lambda表达式和匿名内部类的区别
- 所需类型不同
- 匿名内部类:可以是接口,也可以是抽象类,还可以是具体类
- Lambda表达式:只能是接口
- 使用限制不同
- 如果接口中有且仅有一个抽象方法,可以使用Lambda表达式,也可以使用匿名内部类
- 如果接口中多于一个抽象方法,那么只能用匿名内部类
- 实现原理不同
- 匿名内部类:编译之后,产生一个单独的.class字节码文件
- Lambda表达式:编译之后,没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成
2. 接口组成更新
2.1 接口组成更新概述
接口的组成
- 常量:
public static final
- 抽象方法:
public abstract
- 默认方法(Java8)
- 静态方法(Java8)
- 私有方法(Java9)
2.2 接口的默认方法
格式:
public default 返回值类型 方法名(参数列表) { //方法体 }
注意事项:
- 默认方法不是抽象方法,所以不强制被重写。但是它可以被重写,重写的时候需要去掉default关键字
- public可以省略,default不能省略
2.3 接口中的静态方法
格式:
public static 返回值类型 方法名(参数列表) { //方法体 }
注意事项:
- 静态方法只能通过接口名称调用,不能通过实现类名或者对象名调用
- public可以省略,但是static不能省略
为什么静态方法只能通过接口名/类名调用?
-
如果一个类实现了多个接口中有相同名称的静态方法,而这些静态方法的内容冲突,那么就会报错。所以静态方法属于接口是安全的。
-
静态只能直接访问静态,不能访问非静态。因为静态在内存中的出现的时间要早于非静态。“前人不知后人”
2.4 接口中的私有方法
Java9中新增了带方法体的私有方法, 这其实在Java8中就埋下了伏笔:Java8允许在接口中定义带方法体的默认方法和静态方法。这就可能会引发一个问题:当两个默认方法或静态方法中包含一段相同的代码实现时,程序必然考虑将这段实现代码抽取成一个共性方法,而这个共性方法是不需要让别人使用的,因此拥有私有给隐藏起来,这就是Java9中增加的私有方法的必然性。
定义格式:
private 返回值类型 方法名(参数列表) { // 方法体 }
private static 返回值类型 方法名(参数列表) { // 方法体 }
3. 方法引用
3.1 体验方法引用
public class MyInterfaceDemo {
public static void main(String[] args) {
usePrintable(s-> System.out.println(s));
// 方法引用符 ::
usePrintable(System.out::println);
// 可推导的就是可省略的
}
public static void usePrintable(Printable p) {
p.printString("Hello");
}
}
3.2 方法引用符
方法引用符
::
该符号为引用运算符,而它所在的表达式称为方法引用
推导与省略
- 如果使用Lambda,那么根据"可推导就是可省略"的原则,无需指定参数类型,也无需指定重载形式,它们都将被自动推导
- 如果使用方法引用,也是同样可以根据上下文进行推导
- 方法引用是Lambda的孪生兄弟
3.3 Lambda表达式支持的方法引用
常见的引用方式:
- 引用类方法
- 引用对象的实例方法
- 引用类的实例方法
- 引用构造器
3.4 引用类方法
引用类方法:其实就是引用类的静态方法
-
格式:
类名::静态方法
-
范例:
Integer::parseInt
-
Lambda表达式被类方法替代的时候,它的形式参数全部传递给了静态方法作为参数
3.5 引用对象的实例方法
引用对象的实例方法:就是引用对象的成员方法
-
格式:
对象::成员方法
-
范例:
"HelloWorld"::toUpperCase
-
Lambda表达式被对象的实例方法替代的时候,它的形式参数会全部传递给该方法作为参数
3.6 引用类的实例方法
引用类的实例方法,实际上就是引用类的成员方法
- 格式:
类名::成员方法
- 范例:
String::substring
截取字符串 - Lambda表达式被类的实例方法替代的时候,第一个参数作为调用者,后面的参数全部传递给该方法作为参数
3.7 引用构造器
引用构造器,其实就是引用构造方法
- 格式:
类名::new
- 范例:
Stundet::new
- Lambda表达式被构造器替代的时候,它的形式参数全部传递给构造器作为形式参数
4. 函数式接口
4.1 函数接口的概述
函数式接口:有且仅有一个抽象方法的接口
Java中的函数式编程体现就是Lambda表达式,所以函数式接口就是可以适用于Lambda表达式的接口
只有确保接口中有且仅有一个抽象方法,Java中的Lmabda才能顺利地进行推导
如何检测一个接口是不是函数接口?
-
@FunctionalInterface
-
放在接口定义的上方:如果是函数式接口,编译通过;如果不是,编译失败
【注意事项】
- 我们自己定义函数式接口的时候,
@FunctionalInterface
是可选的,就算不写这个注解,只要保证满足函数式接口定义的条件,也照样是函数式接口。但是,建议加上该注解
4.2 函数式接口作为方法的参数
需求:
- 定义一个类(RunnableDemo),在类中提供两个方法
- 一个方法是:startThread(Runable r) 方法参数Runnable是一个函数式接口
- 一个方法是主方法,在主方法中调用startThread方法
public static void main(String[] args) {
startThread(() -> {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
});
}
public static void startThread(Runnable r) {
// Thread t = new Thread(r);
// t.start();
// 启动了一个线程
new Thread(r).start();
}
4.3 函数式接口作为方法的返回值
需求:
- 定义一个类(ComparatorDemo),在类中提供两个方法
- 一个方法是:Comparator getComparator() 方法返回值Comparator是一个函数式接口
- 一个方法是主方法,在主方法中调用getComparator方法
public static void main(String[] args) {
// 构造使用的场景
// 定义集合存储字符串元素
ArrayList<String> list = new ArrayList<>();
list.add("cccc");
list.add("aa");
list.add("b");
list.add("ddd");
System.out.println("排序前:" + list);
// Collections.sort(list);
Collections.sort(list, getComparator());
System.out.println("排序后:" + list);
// 使用Lambda表达式
// list.sort((s1, s2) -> {
// return s1.length() - s2.length();
// });
Collections.sort(list, (s1, s2) -> s1.length() - s2.length());
System.out.println("Lambda表达式排序:" + list);
}
private static Comparator<String> getComparator() {
// 匿名内部类
// Comparator<String> comp = new Comparator<String>() {
// @Override
// public int compare(String s1, String s2) {
// return s1.length() - s2.length();
// }
// };
// return comp;
return new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return s1.length() - s2.length();
}
};
}
4.4 常用的函数式接口
- Supplier接口
- Consumer接口
- Predicate接口
- Function接口
4.5 Supplier接口
Supplier:包含一个无参方法
- T get():获得结果
- 该方法不需要参数,它会按照某种实现逻辑(有Lambda表达式实现)返回一个数据
- Supplier接口也被称为生产型接口,如果我们指定了接口的泛型是什么类型,那么接口中的get方法就会生产什么类型的数据供我们使用
练习:
定义一个类(SupplierTest),在方法中提供两个方法
- int getMax(Supplier sup) 用于返回一个int数组中的最大值
- 主方法:调用getMax
4.6 Consumer接口
Consumer:包含两个方法
- void accept(T t):对给定的参数执行此操作
- default Consumer andThen(Consumer after):返回一个组合的Consumer,依次执行次操作,然后执行after操作
- Consumer接口也被称为消费型接口,它消费的数据类型由泛型指定
public class ConsumerDemo {
public static void main(String[] args) {
operatorString("马龙", System.out::println);
// operatorString("马龙", (s) -> {
// System.out.println(new StringBuilder(s).reverse().toString());
// });
operatorString("马龙", (s) -> System.out.println(new StringBuilder(s).reverse().toString()));
System.out.println("=================");
operatorString("张继科", System.out::println, s -> System.out.println(new StringBuilder(s).reverse().toString()));
}
// 定义一个方法,消费一个字符串数据
private static void operatorString(String name, Consumer<String> con1, Consumer<String> con2) {
con1.andThen(con2).accept(name);
}
// 定义一个方法,消费一个字符串数据
private static void operatorString(String name, Consumer<String> con) {
con.accept(name);
}
}
练习:
- String[] array = {“林青霞,30”, “张曼玉,35”, “王祖贤,33”};
- 字符串数组中有多条信息,请按照格式:"姓名:XX,年龄:XX"的格式将信息打印出来
- 要求:
- 把打印姓名的动作作为第一个Consumer接口的Lambda实例
- 把打印年龄的动作作为第二个Consumer接口的Lambda实例
- 将两个Consumer接口按照顺序组合到一起使用
public class ConsumerDemo02 {
public static void main(String[] args) {
String[] array = {"林青霞,30", "张曼玉,35", "王祖贤,33"};
printMessage(array, (String str) -> {
String name = str.split(",")[0];
System.out.print("姓名:" + name + ",");
}, (String str) -> {
String name = str.split(",")[1];
System.out.println("姓名:" + name);
});
}
private static void printMessage(String[] strArray, Consumer<String> con1, Consumer<String> con2) {
for (String str : strArray) {
con1.andThen(con2).accept(str);
}
}
}
4.7 Predicate接口
Predicate:常用的四个方法
- boolean test(T t):对给定的参数进行判断(判断逻辑有Lambda表达式实现),返回一个boolean值
- default Prediacte negate():返回一个逻辑的否定,对应逻辑非
- default Prediacte and(Prediacte other):返回一个组合判断,对应短路与
- default Prediacte or(Prediacte other):返回一个组合判断,对应短路或
- Prediacte 接口通常用于判断参数是否满足某种条件
练习
- String[] strArray = {“林青霞,30”, “柳岩,34”, “张曼玉,35”, “貂蝉,31”, “王祖贤,33”};
- 字符串数组中有多条信息,请通过Predicate接口的拼接将符合要求的字符串筛选到集合ArrayList中,并遍历ArrayList集合
- 同时满足如下要求:姓名长度大于2;年龄大于3
public class PredicatePractice {
public static void main(String[] args) {
String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};
ArrayList<String> info =
getInfo(strArray, s -> s.split(",")[0].length() > 2,
s -> Integer.parseInt(s.split(",")[1]) > 33);
System.out.println("list=" + info);
}
private static ArrayList<String> getInfo(String[] arr, Predicate<String> pre1, Predicate<String> pre2) {
ArrayList<String> list = new ArrayList<>();
for (String s : arr) {
if (pre1.and(pre2).test(s)) list.add(s);
}
return list;
}
}
4.8 Function接口
Function<T, R>:常用的两个方法
- R apply(T t):将此函数应用于给定的参数
- default Funciton andThen(Function after):返回一个组合函数,首先将该函数应用于输入,然后将after函数引用语结果
- Function<T, R> 接口通常用于对参数进行处理,转换(处理逻辑由Lmabda表达式实现),然后返回一个新的值
public class FunctionDemo {
public static void main(String[] args) {
stringToInteger("123", Integer::parseInt);
System.out.println("============");
intToString(123, i1 -> i1 + 100, i1 -> Integer.toString(i1));
}
// 把一个字符串转换为int类型,在控制台输出
private static void stringToInteger(String str, Function<String, Integer> fun) {
Integer i = fun.apply(str);
System.out.println(i);
System.out.println(i.getClass());
}
// 把一个int行的数据加上一个整数之后,转为字符串在控制台输出
private static void intToString(int num, Function<Integer, Integer> fun1, Function<Integer, String> fun2) {
String s = fun1.andThen(fun2).apply(num);
System.out.println(s);
System.out.println(s.getClass());
}
}
练习
- String s = “林青霞,30”;
- 按照如下要求操作:
- 将字符串截取到数字年龄部分
- 将上一步的年龄字符串转换成int数据类型
- 将上一步的int数据+70,得到一个int结果,在控制台输出
- 请通过Function接口来实现函数拼接
public class FunctionPractice {
public static void main(String[] args) {
String s = "林青霞,30";
method(s, str -> Integer.parseInt(str.split(",")[1]), i -> i + 70);
}
private static void method(String str, Function<String, Integer> fun1, Function<Integer, Integer> fun2) {
Integer i = fun1.andThen(fun2).apply(str);
System.out.println(i);
}
}