Java的Lambda表达式

语雀链接:Lambda表达式

文章目录

1.体验Lambda表达式
- 1.1函数式编程思想概述
- 1.2体验Lambda表达式
2.Lambda表达式的标准格式
- 2.1匿名内部类中重写run()方法的代码分析
- 2.2Lambda表达式的代码分析
- 2.3Lambda表达式的格式
3.Lambda表达式的练习(抽象方法无参无返回值)
4.Lambda表达式的练习(抽象方法带参无返回值)
5.Lambda表达式的练习(抽象方法带参带返回值)
6.Lambda表达式的省略模式
7.Lambda表达式的注意事项
8.Lambda表达式和匿名内部类的区别
9.接口组成更新概述
10.接口中默认方法
11.接口中静态方法
12.接口中私有方法
13.体验方法引用
14.方法引用符
15.Lambda表达式支持的方法引用
16.引用对象的实例方法
17.引用类的实例方法
18.引用构造器

1.体验Lambda表达式

1.1函数式编程思想概述

在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作”

面向对象思想强调“必须通过对象的形式来做事情”

函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”

而我们要学习的Lambda表达式就是函数式思想的体现

1.2体验Lambda表达式

需求：启动一个线程，在控制台输出一句话：多线程程序启动了

方式1：

定义一个类MyRunnable实现Runnable接口，重写run()方法
创建MyRunnable类的对象
创建Thread类的对象，把MyRunnable的对象作为构造参数传递
启动线程

MyRunable my = new MyRunable();
Thread t = new Thread(my);
t.start();=====MyRunable.java
@Override
public void run() {System.out.println("多线程程序启动了...");
}
=====

方式2：

匿名内部类的方式改进

new Thread(new Runnable() {@Overridepublic void run() {System.out.println("多线程程序启动了_匿名内部类");}
}).start();

方式3：

Lambda表达式的方式改进

new Thread(() -> {System.out.println("多线程程序启动了_匿名内部类");
}).start();

2.Lambda表达式的标准格式

2.1匿名内部类中重写run()方法的代码分析

方法形式参数为空，说明调用方法时不需要传递参数
方法返回值类型为void，说明方法执行没有结果返回
方法体中的内容，是我们具体要做的事情

new Thread(new Runnable() {@Overridepublic void run() {System.out.println("多线程程序启动了");}
}).start();

2.2Lambda表达式的代码分析

()：里面没有内容，可以看成是方法形式参数为空
->：用箭头指向后面要做的事情
{}：包含一段代码，我们称之为代码块，可以看成是方法体中的内容

new Thread(() -> {System.out.println("多线程程序启动了_匿名内部类");
}).start();

2.3Lambda表达式的格式

格式	(形式参数) -> {代码块}
形式参数	如果有多个参数,参数之间用逗号隔开;如果没有参数,留空即可
->	由英文中划线和大于符号组成.代表指向动作
代码块	是我们具体要做的事情,也就是以前我们写的方法体内容

3.Lambda表达式的练习(抽象方法无参无返回值)

Lambda表达式的使用前提

有一个接口
接口中有且仅有一个抽象方法

练习1：

定义一个接口（Eatable），里面定义一个抽象方法：void eat()；
定义一个测试类（EatableDemo），在测试类中提供两个方法
- 一个方法是：useEatable(Eatable e)
- 一个方法是主方法，在主方法中调用useEatable方法

package com.study_02;public interface Eatable {void eat();
}

package com.study_02;public class EatableImpl implements Eatable{@Overridepublic void eat() {System.out.println("一天一个小苹果");}
}

package com.study_02;public class EatableDemo {public static void main(String[] args) {// 在主方法中调用useEatable方法Eatable e = new EatableImpl();useEatable(e);// 匿名内部来useEatable(new Eatable() {@Overridepublic void eat() {System.out.println("一天一个大苹果");}});// Lambda表达式useEatable( () -> {System.out.println("一天一个毒苹果");});}private static void useEatable(Eatable e) {e.eat();}
}

4.Lambda表达式的练习(抽象方法带参无返回值)

练习2:

定义一个接口（Flyable），里面定义一个抽象方法：void fly(String s);
定义一个测试类（FlyableDemo），在测试类中提供两个方法
- 一个方法是：useFlyable(Flyable f)
- 一个方法是主方法，在主去中调用useFlyable方法

package com.study_03;public interface Flyable {void fly(String s);
}

package com.study_03;public class FlyableDemo {public static void main(String[] args) {// 在主方法中调用userFlyable方法// 匿名内部类userFlyable(new Flyable() {@Overridepublic void fly(String s) {System.out.println(s);System.out.println("内部人员");}});System.out.println("------");// LambdauserFlyable((String s) -> {System.out.println(s);System.out.println("Lambda");});}private static void userFlyable(Flyable f) {f.fly("风和日丽");}
}

5.Lambda表达式的练习(抽象方法带参带返回值)

练习3：

定义一个接口（Addable），里面定义一个抽象方法：intadd(intxinty);
定义一个测试类（AddableDemo），在测试类中提供两个方法
- 一个方法是：useAddable(Addablea)
- 一个方法是主方法，在主方法中调用useAddable方法

package com.study_04;public interface Addable {int add(int x,int y);
}

package com.study_04;public class AddableDemo {public static void main(String[] args) {// 在主方法中调用useAddable方法useAddable((int x, int y) -> {return x + y;
//            return x-y;});}private static void useAddable(Addable a) {int sum = a.add(10, 20);System.out.println(sum);}
}

6.Lambda表达式的省略模式

省略规则：

参数类型可以省略。但是有多个参数的情况下，不能只省略一个
如果参数有且仅有一个，那么小括号可以省略
如果代码块的语句只有一条，可以省略大括号和分号，甚至是retum

package com.study_05;public interface Addable {int add(int x,int y);
}

package com.study_05;public interface Flyable {void fly(String s);
}

package com.study_05;import com.study_03.Flyable;
import com.study_04.Addable;public class LambdaDemo {public static void main(String[] args) {//        useAddable((int x,int y) -> {//            return x+y;
//        });// 参数的类型可以省略,不能只省略一个useAddable((x,y) -> {return x + y;});//        userFlyable((String s) -> {//            System.out.println(s);
//        });//        userFlyable((s) -> {//            System.out.println(s);
//        });// 如果参数有且仅有一个,那么小括号可以省略
//        userFlyable(s -> {//            System.out.println(s);
//        });// 如果代码块的语句只有一条,可以省略大括号和分号userFlyable(s -> System.out.println(s));// 如果有return,return也可省略掉useAddable((x,y) -> x + y);}private static void userFlyable(Flyable f) {f.fly("风和日丽");}private static void useAddable(Addable a) {int sum = a.add(10, 20);System.out.println(sum);}
}

7.Lambda表达式的注意事项

注意事项：

使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法
必须有上下文环境，才能推导出Lambda对应的接口
- 根据局部变量的赋值得知Lambda对应的接口：Runnabler=()->System.out.printin("Lambda表达式”);
- 根据调用方法的参数得知Lambda对应的接口：new Thread(()->System.out.println("Lambda表达式")).start();

package com.study_06;public interface Inter {void show();//    void meth();
}

package com.study_06;public class LambdaDemo {public static void main(String[] args) {//        useInter(() -> {//            System.out.println("好好学习天天向上");
//        });// 使用Lambda必修要有接口,并且要求接口中有且仅有一个抽像方法useInter(() -> System.out.println("好好学习天天向上"));// 必须有上下文逻辑,才能推导出Lambda对应的接口
//        new Thread(new Runnable() {//            @Override
//            public void run() {//                System.out.println("匿名内部类");
//            }
//        }).start();//        Runnable r = () -> System.out.println("Lambda表达式");
//        new Thread(r).start();new Thread(() -> System.out.println("Lambda表达式")).start();}private static void useInter(Inter i) {i.show();}
}

8.Lambda表达式和匿名内部类的区别

所需类型不同

匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
Lambda表达式：只能是接口

使用限制不同

如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式

实现原理不同

匿名内部类：编译之后，产生一个单独的.class字节码文件
Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

9.接口组成更新概述

接口的组成

常量
- public static final
抽象方法
- public abstract
默认方法（Java 8）
静态方法（Java 8）
私有方法（Java 9）

10.接口中默认方法

接口中默认方法的定义格式:

格式：public default 返回值类型方法名（参数列表）{ }
范例：public default void show3() { }

接口中默认方法的注意事项：

默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉default关键字
public可以省略，default不能省略

package com.study_01;public interface MyInterface {void show1();void show2();//        void show3();//    public default void show3() {//        System.out.println("show3");
//    }default void show3() {System.out.println("show3");}}

package com.study_01;public class MyInterfaceImplOne implements MyInterface{@Overridepublic void show1() {System.out.println("one show1");}@Overridepublic void show2() {System.out.println("one show2");}@Overridepublic void show3() {System.out.println("one show3");}
}

package com.study_01;public class MyInterfaceDemo {public static void main(String[] args) {// 按照多态的方式创建对象并使用MyInterface my = new MyInterfaceImplOne();my.show1();my.show2();my.show3();}
}

11.接口中静态方法

接口中静态方法的定义格式：

格式：public static 返回值类型方法名（参数列表）{ }
范例：public static void show() { }

接口中静态方法的注意事项：

静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
public可以省略，static不能省略

package com.study_02;public interface Inter {void show();default void method() {System.out.println("Inter中默认方法");}//    public static void test() {//        System.out.println("Inter中静态方法");
//    }static void test() {System.out.println("Inter中静态方法");}
}

package com.study_02;public interface Flyable {public static void test() {System.out.println("Flyable");}
}

package com.study_02;public class InterImlpl implements Inter,Flyable{@Overridepublic void show() {System.out.println("show执行了");}
}

package com.study_02;public class InterDemo {public static void main(String[] args) {Inter i = new InterImlpl();i.show();i.method();
//        i.test();Inter.test();Flyable.test();}
}

12.接口中私有方法

Java 9中新增了带方法体的私有方法，这其实在Java8中就埋下了伏笔：Java8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法是不需要让别人使用的，因此用私有给隐藏起来，这就是Java9增加私有方法的必然性

接口中私有方法的定义格式：

格式1：private返回值类型方法名（参数列表）{}
范例1：private void show(){}
格式2：private static返回值类型方法名（参数列表）{}
范例2：private static void method(){}

接口中私有方法的注意事项：

默认方法可以调用私有的静态方法和非静态方法
静态方法只能调用私有的静态方法

package com.study_03;public interface Inter {default void show1() {System.out.println("show1开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");show();System.out.println("show1结束执行");}default void show2() {System.out.println("show2开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
//        show();method();System.out.println("show2结束执行");}private void show() {System.out.println("初级工程师");System.out.println("中级工程师");System.out.println("高级工程师");}static void method1() {System.out.println("method1开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");method();System.out.println("method1结束执行");}static void method2() {System.out.println("method2开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");method();System.out.println("method2结束执行");}private static void method() {System.out.println("初级工程师");System.out.println("中级工程师");System.out.println("高级工程师");}}

package com.study_03;public class InterImpl implements Inter{}

package com.study_03;public class InterDemo {public static void main(String[] args) {// 按照多态的方法创建对象并使用Inter i = new InterImpl();i.show1();System.out.println("-----");i.show2();System.out.println("-----");Inter.method1();System.out.println("-----");Inter.method2();}
}

13.体验方法引用

在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿参数做操作

那么考虑一种情况：如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑呢？

答案肯定是没有必要

那我们又是如何使用已经存在的方案的呢？

这就是我们要讲解的方法引用，我们是通过方法引用来使用已经存在的方案

package com.study_01;public interface Printable {void printString(String s);
}

package com.study_01;public class PrintableDemo {public static void main(String[] args) {// 在主方法中调用usePrintable方法//        usePrintable((String s) -> {//            System.out.println(s);
//        });usePrintable(s -> System.out.println(s));//        System.out.println("爱生活很好");//方法引用符 ::usePrintable(System.out::println);// 可推导的就是课省略的}private static void usePrintable(Printable p) {p.printString("爱生活很好");}
}

14.方法引用符

package com.study_02;public interface Printable {void printInt(int i);
}

package com.study_02;public class PrintableDemo {public static void main(String[] args) {// 在主方法中调用usePrintable方法
//        usePrintable(i -> System.out.println(i));// 方法引用usePrintable(System.out::println);}private static void usePrintable(Printable p) {p.printInt(666);}
}

15.Lambda表达式支持的方法引用

常见的引用方式:

引用类方法
引用对象的实例方法
引用类的实例方法
引用构造器

引用类方法

引用类方法，其实就是引用类的静态方法

格式：类名 : 静态方法
范例：Integer:parselnt
- Integer类的方法：public static int parselnt(String s);将此String转换为int类型数据

练习：

定义一个接口（Converter）,里面定义一个抽象方法i
- int convert(Strings);
定义一个测试类（ConverterDemo），在测试类中提供两个方法
- 一个方法是：useConverter(Converter c);
- 一个方法是主方法，在主方法中调用useConverter方法

package com.study_03;public interface Converter {int convert(String s);
}

package com.study_03;public class ConverterDemo {public static void main(String[] args) {// 在主方法中调用useConverter方法// 重写 Converter接口 中的 convert方法 是有返回值的
//        useConverter((String s) -> {//            return Integer.parseInt(s);
//        });useConverter(s -> Integer.parseInt(s));// 引用类方法useConverter(Integer::parseInt);// Lambda表达式被类方法替代的时候,它的形式参数全部传递给静态方法作为参数}private static void useConverter(Converter c) {int number = c.convert("666"); // 将convert方法返回值赋给 numberSystem.out.println(number);}
}

16.引用对象的实例方法

引用对象的实例方法，其实就引用类中的成员方法

格式：对象::成员方法
范例："HelloWorld"::toUpperCase
- String类中的方法：public String toUpperCase()将此String所有字符转换为大写

练习

定义一个类（PrintString），里面定义一个方法
- public void printUpper(String s)：把字符串参数变成大写的数据，然后在控制台输出
定义一个接口（Printer），星面定义一个抽象方法
- void printUpperCase(Strings);
定义一个测试类（PrinterDemo），在测试类中提供两个方法
- 一个方法是：usePrinter(Printerp);
- 一个方法是主方法，在主方法中调用usePrinter方法

package com.study_04;public interface Printer {void printUpperCase(String s);
}

package com.study_04;public class PrintString {// 把字符串参数变成大写的数据,然后在控制台输出public void printUpper(String s) {String result = s.toUpperCase();System.out.println(result);}
}

package com.study_04;public class PrinterDemo {public static void main(String[] args) {// 在主方法中调用usePrinter方法
//        usePrinter((String s) -> {            String resuult = s.toUpperCase();
            System.out.println(resuult);
//            System.out.println(s.toUpperCase());
//        });usePrinter(s -> System.out.println(s.toUpperCase()));// 引用对象的实例方法PrintString ps = new PrintString();usePrinter(ps::printUpper);//Lambda表达被对象实例方法替代的时候,它的形式参数全部传递给该方法作为参数}private static void usePrinter(Printer p) {p.printUpperCase("HelloWorld");}
}

17.引用类的实例方法

引用类的实例方法，其实就是引用类中的成员方法

格式：类名::成员方法
范例：String::substring
- String类中的方法：public String substring(int beginlndex，int endlndex);
- 从beginlndex开始到endlndex结束，截取字符串。返回一个子串，子串的长度为endlndex - beginlndex

练习

定义一个接口（MyString），里面定义一个抽象方法：
- String mySubString(String s，int xinty);
定义一个测试类（MyStringDemo），在测试类中提供两个方法
- 一个方法是：uselMyString(MyString my);
- 一个方法是主方法，在主方法中调用useMyString方法

package com.study_05;public interface MyString {String mySubString(String s, int x, int y);
}

package com.study_05;public class MyStringDemo {public static void main(String[] args) {// 在主方法中调用useMyString方法//        useMyString((String s,int x ,int y) -> {//            return s.substring(x,y);
//        });useMyString((s,x,y) -> s.substring(x,y));// 引用类的实例方法useMyString(String::substring);// Lambda表达式被类的实例方法替代的时候// 第一个参数作为调用者// 后面的参数全部传递给该方法作为参数}private static void useMyString(MyString my) {String s = my.mySubString("HelloWorld",2,5);System.out.println(s);}
}

18.引用构造器

引用构造器,其实就是引用方法

格式:类名::new
范例:Student::new

练习

定义一个类（Student），里面有两个成员变量（name，age）
- 并提供无参构造方法和带参构造方法，以及成员变量对应的get和set方法
定义一个接口（StudentBuilder），里面定义一个抽象方法
- Student build(String name，int age);
定义一个测试类（StudentDemo），在测试类中提供两个方法
- 一个方法是：useStudentBuilder(StudentBuilders);
- 一个方法是主方法，在主方法中调用useStudentBuilder方法

package com.study_06;public interface StudentBuilder {Student build(String name,int age);
}

package com.study_06;public class Student {private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

package com.study_06;public class StudentDemo {public static void main(String[] args) {//        useStudentBuilder((String name,int age) -> {            Student s = new Student(name,age);
            return s;
//            return new Student(name,age);
//        });useStudentBuilder((name,age) -> new Student(name,age));// 引用构造器useStudentBuilder(Student::new);//Lambda表达式被构造器替代的时候,他是形式参数全部传递给构造器作为参数}private static void useStudentBuilder(StudentBuilder sb) {Student s = sb.build("林青霞",30);System.out.println(s.getName()+","+s.getAge());}
}