@[toc]

1.体验Lambda表达式

1.1函数式编程思想概述

Lambda表达式 - 图1

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

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

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

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

1.2体验Lambda表达式

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

方式1：

  • 定义一个类MyRunnable实现Runnable接口，重写run()方法
  • 创建MyRunnable类的对象
  • 创建Thread类的对象，把MyRunnable的对象作为构造参数传递
  • 启动线程
  1. MyRunable my = new MyRunable();
  2. Thread t = new Thread(my);
  3. t.start();
  5. =====MyRunable.java
  6. @Override
  7. public void run() {
  8.        System.out.println("多线程程序启动了...");
  9. }
  10. =====

方式2：

  • 匿名内部类的方式改进
  1. new Thread(new Runnable() {
  2.     @Override
  3.     public void run() {
  4.         System.out.println("多线程程序启动了_匿名内部类");
  5.     }
  6. }).start();

方式3：

  • Lambda表达式的方式改进
  1. new Thread(() -> {
  2.     System.out.println("多线程程序启动了_匿名内部类");
  3. }).start();

2.Lambda表达式的标准格式

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

  • 方法形式参数为空，说明调用方法时不需要传递参数
  • 方法返回值类型为void，说明方法执行没有结果返回
  • 方法体中的内容，是我们具体要做的事情
  1. new Thread(new Runnable() {
  2.     @Override
  3.     public void run() {
  4.         System.out.println("多线程程序启动了");
  5.     }
  6. }).start();

2.2Lambda表达式的代码分析

  • ()：里面没有内容，可以看成是方法形式参数为空
  • ->：用箭头指向后面要做的事情
  • {}：包含一段代码，我们称之为代码块，可以看成是方法体中的内容
  1. new Thread(() -> {
  2.     System.out.println("多线程程序启动了_匿名内部类");
  3. }).start();

2.3Lambda表达式的格式

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

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

Lambda表达式的使用前提

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

练习1：

  • 定义一个接口（Eatable），里面定义一个抽象方法：void eat()；
  • 定义一个测试类（EatableDemo），在测试类中提供两个方法
    • 一个方法是：useEatable(Eatable e)
    • 一个方法是主方法，在主方法中调用seEatable方法
  1. package com.study_02;
  3. public interface Eatable {
  4.     void eat();
  5. }
  1. package com.study_02;
  3. public class EatableImpl implements Eatable{
  5.     @Override
  6.     public void eat() {
  7.         System.out.println("一天一个小苹果");
  8.     }
  9. }
  1. package com.study_02;
  3. public class EatableDemo {
  4.     public static void main(String[] args) {
  5.         // 在主方法中调用useEatable方法
  6.         Eatable e = new EatableImpl();
  7.         useEatable(e);
  9.         // 匿名内部来
  10.         useEatable(new Eatable() {
  11.             @Override
  12.             public void eat() {
  13.                 System.out.println("一天一个大苹果");
  14.             }
  15.         });
  17.         // Lambda表达式
  18.         useEatable( () -> {
  19.             System.out.println("一天一个毒苹果");
  20.         });
  22.     }
  24.     private static void useEatable(Eatable e) {
  25.         e.eat();
  26.     }
  27. }

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

练习2:

  • 定义一个接口（Flyable），里面定义一个抽象方法：void fly(String s);
  • 定义一个测试类（FlyableDemo），在测试类中提供两个方法
    • 一个方法是：useFlyable(Flyable f)
    • 一个方法是主方法，在主去中调用useFlyable方法
  1. package com.study_03;
  3. public interface Flyable {
  4.     void fly(String s);
  5. }
  1. package com.study_03;
  3. public class FlyableDemo {
  4.     public static void main(String[] args) {
  5.         // 在主方法中调用userFlyable方法
  6.         // 匿名内部类
  7.         userFlyable(new Flyable() {
  8.             @Override
  9.             public void fly(String s) {
  10.                 System.out.println(s);
  11.                 System.out.println("内部人员");
  12.             }
  13.         });
  14.         System.out.println("------");
  16.         // Lambda
  17.         userFlyable((String s) -> {
  18.             System.out.println(s);
  19.             System.out.println("Lambda");
  20.         });
  22.     }
  24.     private static void userFlyable(Flyable f) {
  25.         f.fly("风和日丽");
  26.     }
  27. }

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

练习3：

  • 定义一个接口（Addable），里面定义一个抽象方法：intadd(intxinty);
  • 定义一个测试类（AddableDemo），在测试类中提供两个方法
    • 一个方法是：useAddable(Addablea)
    • 一个方法是主方法，在主方法中调用useAddable方法
  1. package com.study_04;
  3. public interface Addable {
  4.     int add(int x,int y);
  5. }
  1. package com.study_04;
  3. public class AddableDemo {
  4.     public static void main(String[] args) {
  5.         // 在主方法中调用useAddable方法
  6.         useAddable((int x, int y) -> {
  7.             return x + y;
  8. //            return x-y;
  9.         });
  11.     }
  13.     private static void useAddable(Addable a) {
  14.         int sum = a.add(10, 20);
  15.         System.out.println(sum);
  16.     }
  17. }

6.Lambda表达式的省略模式

✨省略规则：

  • 参数类型可以省略。但是有多个参数的情况下，不能只省略一个
  • 如果参数有且仅有一个，那么小括号可以省略
  • 如果代码块的语句只有一条，可以省略大括号和分号，甚至是retum
  1. package com.study_05;
  3. public interface Addable {
  4.     int add(int x,int y);
  5. }
  1. package com.study_05;
  3. public interface Flyable {
  4.     void fly(String s);
  5. }
  1. package com.study_05;
  3. import com.study_03.Flyable;
  4. import com.study_04.Addable;
  6. public class LambdaDemo {
  7.     public static void main(String[] args) {
  8. //        useAddable((int x,int y) -> {
  9. //            return x+y;
  10. //        });
  11.         // 参数的类型可以省略,不能只省略一个
  12.         useAddable((x,y) -> {
  13.             return x + y;
  14.         });
  16. //        userFlyable((String s) -> {
  17. //            System.out.println(s);
  18. //        });
  20. //        userFlyable((s) -> {
  21. //            System.out.println(s);
  22. //        });
  24.         // 如果参数有且仅有一个,那么小括号可以省略
  25. //        userFlyable(s -> {
  26. //            System.out.println(s);
  27. //        });
  29.         // 如果代码块的语句只有一条,可以省略大括号和分号
  30.         userFlyable(s -> System.out.println(s));
  32.         // 如果有return,return也可省略掉
  33.         useAddable((x,y) -> x + y);
  35.     }
  37.     private static void userFlyable(Flyable f) {
  38.         f.fly("风和日丽");
  39.     }
  41.     private static void useAddable(Addable a) {
  42.         int sum = a.add(10, 20);
  43.         System.out.println(sum);
  44.     }
  45. }

7.Lambda表达式的注意事项

✨注意事项：

  • 使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法
  • 必须有上下文环境，才能推导出Lambda对应的接口
    • 根据局部变量的赋值得知Lambda对应的接口：Runnabler=()->System.out.printin("Lambda表达式”);
    • 根据调用方法的参数得知Lambda对应的接口：new Thread(()->System.out.println("Lambda表达式")).start();
  1. package com.study_06;
  3. public interface Inter {
  4.     void show();
  6. //    void meth();
  7. }
  1. package com.study_06;
  3. public class LambdaDemo {
  4.     public static void main(String[] args) {
  5. //        useInter(() -> {
  6. //            System.out.println("好好学习天天向上");
  7. //        });
  9.         // 使用Lambda必修要有接口,并且要求接口中有且仅有一个抽像方法
  10.         useInter(() -> System.out.println("好好学习天天向上"));
  12.         // 必须有上下文逻辑,才能推导出Lambda对应的接口
  13. //        new Thread(new Runnable() {
  14. //            @Override
  15. //            public void run() {
  16. //                System.out.println("匿名内部类");
  17. //            }
  18. //        }).start();
  20. //        Runnable r = () -> System.out.println("Lambda表达式");
  21. //        new Thread(r).start();
  23.         new Thread(() -> System.out.println("Lambda表达式")).start();
  24.     }
  26.     private static void useInter(Inter i) {
  27.         i.show();
  28.     }
  29. }

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不能省略
  1. package com.study_01;
  3. public interface MyInterface {
  4.     void show1();
  6.     void show2();
  8. //        void show3();
  10. //    public default void show3() {
  11. //        System.out.println("show3");
  12. //    }
  14.      default void show3() {
  15.         System.out.println("show3");
  16.     }
  18. }
  1. package com.study_01;
  3. public class MyInterfaceImplOne implements MyInterface{
  4.     @Override
  5.     public void show1() {
  6.         System.out.println("one show1");
  7.     }
  9.     @Override
  10.     public void show2() {
  11.         System.out.println("one show2");
  12.     }
  14.     @Override
  15.     public void show3() {
  16.         System.out.println("one show3");
  17.     }
  18. }
  1. package com.study_01;
  3. public class MyInterfaceDemo {
  4.     public static void main(String[] args) {
  5.         // 按照多态的方式创建对象并使用
  6.         MyInterface my = new MyInterfaceImplOne();
  7.         my.show1();
  8.         my.show2();
  9.         my.show3();
  10.     }
  11. }

11.接口中静态方法

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

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

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

  • 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
  • public可以省略，static不能省略
  1. package com.study_02;
  3. public interface Inter {
  4.     void show();
  6.     default void method() {
  7.         System.out.println("Inter中默认方法");
  8.     }
  10. //    public static void test() {
  11. //        System.out.println("Inter中静态方法");
  12. //    }
  14.     static void test() {
  15.         System.out.println("Inter中静态方法");
  16.     }
  17. }
  1. package com.study_02;
  3. public interface Flyable {
  4.     public static void test() {
  5.         System.out.println("Flyable");
  6.     }
  7. }
  1. package com.study_02;
  3. public class InterImlpl implements Inter,Flyable{
  4.     @Override
  5.     public void show() {
  6.         System.out.println("show执行了");
  7.     }
  8. }
  1. package com.study_02;
  3. public class InterDemo {
  4.     public static void main(String[] args) {
  5.         Inter i = new InterImlpl();
  6.         i.show();
  7.         i.method();
  8. //        i.test();
  10.         Inter.test();
  12.         Flyable.test();
  13.     }
  14. }

12.接口中私有方法

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

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

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

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

  • 默认方法可以调用私有的静态方法和非静态方法
  • 静态方法只能调用私有的静态方法
  1. package com.study_03;
  3. public interface Inter {
  4.     default void show1() {
  5.         System.out.println("show1开始执行");
  6. //        System.out.println("初级工程师");
  7. //        System.out.println("中级工程师");
  8. //        System.out.println("高级工程师");
  9.         show();
  10.         System.out.println("show1结束执行");
  11.     }
  13.     default void show2() {
  14.         System.out.println("show2开始执行");
  15. //        System.out.println("初级工程师");
  16. //        System.out.println("中级工程师");
  17. //        System.out.println("高级工程师");
  18. //        show();
  19.         method();
  20.         System.out.println("show2结束执行");
  21.     }
  22.     private void show() {
  23.         System.out.println("初级工程师");
  24.         System.out.println("中级工程师");
  25.         System.out.println("高级工程师");
  26.     }
  28.     static void method1() {
  29.         System.out.println("method1开始执行");
  30. //        System.out.println("初级工程师");
  31. //        System.out.println("中级工程师");
  32. //        System.out.println("高级工程师");
  33.         method();
  34.         System.out.println("method1结束执行");
  35.     }
  37.     static void method2() {
  38.         System.out.println("method2开始执行");
  39. //        System.out.println("初级工程师");
  40. //        System.out.println("中级工程师");
  41. //        System.out.println("高级工程师");
  42.         method();
  43.         System.out.println("method2结束执行");
  44.     }
  46.     private static void method() {
  47.         System.out.println("初级工程师");
  48.         System.out.println("中级工程师");
  49.         System.out.println("高级工程师");
  50.     }
  52. }
  1. package com.study_03;
  3. public class InterImpl implements Inter{
  4. }
  1. package com.study_03;
  3. public class InterDemo {
  4.     public static void main(String[] args) {
  5.         // 按照多态的方法创建对象并使用
  6.         Inter i = new InterImpl();
  7.         i.show1();
  8.         System.out.println("-----");
  9.         i.show2();
  11.         System.out.println("-----");
  13.         Inter.method1();
  14.         System.out.println("-----");
  15.         Inter.method2();
  16.     }
  17. }

13.体验方法引用

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

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

答案肯定是没有必要

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

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

  1. package com.study_01;
  3. public interface Printable {
  4.     void printString(String s);
  5. }
  1. package com.study_01;
  3. public class PrintableDemo {
  4.     public static void main(String[] args) {
  5.         // 在主方法中调用usePrintable方法
  7. //        usePrintable((String s) -> {
  8. //            System.out.println(s);
  9. //        });
  11.         usePrintable(s -> System.out.println(s));
  13. //        System.out.println("爱生活很好");
  15.         //方法引用符 ::
  16.         usePrintable(System.out::println);
  18.         // 可推导的就是课省略的
  20.     }
  22.     private static void usePrintable(Printable p) {
  23.         p.printString("爱生活很好");
  24.     }
  25. }

14.方法引用符

  1. package com.study_02;
  3. public interface Printable {
  4.     void printInt(int i);
  5. }
  1. package com.study_02;
  3. public class PrintableDemo {
  4.     public static void main(String[] args) {
  5.         // 在主方法中调用usePrintable方法
  6. //        usePrintable(i -> System.out.println(i));
  8.         // 方法引用
  9.         usePrintable(System.out::println);
  10.     }
  12.     private static void usePrintable(Printable p) {
  13.         p.printInt(666);
  14.     }
  15. }

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

常见的引用方式:

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

引用类方法

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

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

练习：

  • 定义一个接口（Converter）,里面定义一个抽象方法i
    • int convert(Strings);
  • 定义一个测试类（ConverterDemo），在测试类中提供两个方法
    • 一个方法是：useConverter(Converter c);
    • 一个方法是主方法，在主方法中调用useConverter方法
  1. package com.study_03;
  3. public interface Converter {
  4.     int convert(String s);
  5. }
  1. package com.study_03;
  3. public class ConverterDemo {
  4.     public static void main(String[] args) {
  5.         // 在主方法中调用useConverter方法
  6.         // 重写 Converter接口 中的 convert方法 是有返回值的
  7. //        useConverter((String s) -> {
  8. //            return Integer.parseInt(s);
  9. //        });
  11.         useConverter(s -> Integer.parseInt(s));
  13.         // 引用类方法
  14.         useConverter(Integer::parseInt);
  16.         // Lambda表达式被类方法替代的时候,它的形式参数全部传递给静态方法作为参数
  19.     }
  21.     private static void useConverter(Converter c) {
  22.         int number = c.convert("666"); // 将convert方法返回值赋给 number
  23.         System.out.println(number);
  24.     }
  25. }

16.引用对象的实例方法

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

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

练习

  • 定义一个类（PrintString），里面定义一个方法
    • public void printUpper(String s)：把字符串参数变成大写的数据，然后在控制台输出
  • 定义一个接口（Printer），星面定义一个抽象方法
    • void printUpperCase(Strings);
  • 定义一个测试类（PrinterDemo），在测试类中提供两个方法
    • 一个方法是：usePrinter(Printerp);
    • 一个方法是主方法，在主方法中调用usePrinter方法
  1. package com.study_04;
  3. public interface Printer {
  4.     void printUpperCase(String s);
  5. }
  1. package com.study_04;
  3. public class PrintString {
  4.     // 把字符串参数变成大写的数据,然后在控制台输出
  5.     public void printUpper(String s) {
  6.         String result = s.toUpperCase();
  7.         System.out.println(result);
  8.     }
  9. }
  1. package com.study_04;
  3. public class PrinterDemo {
  4.     public static void main(String[] args) {
  5.         // 在主方法中调用usePrinter方法
  6. //        usePrinter((String s) -> {
  7. ////            String resuult = s.toUpperCase();
  8. ////            System.out.println(resuult);
  9. //            System.out.println(s.toUpperCase());
  10. //        });
  12.         usePrinter(s -> System.out.println(s.toUpperCase()));
  14.         // 引用对象的实例方法
  15.         PrintString ps = new PrintString();
  16.         usePrinter(ps::printUpper);
  18.         //Lambda表达被对象实例方法替代的时候,它的形式参数全部传递给该方法作为参数
  19.     }
  22.     private static void usePrinter(Printer p) {
  23.         p.printUpperCase("HelloWorld");
  24.     }
  25. }

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方法
  1. package com.study_05;
  3. public interface MyString {
  4.     String mySubString(String s, int x, int y);
  5. }
  1. package com.study_05;
  3. public class MyStringDemo {
  4.     public static void main(String[] args) {
  5.         // 在主方法中调用useMyString方法
  7. //        useMyString((String s,int x ,int y) -> {
  8. //            return s.substring(x,y);
  9. //        });
  11.         useMyString((s,x,y) -> s.substring(x,y));
  13.         // 引用类的实例方法
  14.         useMyString(String::substring);
  16.         // Lambda表达式被类的实例方法替代的时候
  17.         // 第一个参数作为调用者
  18.         // 后面的参数全部传递给该方法作为参数
  19.     }
  20.     private static void useMyString(MyString my) {
  21.         String s = my.mySubString("HelloWorld",2,5);
  22.         System.out.println(s);
  23.     }
  24. }

18.引用构造器

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

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

练习

  • 定义一个类（Student），里面有两个成员变量（name，age）
    • 并提供无参构造方法和带参构造方法，以及成员变量对应的get和set方法
  • 定义一个接口（StudentBuilder），里面定义一个抽象方法
    • Student build(String name，int age);
  • 定义一个测试类（StudentDemo），在测试类中提供两个方法
    • 一个方法是：useStudentBuilder(StudentBuilders);
    • 一个方法是主方法，在主方法中调用useStudentBuilder方法
  1. package com.study_06;
  3. public interface StudentBuilder {
  4.     Student build(String name,int age);
  5. }
  1. package com.study_06;
  3. public class Student {
  4.     private String name;
  5.     private int age;
  7.     public Student() {
  8.     }
  10.     public Student(String name, int age) {
  11.         this.name = name;
  12.         this.age = age;
  13.     }
  15.     public String getName() {
  16.         return name;
  17.     }
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  23.     public int getAge() {
  24.         return age;
  25.     }
  27.     public void setAge(int age) {
  28.         this.age = age;
  29.     }
  30. }
  1. package com.study_06;
  3. public class StudentDemo {
  4.     public static void main(String[] args) {
  5. //        useStudentBuilder((String name,int age) -> {
  6. ////            Student s = new Student(name,age);
  7. ////            return s;
  8. //            return new Student(name,age);
  9. //        });
  11.         useStudentBuilder((name,age) -> new Student(name,age));
  13.         // 引用构造器
  14.         useStudentBuilder(Student::new);
  16.         //Lambda表达式被构造器替代的时候,他是形式参数全部传递给构造器作为参数
  17.     }
  20.     private static void useStudentBuilder(StudentBuilder sb) {
  21.         Student s = sb.build("林青霞",30);
  22.         System.out.println(s.getName()+","+s.getAge());
  23.     }
  24. }