JavaSE---Lambda&Stream语法

背景

有一个学生类，传入5个学生对象，然后用ArrayList存储并输出，传入时无序，想要输出时按照自然顺序（学生的学号大小）排序。Comparator是一个排序比较接口，里面定义了一个比较的方法，但是没有实现共4种方法

package com.ffyc.javaoop.day13.Lambda;

public class Student {
    int no;
    String name;

    public Student(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Demo2 {
    public static void main(String[] args) {
        Student s1 = new Student(101,"jim1");
        Student s2 = new Student(102,"jim2");
        Student s3 = new Student(103,"jim3");
        Student s4 = new Student(104,"jim4");
        Student s5 = new Student(105,"jim5");
        ArrayList<Student> students = new ArrayList<>();
        students.add(s2);
        students.add(s3);
        students.add(s1);
        students.add(s5);
        students.add(s4);
        /*
        排序方法
        */
        System.out.prinntln(students);

1.写一个Comparator接口实现类(单独的类，此类只用于学生排序)

import java.util.Comparator;
/*
自定义一个学生排序类
 */
public class StudentComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getNo()-o2.getNo();
    }
}

students.sort(new StudentComparator());

2.将学生排序功能写成一个内部类，将功能封装在类的内部，内部类也是需要定义一个类的

 /*
    内部类，在类的里面，main方法的外面
    内部类也是属于外部类成员
     */

    static class StudentComparator implements Comparator<Student>{

        @Override
        public int compare(Student o1, Student o2) {
            return o1.getNo()-o2.getNo();
        }
    }

students.sort(new StudentComparator());

3.在内部类的基础上，为了进一步简化语法，推出匿名内部类

new + 接口名/抽象类名 都不是在创建接口/抽象类对象
是在创建一个匿名的类的对象，有一个匿名的类实现了此接口

 匿名内部类
        students.sort(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getNo()-o2.getNo();
            }
        });

外部类 内部类 匿名内部类，核心都是对排序的方法进行实现，将方法转载一个对象中
传递给了sort()方法。
关于内部类，可以参考内部类

4.(Lambda表达式)在java8之后，对匿名内部类的写法进行了简化，可以将函数直接作为参数传递

students.sort((o1, o2) -> {return o1.getNo()-o2.getNo();});//把函数当做参数

如果不能理解，可以看做这种方法

可以理解为这种
        Comparator<Student> c = (o1, o2) -> {return o1.getNo()-o2.getNo();};
        students.sort(c);

Lambda

Lambda表达式是一个匿名函数，可以理解为一段可以传递的代码，Lambda表达式的本质只是一个“语法糖”，由编译器推断并帮你转包装为常规的代码。
Lambda 表达式可以具有零个，一个或多个参数。
可以显式声明参数的类型，也可以由编译器自动从上下文推断参数的类型。
例如 (int a,int b)与 (a,b)相同。
参数用小括号括起来，用逗号分隔。例如 (a, b) 或 (int a, int b) 或 (String
a, int b, float c)。
空括号用于表示一组空的参数。例如 () -> 42。
当有且仅有一个参数时，如果不显式指明类型，则不必使用小括号。
例如 a -> return a*a。
Lambda 表达式的正文可以包含零条，一条或多条语句。
如果 Lambda 表达式的正文只有一条语句，则大括号可不用写，且表达式
的返回值类型要与匿名函数的返回类型相同。
如果 Lambda 表达式的正文有一条以上的语句必须包含在大括号（代码块）
中，且表达式的返回值类型要与匿名函数的返回类型相同

public interface LambdaInterface {
    public abstract int test(int a,int b);
    public static void testStatic(int a){

    }
}

 /*
        使用lambda 要求是接口中/抽象类中只能有一个抽象方法
        用于类型推断
        ()参数列表
        ->{}函数体
         */
        //LambdaInterface lam = (a,b)->{ System.out.println("aaaa"); };
        LambdaInterface lam = (a,b)->{
             return a+b; };

//无参数，无返回值，lambda 体中只有一行代码时，{}可以忽略
() -> System.out.println("Hello World");
//无参数，有返回值
() -> { return 3.1415 };
//有参数，无返回值
(String s) -> { System.out.println(s); }
//有一个参数，无返回值
s -> { System.out.println(s); }
//有多个参数，有返回值
(int a, int b) -> { return a + b; }
//有多个参数，表达式参数类型可以不写，jvm 可以根据上下文进行类型推断
(a, b) -> { return a - b; }

//创建线程
       // T t = new T();
        //new Thread(t).start();
        new Thread(()->{
            System.out.println("线程做的事情");
        });
        //GUI组件添加监听事件
        JButton jb = new JButton("按钮");
        jb.addActionListener((e -> {
            
   }));

功能接口

Lambda 表达式只支持函数式接口 也就是只有一个抽象方法的接口.功能
接口是 java 8 中的新增功能，它们只允许一个抽象方法。这些接口也称为单抽
象方法接口。Java 8 也引入了一个注释，即@FunctionalInterface，当你注释
的接口违反了 Functional Interface 的契约时，它可以用于编译器级错误

Stream

Stream 是 Java8 的新特性,它允许你以声明式的方式处理数据集合，可以把
它看作是遍历数据集的高级迭代器。此外与 stream 与 lambada 表达示结合后
编码效率与大大提高，并且可读性更强。
要澄清的是 java8 中的 stream 与 InputStream 和 OutputStream 是完全不同的概念.

public static void main(String[] args) {
List<Apple> applestore = new ArrayList();
applestore.add(new Apple(1,"red",500,"河南"));
applestore.add(new Apple(2,"red",400,"陕西"));
applestore.add(new Apple(3,"green",300,"上海"));
applestore.add(new Apple(4,"green",200,"湖北"));
applestore.add(new Apple(5,"green",100,"湖南"));
}

我们的需求是在 applestore 集合中找出红色苹果手机. 使用 Stream 流快速实现

List<Apple> apples = applestore
.stream()
.filter(a -> a.getColor().equals("red"))
.collect(Collectors.toList());

这里使用的就是 Java8 中的 stream 流，使用的是声明性方式写的：说明想
要完成什么（筛选，排序，取值），而不说明如何实现一个操作（for 循环）。
同时可以将这些操作链接起来，达到一种流水线式的效果：

流，就是“从支持数据处理操作的源,生成的元素序列”
元素列表:和集合一样，流也提供了一个接口,访问特定元素类型的一组有序值。
数据源 :获取数据的源，比如集合。
数据处理操作 :流更偏向于数据处理和计算，比如 filter、map、find、sort 等。
简单来说，我们通过一个集合的 stream 方法获取一个流，然后对流进行一
系列流操作，最后再构建成我们需要的数据集合

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class StreamDemo1 {
    /*
    实际开发一个项目，产品周期比较长的，初期使用java8，后期不能随便更改jdk
    后期开始一个新项目，或者子项目使用新的jdk
    Stream是java8之后推出的新功能，用于对数据（集合，数组）进行高级迭代
    结合lambda使得语法更加简单
    使用声明方式处理数据集合
    与java中的IO流是完全不同的
     */
    public static void main(String[] args) {
        Student s1 = new Student(101,"jim1","男");
        Student s2 = new Student(102,"jim2","女");
        Student s3 = new Student(103,"jim3","男");
        Student s4 = new Student(104,"jim4","女");
        Student s5 = new Student(105,"jim5","女");
        ArrayList<Student> students = new ArrayList<>();
        students.add(s2);
        students.add(s3);
        students.add(s1);
        students.add(s5);
        students.add(s4);
        //以前对集合的操作，筛选出集合中性别为男的学生
      /*  for (Student s:students) {
            if(s.getGender().equals("男")){
                students.add(s);
            }
        }
        System.out.println(students);*/
        /*
        students.stream() 将集合（数据库）中的数据加入到一个Stream对象中
        Stream中提供了许多关于操作的方法
         */
        List<Student> list = students
                .stream()
                .filter((t)->{return t.getGender().equals("男");})//中间操作
                .collect(Collectors.toList());//把流再转为集合，也叫作终端操作
        System.out.println(list);//经过流操作的数据
        System.out.println(students);//数据源  是不变的
    }
}

-获取流

//使用 Collection 接口下的 stream()
List<String> list = new ArrayList<>();
Stream<String> stream = list.stream();
//使用 Arrays 中的 stream() 方法，将数组转成流
Integer[] nums = new Integer[10];
Stream<Integer> stream = Arrays.stream(nums);
//使用 Stream 中的静态方法：of()
Stream<Integer> stream = Stream.of(1,2,3,4,5,6);
//使用 BufferedReader.lines() 方法，将每行内容转成流
BufferedReader reader=new BufferedReader(new FileReader("stream.txt"));
Stream<String> lineStream = reader.lines();

-流操作

流操作可以分为两类：中间操作和终端操作。回看之前的代码：

List<Student> list = students
                .stream()
                .filter((t)->{return t.getGender().equals("男");})//中间操作
                .collect(Collectors.toList());//把流再转为集合，也叫作终端操作

简化一下就是：
数据源 => 中间操作 => 终端操作 => 结果
诸如 filter 或者 sort 等中间操作会返回另一个流，进而进行下一步流操作，而终
端操作则是将流关闭，构建新的数据集合对象（也可以不构建）。

-中间操作

filter：过滤流中的某些元素,
sorted(): 自然排序，流中元素需实现 Comparable 接口
distinct: 去除重复元素
limit(n): 获取 n 个元素
skip(n): 跳过 n 元素，配合 limit(n)可实现分页
map(): 将其映射成一个新的元素

-终端操作

forEach: 遍历流中的元素
toArray:将流中的元素倒入一个数组
Min:返回流中元素最小值
Max:返回流中元素最大值
count:返回流中元素的总个数
Reduce:所有元素求和
anyMatch:接收一个 Predicate 函数，只要流中有一个元素满足条件则返回 true，否则返回 false
allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返回 true，否则返回 false
findFirst：返回流中第一个元素
collect:将流中的元素倒入一个集合,Collection 或 Map