Java8引入的 Lambda 表达式也称为闭包,是推动Java8发布的最重要的新特性。Lambda 是一个匿名函数,主要作用就是简化部分匿名内部类的写法。我们可以把 Lambda表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。使用 Lambda表达式可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格,它使Java的语言表达能力得到了提升。
1、Lambda新特性简介
Java8中引入了一个新的操作符,“->”,该操作符称为箭头操作符或者Lambda操作符,箭头操作符将Lambda表达式拆分成两部分;
- 左侧: Lambda表达式的参数列表,对应的是接口中抽象方法的参数列表;
- 右侧: Lambda表达式中所需要执行的功能(Lambda体),对应的是对抽象方法的实现;
- Lambda表达式的实质是对接口的实现,能够使用 Lambda 表达式的一个重要依据是必须有相应的函数接口(lambda表达式必须和接口进行绑定);
- 所谓函数式接口(function interface),是指内部有且仅有一个抽象方法的接口。
- Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)。
- Lambda 表达式有一个类型推断机制,在上下文信息足够的情况下,编译器可以推断出参数表的类型,而不需要显式指定。
1.1 Lambda语法
lambda 表达式的语法格式如下:
(parameters) -> expression
或
(parameters) ->{ statements; }
分情况语法示范:
(1)语法格式一:无参,无返回值,Lambda 体只需一条语句
示例:Runnable r1 = () -> System.out.println("Hello Lambda!");
(2)语法格式二:Lambda 需要一个参数
示例:Consumer<String> con = (x) -> System.out.println(x);
(3)语法格式三:Lambda 只需要一个参数时,参数的小括号可以省略
示例:Consumer<String> con = x -> System.out.println(x);
(4)语法格式四:Lambda 需要两个参数,并且有返回值
示例:
Comparator<Integer> com = (x, y) -> {
System.out.println("函数式接口");
return Integer.compare(x, y);
};
(5)语法格式五:当 Lambda 体只有一条语句时,return 与大括号可以省略
示例:Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
(6)Lambda 表达式的参数列表的数据类型可以省略不写,因为JVM编译器通过上下文推断出,数据类型,即“类型推断”
示例:
Comparator<Integer> com = (Integer x,Integer y) -> { //Integer 类型可以省略
System.out.println("函数式接口");
return Integer.compare(x, y);
};
根据上述语法可知,组成Lambda表达式的三要素:形式参数,箭头,代码块:
- ① 格式:(形式参数) -> {代码块}。
- ② 形式参数:如果有多个参数,参数之间用逗号隔开;如果没有参数,留空即可。
- ③ ->:由英文中划线和大于符号组成,固定写法。代表指向动作。
- ④ 代码块:是我们具体要做的事情,也就是我们写的方法体内容。
语法看起来很简答,其实就是通过箭头表达式替代匿名内部类。以下是lambda表达式的重要特征:
- 可选类型声明:不需要声明参数类型,编译器可以统一识别参数值 parameters。
- 可选的参数圆括号:一个参数无需定义圆括号,但多个参数需要定义圆括号。
- 可选的大括号:如果主体只包含一条语句,就不需要使用大括号。
- 可选的返回关键字:如果主体只有一个表达式返回值则编译器会自动返回值,大括号需要指定表达式返回了一个数值。
1.2 Lambda的优点
使用 Lambda 表达式可以使代码变的更加简洁紧凑。以下简单列了一下它的优点:
- 速度更快
- 代码更少(增加了新的语法Lambda表达式)
- 强大的Stream API
- 便于并行
- 最大化减少空指针异常Optional
- 类型推断:Lambda 表达式中的参数类型都是由编译器推断得出的。
Lambda 表达式中无需指定类型,程序依然可以编译,这是因为 javac 根据程序的上下文,在后台推断出了参数的类型。 Lambda 表达式的类型依赖于上下文环境,是由编译器推断出来的。这就是所谓的 “类型推断”。
1.3 Lambda简单实例
为了更直观的看到Lambda的写法,我们列出几个Lambda 表达式的简单示例:
// 1. 不需要参数,返回值为 5。
// 无参数时不可省略参数的括号
() -> 5
// 2. 接收一个参数(数字类型),返回其2倍的值。
// 一个参数,可省略参数外的括号
x -> 2 * x
// 3. 接受2个参数(数字),并返回他们的差值
// 多个参数,不可省略参数的括号
// 如果只有一个语句,也可省略return关键字
// 参数类型可省略,根据要实现的接口的方法能推导出来
(x, y) -> x – y
// 4. 接收2个int型整数,返回他们的和
// 单条语句,可省略语句的大括号
// 如果只有一个语句,也可省略return关键字
(int x, int y) -> x + y
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
// 单条语句,可省略语句的大括号
(String s) -> System.out.print(s)
// 6. 多条语句,语句需要加大括号
() -> {
System.out.println("lambda1");
System.out.println("lambda2");
};
根据示例可以得出如下结论:
- 无参数或多个参数时不可省略参数的括号。
- 一个参数,可省略参数外的括号。
- 参数类型可省略,可以根据要实现的接口的方法推导出来。
- 如果只有一个语句,也可省略return关键字。
- 参数体为单条语句时,可省略语句的大括号。多条语句时需要参数体需要加大括号。
2、实现类、匿名类到Lambda的转换实例
以下是分别使用实现类,匿名类,Lambda实现一个多线程的例子,它们的表示方式虽然不同,但最终效果是相同的。
2.1 方式1:实现类
定义一个类MyRunnable实现Runnable接口,重写run()方法。
//创建MyRunnable类的对象
class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println("多线程程序启动了...");
}
}
public class LambdaDemo {
public static void main(String[] args) {
//实现类的方式实现需求
MyRunnable my = new MyRunnable();
//创建Thread类的对象,把MyRunnable的对象作为构造参数传递
Thread t = new Thread(my);
//启动线程
t.start();
}
}
2.2 方式2:匿名内部类
以下是使用匿名内部类对上述实现类的方式进行了改进,可以看到代码简洁了很多。我们只需要关注接口的run方法实现。
public class LambdaDemo {
public static void main(String[] args) {
//匿名内部类的方式改进
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("多线程程序启动了...");
}
}).start();
}
}
2.3 方式3:Lambda表达式
本例中对匿名内部类的方式进行了改进,使用了Lambda表达式,代码结构更加清晰,关注点进一步明确,我们甚至都不需要知道接口的方法申明,只需要关注方法体的实现,即我们的业务逻辑代码。
public class LambdaDemo {
public static void main(String[] args) {
//Lambda表达式方式改进
new Thread(() -> {
System.out.println("多线程程序启动了...");
}).start();
}
}
Lambda表达式中的代码解析:
- ():里面没有内容,可以看成是方法形式参数为空
- ->:用箭头指向后面要做的事情
- { }:包含一段代码,我们称之为代码块,可以看成是方法体中的内容
3、自定义接口使用Lambda的实例
Lambda表达式的使用前提:
- ① 有一个接口。
- ② 接口中有且仅有一个抽象方法。
根据上述约束,我们自定义一个仅有一个抽象方法的接口。
public interface Eatable {
void eat();
}
3.1 方式1:实现类
class EatableImpl implements Eatable{
@Override
public void eat() {
System.out.println("一天一苹果,医生远离我");
}
}
public class EatableDemo {
public static void main(String[] args) {
// 调用useEatable方法
Eatable e = new EatableImpl();
useEatable(e);
}
private static void useEatable(Eatable e){
e.eat();
}
}
3.2 方式2:匿名内部类
public class EatableDemo {
public static void main(String[] args) {
//匿名内部类
useEatable(new Eatable() {
@Override
public void eat() {
System.out.println("一天一苹果,医生远离我");
}
});
}
private static void useEatable(Eatable e){
e.eat();
}
}
3.3 方式3:Lambda表达式
public class EatableDemo {
public static void main(String[] args) {
//用Lambda表达式
useEatable(() -> {
System.out.println("一天一苹果,医生远离我");
});
}
private static void useEatable(Eatable e){
e.eat();
}
}
4、函数式接口
只包含一个抽象方法的接口,称为函数式接口。可以通过 Lambda 表达式来创建该接口的对象。
4.1 自定义函数接口
我们可以在任意函数式接口上使用 @FunctionalInterface
注解,这样做可以检查它是否是一个函数式接口,同时 javadoc 也会包含一条声明,说明这个接口是一个函数式接口。
@FunctionalInterface
Public interface MyNumber{
public double getValue();
}
// 函数式接口中使用泛型
@FunctionalInterface
Public interface MyFun<T>{
public T getValue(T t);
}
4.2 作为参数传递的Lambda表达式
作为参数传递 Lambda 表达式:为了将 Lambda 表达式作为参数传递,接收Lambda 表达式的参数类型必须是与该 Lambda 表达式兼容的函数式接口的类型。
public String toUpperString(MyFun<String> mf, String str){
return mf.getValue(str);
}
// 作为参数传递Lambda表达式:
String newStr = toUpperString(
(str) - > str.toUpperCase(), “abcdef”);
System.out.println(newStr);
4.3 Java 内置四大核心函数式接口
Java8中的java.util.function包中提供了一些常用的函数式功能接口。
4.3.1 消费型接口 Consumer<T>
对类型为T的对象应用操作,包含方法 void accept(T t)
,参数类型为T,返回类型为void,示例如下:
// Consumer<T> 消费型接口 :
@Test
public void test1(){
happy(10000, (m) -> System.out.println("每次消费:" + m + "元"));
}
public void happy(double money, Consumer<Double> con){
con.accept(money);
}
4.3.2 供给型接口 Supplier<T>
返回类型为T的对象,包含方法 T get()
,无参数,返回类型为T,示例如下:
//Supplier<T> 供给型接口 :
@Test
public void test2(){
List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));
for (Integer num : numList) {
System.out.println(num);
}
}
//需求:产生指定个数的整数,并放入集合中
public List<Integer> getNumList(int num, Supplier<Integer> sup){
List<Integer> list = new ArrayList<>();
for (int i = 0; i < num; i++) {
Integer n = sup.get();
list.add(n);
}
return list;
}
4.3.3 函数型接口 Function<T, R>
对类型为T的对象应用操作并返回结果。结果是R类型的对象。包含方法 R apply(T t)
,参数类型为T,返回类型为R,示例如下:
//Function<T, R> 函数型接口:
@Test
public void test3(){
String newStr = strHandler("\t\t\t 我大尚硅谷威武 ", (str) -> str.trim());
System.out.println(newStr);
String subStr = strHandler("我大尚硅谷威武", (str) -> str.substring(2, 5));
System.out.println(subStr);
}
//需求:用于处理字符串
public String strHandler(String str, Function<String, String> fun){
return fun.apply(str);
}
4.3.4 断言型接口 Predicate<T>
确定类型为T的对象是否满足某约束,并返回boolean值。包含方法 boolean test(T t)
,参数类型为T,返回类型为布尔值,示例如下:
//Predicate<T> 断言型接口:
@Test
public void test4(){
List<String> list = Arrays.asList("Hello", "atguigu", "Lambda", "www", "ok");
List<String> strList = filterStr(list, (s) -> s.length() > 3);
for (String str : strList) {
System.out.println(str);
}
}
//需求:将满足条件的字符串,放入集合中
public List<String> filterStr(List<String> list, Predicate<String> pre){
List<String> strList = new ArrayList<>();
for (String str : list) {
if(pre.test(str)){
strList.add(str);
}
}
return strList;
}
4.3.5 其他接口
5、Lambda表达式和匿名内部类的区别
5.1 所需类型不同
- ① 匿名内部类:可以是接口,也可以是抽象类,还可以是具体类
- ② Lambda表达式:只能是接口
abstract class Animal {
public abstract void method();
}
class Student {
public void study(){
System.out.println("爱生活,爱java");
}
}
public class LambdaDemo{
public static void main(String[] args) {
/*//匿名内部类
useInter(new Inter() {
@Override
public void show() {
System.out.println("接口");
}
});
useAnimal(new Animal() {
@Override
public void method() {
System.out.println("抽象类");
}
});
useStudent(new Student(){
@Override
public void study(){
System.out.println("具体类");
}
});*/
//Lambda
useInter(() -> System.out.println("接口"));
//useAnimal(() -> System.out.println("抽象类"));//不可以
//useStudent(() -> System.out.println("具体类"));//不可以
}
private static void useStudent(Student s){
s.study();
}
private static void useAnimal(Animal a){
a.method();
}
private static void useInter(Inter i){
i.show();
}
}
5.2 使用限制不同
- ① 如果接口中有且仅有一个抽象方法,可以使用Lambda表达式,也可以使用匿名内部类
- ② 如果接口中多于一个抽象方法,只能使用匿名内部类,而不能使用Lambda表达式
public interface Inter{
void show();
void show1();
}
public class LambdaDemo{
public static void main(String[] args) {
useInter(new Inter() {
@Override
public void show() {
System.out.println("show"); // 只打印这一个show
}
@Override
public void show1() {
System.out.println("show");
}
});
}
private static void useInter(Inter i){
i.show();
}
}
5.3 实现原理不同
- ① 匿名内部类:编译之后,产生一个单独的.class字节码文件
- ② Lambda表达式:编译之后,没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成
6、方法引用和构造器引用
6.1 方法引用
当要传递给Lambda体的操作,已经有实现的方法了,可以使用方法引用!
- (实现抽象方法的参数列表,必须与方法引用方法的参数列表保持一致! )
- 方法引用:使用操作符 “::” 将方法名和对象或类的名字分隔开来。
- 方法引用格式: ClassName::MethodName
注意:
- 方法引用所引用的方法的参数列表与返回值类型,需要与函数式接口中抽象方法的参数列表和返回值类型保持一致!
- 若Lambda 的参数列表的第一个参数,是实例方法的调用者,第二个参数(或无参)是实例方法的参数时,格式: ClassName::MethodName
如下三种主要使用情况:
(1)对象::实例方法
@Test
public void test1(){
PrintStream ps = System.out;
Consumer<String> con = (str) -> ps.println(str);
con.accept("Hello World!");
System.out.println("--------------------------------");
Consumer<String> con2 = ps::println;
con2.accept("Hello Java8!");
Consumer<String> con3 = System.out::println;
}
@Test
public void test2(){
Employee emp = new Employee(101, "张三", 18, 9999.99);
Supplier<String> sup = () -> emp.getName();
System.out.println(sup.get());
System.out.println("----------------------------------");
Supplier<String> sup2 = emp::getName;
System.out.println(sup2.get());
}
(2)类::静态方法
@Test
public void test3(){
BiFunction<Double, Double, Double> fun = (x, y) -> Math.max(x, y);
System.out.println(fun.apply(1.5, 22.2));
System.out.println("--------------------------------------------------");
BiFunction<Double, Double, Double> fun2 = Math::max;
System.out.println(fun2.apply(1.2, 1.5));
}
@Test
public void test4(){
Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
System.out.println("-------------------------------------");
Comparator<Integer> com2 = Integer::compare;
}
(3)类::实例方法
@Test
public void test5(){
BiPredicate<String, String> bp = (x, y) -> x.equals(y);
System.out.println(bp.test("abcde", "abcde"));
System.out.println("-----------------------------------------");
BiPredicate<String, String> bp2 = String::equals;
System.out.println(bp2.test("abc", "abc"));
System.out.println("-----------------------------------------");
Function<Employee, String> fun = (e) -> e.show();
System.out.println(fun.apply(new Employee()));
System.out.println("-----------------------------------------");
Function<Employee, String> fun2 = Employee::show;
System.out.println(fun2.apply(new Employee()));
}
6.2 构造器引用
构造器引用:构造器的参数列表,需要与函数式接口中参数列表保持一致!
- 构造器引用格式: ClassName::new
- 与函数式接口相结合,自动与函数式接口中方法兼容。
- 可以把构造器引用赋值给定义的方法,与构造器参数
- 列表要与接口中抽象方法的参数列表一致!
- 和方法引用一样,构造器本质上也是一个
<init>
方法
Function<Integer, MyClass> fun = (n) -> new MyClass(n);
等同于:
Function<Integer, MyClass> fun = MyClass::new;
示例:
@Test
public void test1() {
Function<Integer, Person> f1 = new Function<Integer, Person>() {
@Override
public Person apply(Integer t) {
return new Person(t);
}
};
// ----------------------------lambda表达式------------------------------
Function<Integer, Person> f2 = t -> new Person(t);
// -----------------------------构造器的引用-----------------------------
Function<Integer, Person> f3 = Person::new;
}
示例解释:
- Apply()方法中第一个泛型是形参类型,第二个泛型是返回值返回值类型,所以构造器引用时,将返回类型的对象new,将第一个参数作为形参
6.3 数组引用
构造器引用的特例
- 数组引用格式:
type[]::new
Function<Integer, Integer[]> fun = (n) -> new Integer[n];
等同于:
Function<Integer, Integer[]> fun = Integer[]::new;
示例:
/**
* 数组引用
*/
@Test
public void test2() {
Function<Integer, Person[]> f1 = new Function<Integer, Person[]>() {
@Override
public Person[] apply(Integer t) {
return new Person[t];
}
};
// ---------------------------------lambda表达式------------------------------
Function<Integer, Person[]> f2 = t -> new Person[t];
// ---------------------------------数组的引用------------------------------
Function<Integer, Person[]> f3 = Person[]::new;
// 调用
Person[] apply = f3.apply(10);
}
示例解释:
- Apply()方法中第一个泛型是形参类型,第二个泛型是返回值返回值的数组类型,所以构造器引用时,将返回类型的对象new,将第一个参数作为返回数组的长度
使用案例:
List<String> newStrList = Arrays.asList(1,2,3,4,5).stream().map(String::new).collect(Collectors.toList());
7、Lambda表达式应用实战
7.1 示例1
// 1、匿名内部类
Comparator<Integer>com = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) { //降序排列
return Integer.compare(o2,o1);
// return o2 - o1;
}
};
// 2、Lambda 表达式
Comparator<Integer> com = (x, y) -> Integer.compare(y, x);
7.2 数组排序
List<Integer> list = Arrays.asList(33,44,55,33,22);
// 1、匿名内部类的方式
Collections.sort(list, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
});
// 2、lambda 表达式的方式
Collections.sort(list, (p1, p2) -> p1 - p2);
// 3、静态方法的引用
Collections.sort(list, LambdbTest::compar);
public static int compar(Integer p1, Integer p2) {
return p1-p2;
}
7.3 获取stream对象
// 1、批量数据,stream对象
Stream stream = Stream.of("admin", "ossuser");
// 2、数组
int[] array = new int[]{1,3,4};
IntStream stream1 = Arrays.stream(array);
// 2、集合
List<String> list = Arrays.asList("admin", "ossuser");
Stream<String> stream2 = list.stream();
// 3、Map
Map<String, String> map = new HashMap<>();
map.put("name", "admin");
Stream<Map.Entry<String, String>> stream3 = map.entrySet().stream();
// 3、stream对基类型类型的功能封装
IntStream intStream = IntStream.of(3);
IntStream.range(1, 5).forEach(System.out::println); // 左闭右开
IntStream.rangeClosed(1, 5).forEach(System.out::println); // 左闭又闭
7.4 Stream对象转为指定数据
// 1、数组
Object[] ints = stream.toArray(String[]::new);
// 2、字符串
String collect1 = stream.collect(Collectors.joining()).toString();
// 3、集合
List<String> list1 = (List<String>) stream.collect(Collectors.toList());
// 4、map
Map<String, String> map1 = (Map<String, String>) stream.collect(Collectors.toMap(x -> x, y -> "value" + y));
7.5 其他API操作
List<String> list2 = Arrays.asList("admin", "user", "ossuser");
// 1、map() 中间操作,map()方法接收一个Function接口
List<String> strings = list2.stream().map(x -> x + "test").collect(Collectors.toList());
// 2、filter() 添加过滤条件,过滤满足条件的用户
List<String> collect = list2.stream().filter(x -> x.length() > 2).collect(Collectors.toList());
// 3、forEach 增强型循环
list2.forEach(System.out::print);
// 4、peek() 中间操作,迭代数据依次处理过程,实现数据的多次迭代
list2.stream()
.peek(x -> System.out.println(x + "1"))
.peek(x -> System.out.println(x + "2"))
.forEach(System.out::println);
// 5、skip() 中间操作,有状态,跳过部分数据
list2.stream().skip(1).forEach(System.out::println);
// 6、limit() 中间操作,有状态,限制输出数据量
list2.stream().limit(2).forEach(System.out::println);
// 7、distinct() 中间操作,有状态,去重
list2.stream().distinct().forEach(System.out::println);
评论区