13Lambda、函数式接口、Stream

1、Lambda表达式

Lambda表达式的介绍与使用

匿名内部类的格式：
new 父类或接口() {
//重写父类或接口的方法
}
匿名内部类很多地方是冗余的。
比如使用匿名内部类的方式实现多线程。
因为Thread构造方法参数需要一个Runnable类型的数据，所以我们不得不写new Runnable。
因为要重写Runnable中的run方法，所以又不得不写了run方法等声明
整个匿名内部类中最关键内容是方法，方法最重要的东西有前中后三点。
前：参数。
中：方法体
后：返回值
最好的情况是我们只关注匿名内部类中这些最核心的东西（方法的参数，方法体，返回值）。
Lambda表达式只关注方法的参数，方法体，以及返回值。
Lambda表达式是匿名内部类的简化写法。
Lambda表达式是属于函数式的编程思想

面向对象思想：怎么做
函数式编程思想：做什么
匿名内部类的好处是可以省略单独创建.java文件的操作。但是匿名内部类也有缺点，就是语法有些冗余。匿名内部类中最核心的东西是方法的参数，方法体，返回值，其他的内容都是为了满足格式不得不写的一些东西。匿名内部类的简化写法是lambda表达式，lambda表达式只需要关注方法的参数，方法体，返回值。

Lambda的标椎格式：
（参数类型参数名）->{
方法体；
return 返回值；
}
格式解释：
（1）小括号中的参数和之前的方法的参数一样，多个参数之间要使用逗号隔开。
（2）->箭头是一个运算符，表示指向性的动作。
（3）大括号中的内容和之前的方法大括号中的内容是一样的。

Lambda表达式可以省略面向对象中的一些条条框框，让我们只关注最核心的内容。
使用了函数式编程的思想：可推导，可以省略。

因为Thread构造方法中需要Runnable接口类型的参数，所以可以省略new Runnable。同时因为Runnable中只有一个抽象方法run，所以重写的必然是这个抽象方法，那么也可以省略run方法的声明部分。

使用比较器排序，对保存学生对象的集合根据年龄升序排序。

public static void main(String[] args) {
        //创建集合
        List<Student> list = new ArrayList<>();
        //添加学生对象
        list.add(new Student("嫐", 20));
        list.add(new Student("嬲", 18));
        list.add(new Student("挊", 22));
        //使用比较器排序，对集合中的学生对象根据年龄升序排序。
        //Collections.sort(list, new Rule());
        //进行比较器排序，使用匿名内部类的方式
        /*
        Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        */
        //进行比较器排序，使用Lambda表达式
        /*
        Collections.sort(list, (Student o1, Student o2) -> {
            return o1.getAge() - o2.getAge();
        });
        */
        Collections.sort(list, (o1, o2) -> o1.getAge() - o2.getAge());
        //输出集合
        System.out.println(list);
}

Lambda表达式的标准格式：
（参数类型参数名）->{
方法体；
return返回值；
}
省略规则：小括号中的参数类型可以省略；
如果小括号中只有一个参数，那么可以省略小括号。
如果大括号中只有一条语句，那么无论该方法有没有返回值，都可以省略大括号。
接口：

package cn.itcast.demo01_lambda;

public interface MyInterface {
    //提供抽象方法
    void printStr(String str);
}

测试类

public class Test {
    public static void main(String[] args) {
        method(new MyInterface() {
            @Override
            public void printr(String string) {
                System.out.println(string);
            }
        });

        method((String str) ->{
            System.out.println(str);
        });
        

        method(str -> System.out.println(str));
    }

    public static void method(MyInterface myInterface) {
        myInterface.printr("hello");
    }
}

Lambda表达式的使用前提

（1）必须要有接口（不能是抽象类），接口中必须有且只有一个需要被重写的抽象方法。
（2）必须支持上下文推导。要能够推导出来这个Lambda表达式表示的是哪个接口中的内容。常用的一种上下文推导方式是使用Lambda表达式当做方法参数（传递给一个接口类型）也可以将Lambda表达式赋值给一个接口类型的变量。

public static void method(MyInterface m) {
        m.printStr("hello");
    }

    public static void main(String[] args) {
        //调用method方法
        //method(str -> System.out.println(str));

        //使用匿名内部类方式创建对象
        /*
        MyInterface m = new MyInterface() {
            @Override
            public void printStr(String str) {
                System.out.println(str);
            }
        };
        */
        //将Lambda表达式赋值给接口类型。
        MyInterface m = str -> System.out.println(str);
        m.printStr("HELLO");
}

函数是接口

函数式接口的介绍

如果一个接口中有且仅有一个需要被重写的抽象方法，那么这个接口就是一个函数式接口。函数式接口可以当做Lambda表达式的使用前提。
有一个注解叫做@FunctionalInterface可以验证一个接口是否是函数式接口，如果在接口上面加上@FunctionalInterface注解报错，那么就说明该接口不是函数式接口，如果在接口上面加上@FunctionalInterface注解不报错，那么就说明该接口是一个函数式接口。

@FunctionalInterface仅仅用来验证一个接口是否是函数式接口，如果不使用该注解，只要接口符合函数式接口的规则，那么他就是一个函数式接口。
在jdk8的时候，提供了java.util.function，这个包下面有大量的函数式接口。
其中有一个函数式接口叫做Consumer，可以把它看成一个消费者，可以去消费（使用）一个数据。

抽象方法：void accept（T t）：用来消费（使用）一个数据。

public class Demo01Consumer {
    //定义方法，使用函数式接口Consumer当做参数
    public static void method(Consumer<String> c) {
        //通过c调用accept方法，使用字符串
        c.accept("hello");
    }

    public static void main(String[] args) {
        //调用method方法，传递匿名内部类对象。
        /*
        method(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        */
        //调用method方法，传递Lambda表达式
        method(s -> System.out.println(s));

    }
}

在Java中还有一个函数式接口叫做Predicate，这个函数式接口可以判断一个数据是否符合要求。
抽象方法：boolean test(T t)：判断一个数据t是否符合要求。

public class Demo02Predicate {
    //定义方法，使用函数式接口Predicate当做方法参数
    public static void method(Predicate<String> p) {//p= s -> s.length() == 5
        //调用方法，判断hello这个字符串是否符合要求
        boolean flag = p.test("hello");
        System.out.println(flag);
    }

    public static void main(String[] args) {
        //调用method方法
        method(s -> s.length() == 5);
    }
}

Stream流

Stream流的获取

Stream是一个接口，这个接口表示的就是流。
获取Stream流的两种方法：
（1）通过Collection单列集合获取。
（2）通过数组获取流。

通过Collection单列集合获取流：
在Collection中有一个方法，叫做stream，可以得到集合对应的流。
Stream stream():获取集合对应的流。

public class Demo02CollectionGetStream {
    public static void main(String[] args) {
        //创建List集合
        List<String> list = new ArrayList<>();
        //添加元素
        list.add("aa");
        list.add("bb");
        list.add("cc");
        //调用集合的stream方法，获取流
        Stream<String> stream = list.stream();

        //调用stream的toArray将流转成数字，然后再使用数组的工具类将内容输出
        System.out.println(Arrays.toString(stream.toArray()));
    }
}

通过数组获取流：
（1）使用Stream中的静态方法of获取。
static Stream of(T… values)：根据数组获取流，参数是可变参数，可以传递多个数据，也可以传递数组。
（3）使用Arrays工具类中的stream方法获取。

public class Demo03ArrayGetStream {
    public static void main(String[] args) {
        //1. 使用Stream中的静态方法of获取
        String[] strArr = {"aa", "bb", "cc", "dd"};
        //static Stream of(T... values)： 根据数组获取流
        //Stream<String> stream = Stream.of(strArr);
        Stream<String> stream = Stream.of("hello", "world", "java");
        //输出Stream流中的内容
        System.out.println(Arrays.toString(stream.toArray()));

        //2. 使用Arrays工具类中的stream方法获取
        Stream<String> stream2 = Arrays.stream(strArr);
        System.out.println(Arrays.toString(stream2.toArray()));
    }
}

Stream流的常用方法

（1）forEach：在Stream中，有一个方法叫做forEach，可以对流中的元素进行逐一处理。
void forEach(Consumer action)：参数需要传递Consumer类型，Consumer表示消费者。
forEach方法的参数定义的就是处理的规则（如何进行处理）
forEach方法参数是函数式接口Consumer类型，那么我们可以传递Lambda表达式，这个Lambda表达式表示的含义是如何处理。
（2）在Stream中，有一个方法叫做filter，可以对流中的元素进行过滤（筛选）
Stream filter(Predicate predicate)：对流中的元素进行过滤（筛选）
filter方法参数需要一个Predicate类型，Predicate这个函数式接口的作用是用来判断一个数据是否符合要求。
我们要在参数Predicate中定义过滤的规则，如果判断成立，那么表示该数据留下，如果判断不成立表示该数据过滤掉。
filter方法参数是Predicate函数式接口，那么我们可以传递Lambda表达式，该Lambda表达式表示的是Predicate中
唯一的抽象方法test的内容(重写后)，我们要在Lambda表达式中定义过滤规则，如果条件成立，那么数据不会过滤掉，
如果条件不成立，那么数据会被过滤掉。
（3）在Stream中，有一个方法叫叫做count，可以获取流中元素的个数
long count()：获取流中元素的个数
（4）在Stream中，有一个方法叫做limit，可以获取流中的前几个元素
Stream limit(long n)：获取流中的前n个元素。
（5）在Stream中，有一个方法叫做skip，可以跳过流中的前几个元素。
Stream skip(long n)：跳过流中的前n个元素
（6）在Stream中，有一个静态方法叫做concat，可以对两个流进行合并。
static Stream concat(Stream a, Stream b)：对参数a和b这两个流进行合并，合并成新的流。
注意：流的注意事项：
1. 调用Stream的非终结方法会返回Stream流对象，但是返回的Stream是一个新的流。（forEach、count为终结方法，不能连接操作）
2. 流只能一次性使用。