Lambda表达式和Stream流

Lambda表达式

1.体验Lambda表达式

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

方式1：

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

        MyRunnable my = new MyRunnable();
        Thread t = new Thread(my);
        t.start();

方式2：

• 匿名类的方式改进

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

方式3：

• Lambda表达式的方式改进

        //Lambda表达式的方式改进
        new Thread(() -> {
            System.out.println("多线程程序启动了");
        }).start();

1.3Lambda表达式的标准格式

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

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

Lambda表达式的代码分析

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

组成Lambda表达式的三要素：形式参数、箭头、代码块

Lambda表达式的标准格式

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

Lambda表达式的练习

Lambda表达式的使用前提

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

练习1：

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

练习2：

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

练习3：

• 定义一个接口(Addable)，里面定义一个抽象方法: int add(int x, int y)
• 定义一个测试类(AddableDemo)，在测试类中提供两个方法
  • 一个方法是:useAddable(Addable a)
  • 一个方法是主方法，在主方法中调用useAddable方法
    

Lambda表达式的省略模式

省略规则:

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

Lambda表达式的注意事项

注意事项:

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

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

所需类型不同

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

使用限制不同

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

Stream流

1.体验Stream流

需求：按照下面的要求完成集合的创建和遍历

• 创建一个集合，存储多个字符串元素
• 把集合中所有以"张"开头的元素存储到一个新的集合
• 把"张"开头的集合中的长度为3的元素存储到一个新的集合
• 遍历上一步得到的集合

1.2Stream流的生成方式

Stream流的使用

• 生成流
  通过数据源（集合、数组等）生成流
  list.stream()
• 中间操作
  一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程序的数据过滤/映射，然后返回一个新的流，交给下一个操作使用
  filter()
• 终结操作
  一个流只能有一个终结操作，当这个操作执行后，流就被使用"光"了，无法再被操作。所以这必定是流的最后一个操作。
  forEach()

Stream流的生成方式

Stream流的常见生成方式

• Collection体系的集合可以使用默认方法stream()生成流
  defaultStream<E> stream()
• Map体系的集合间接的生成流
• 数组可以通过Stream接口的静态方法of(T…values)生成流

链式编程

链式编程

所谓的链式编程，则是类似与StringBuffer的append方法的写法：

StringBuffer buffer = new StringBuffer();
// 链式编程
buffer.append("aaa").append("bbb").append("ccc");

如何实现

那么问题来了，怎么实现这种酷炫的连写代码呢？其实很简单，那就是在方法的最后写上return this;如果大家去看StringBuffer的append的源代码，也可以发现，它里面也是这么写的，我们除了在拼接字符串的时候这么用，在什么时候也可以这样使用链式编程呢？在创建实体bean对象的时候，也可以这么写。

public class Dog {

    private int weight;

    private String dogType;

    private String color;

    public int getWeight() {
        return weight;
    }

    public Dog setWeight(int weight) {
        this.weight = weight;
        return this;
    }

    public String getDogType() {
        return dogType;
    }

    public Dog setDogType(String dogTye) {
        this.dogType = dogTye;
        return this;
    }

    public String getColor() {
        return color;
    }

    public Dog setColor(String color) {
        this.color = color;
        return this;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "weight=" + weight +
                ", dogType='" + dogType + '\'' +
                ", color='" + color + '\'' +
                '}';
    }
}

因此在创建这个实体的时候就可以这么写：

Dog dog1 = new Dog();
//常规赋值风格
dog1.setColor("黑色");
dog1.setDogType("牧羊");
dog1.setWeight(100);
System.out.println(dog1.toString());

//链式编程风格
Dog dog2 = new Dog();
dog2.setWeight(1001).setDogType("土狗").setColor("紫色");
System.out.println(dog2.toString());

Java里实现链式编程风格