Java 8 Lambda 表达式&Stream

Lambda 表达式

Lambda出现的背景：
     Java 是面向对象语言，除了部分简单数据类型，Java 中的一切都是对象，即使数组也是一种对象，每个类创建的实例也是对象。在 Java 中定义的函数或方法不可能完全独立，也不能将方法作为参数或返回一个方法给实例。在 Java 8 以前，若我们想要把某些功能传递给某个方法，总要去写匿名类。

Car car=new Car(111,"宝马");
        Car car1=new Car(222,"宝马");
        Car car2=new Car(333,"宝马");
        Car car3=new Car(444,"宝马");
        Car[]cars={car2,car1,car,car3};//创立一个Car类型数组，并将没有乱序的对象插入其中
        Arrays.sort(cars, new Comparator<Car>() {//使用内部类的方式，创立了一个接口内部类对象。即匿名内部类
            @Override
            public int compare(Car o1, Car o2) {
                return o1.getNum()-o2.getNum();
            }
        });

在上面的例子里，为了对集合集合进行排序，我们为 Comparator 接口创建了一个它的匿名内部类对象，重写接口中的方法,来实现排序功能。

而在JAVA8增加一个语言级的新特性，名为Lambda表达式。

Lambda表达式简介：

    Lambda 表达式是一个匿名函数，我们可以把 lambda 表达式理解为一段可以传递的代码（将代码段像数据一样传递）。使用它可以写出更简洁， 更灵活的代码。作为一种更紧凑的代码风格，使 java 语言的表达式能力得到的提升。Lambda 表达式的本质只是一个"语法糖",由编译器推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能。

这里提一嘴，"语法糖"（Syntactic sugar），也译为糖衣语法，是由英国计算机科学家彼得·约翰·兰达（Peter J. Landin）发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。通常来说使用语法糖能够增加程序的可读性，从而减少程序代码出错的机会。

Lambda 表达式的结构

1. Lambda 表达式可以具有零个，一个或多个参数。

2. 可以显式声明参数的类型，也可以由编译器自动从上下文推断参数的类型。
    例如 (int a,int b)与 (a,b)相同。

3. 参数用小括号括起来，用逗号分隔。例如 (a, b) 或 (int a, int b) 或 (String a, int b, float c)。

4. 空括号用于表示一组空的参数。例如 () -> 42。

5. 当有且仅有一个参数时，如果不显式指明类型，则不必使用小括号。
    例如 a -> return a*a。

6. Lambda 表达式的正文可以包含零条，一条或多条语句。

7. 如果 Lambda 表达式的正文只有一条语句，则大括号可不用写，且表达式
的返回值类型要与匿名函数的返回类型相同。

8. 如果 Lambda 表达式的正文有一条以上的语句必须包含在大括号（代码块）中，且表达式的返回值类型要与匿名函数的返回类型相同。

9. Java 中的 Lambda 表达式通常使用 (argument) -> {body}语法书写

      左侧：lambda 表达式的参数列表         右侧：lambda 表达式中需要执行的功能，即 lambda 体

例如上图中我们给Car数组排序，便可以使用Lambda表达式。

public class CarText {
    public static void main(String[] args) {
        Car car=new Car(111,"宝马");
        Car car1=new Car(222,"宝马");
        Car car2=new Car(333,"宝马");
        Car car3=new Car(444,"宝马");
        Car[]cars={car2,car1,car,car3};//创立一个Car类型数组，并将没有乱序的对象插入其中
        /*Arrays.sort(cars, new Comparator<Car>() {//使用内部类的方式，创立了一个接口内部类对象。即匿名内部类
            @Override
            public int compare(Car o1, Car o2) {
                return o1.getNum()-o2.getNum();
            }
        });*/
        Arrays.sort(cars,(o1, o2) ->{//比上面匿名内部类更简洁的方法，lambda方法。两者作用一样
            return o1.getNum()-o2.getNum();
        });
        System.out.println(Arrays.toString(cars));
    }
}

虽然上面说了那么多使用规则，但我们作为初学者建议无脑使用（）->{}，这种语法体，万物通用。

下面我们自定义接口用Lambda方法体实现接口。

public interface Oper {//自定义创建接口
    public void show();
}
public class OperText {
    public void text(Oper oper){
        oper.show();
    }
    public static void main(String[] args) {
        OperText operText=new OperText();
        operText.text(()->{//使用Lambda表达式 重写接口中的方法
            System.out.println("Oper中的show方法");
        });
    }
}

 上图是无参的抽象方法，下图是有参的抽象方法。

@FunctionalInterface//表示是一个功能函数接口,接口中只能定义一个抽象方法
public interface Oper {//自定义创建接口
    //public void show();
    int add(int a,int b);//使用lambda表达式接口中,只能有一个抽象方法,因为需要自动类型推断
}
public class OperText {
    public void text(Oper oper){
        //oper.show();
        oper.add(8,9);
    }
    public static void main(String[] args) {
        OperText operText=new OperText();
        operText.text((a,b)->{
           return a+b;
        });
        /*operText.text(()->{//使用Lambda表达式 重写接口中的方法
            System.out.println("Oper中的show方法");
        });*/
    }
}

 注意使用Lambda表达式所实现的接口中的抽象方法只能拥有一个。而@FunctionalInterface表示接口中只能定义一个抽象方法。

功能接口（Functional interface）

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

 如图所示功能接口只能有一个抽象方法。如果我们尝试在其中添加一个抽象方法，则会抛出编译时错误。

Stream

    Stream 是 Java8 的新特性,它允许你以声明式的方式处理数据集合，可以把它看作是遍历数据集的高级迭代器。此外与 stream 与 lambada 表达示结合后编码效率与大大提高，并且可读性更强。

      要注意的是 java8 中的 stream 与 InputStream 和 OutputStream 是完全不同的概念。

      提供了对象数据集合进行操作的各种方法,我们只需要声明式的告诉其应该做什么。

什么是流呢？

就是一个对集合进行遍历操作的高级迭代器.

简单的定义，就是“从支持数据处理操作的源,生成的元素序列”。

元素列表 ：和集合一样，流也提供了一个接口,访问特定元素类型的一组有序值。

数据源 : 获取数据的源，比如集合。

数据处理操作 : 流更偏向于数据处理和计算，比如 filter、map、find、sort 等。

简单来说，我们通过一个集合的 stream 方法获取一个流，然后对流进行一系列流操作，最后再构建成我们需要的数据集合。

获取流

使用 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<Apple> apples = applestore
.stream()               获得流
.filter(a -> a.getColor().equals("red"))           中间操作
.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

 下面给出一些代码示例方便理解。

public class StreamDemo {
    public static void main(String[] args) {
        Integer []arr={3,6,7,2,1,4,9,5,4,1};
        Arrays.stream(arr)//将数组转换为流
              .distinct()//去除重复元素
              .filter((e)->{return e<6;})//过滤元素
              .sorted((a,b)->{return a-b;})//排序
              .limit(4)//限制获取几个元素
              .skip(2)//跳过几个元素
              .forEach(integer -> {
                  System.out.println(integer);
              });//遍历元素
    }
}

 

Integer[]i={4,5,1,2,1,4};
        long count= Arrays.stream(i).distinct()
                                    .sorted((a,b)->{
                                        return a-b;})
                                    .limit(3)
                                    .count();//元素个数整合
        System.out.println(count);

 

 

Integer max=Arrays.stream(i).distinct()
                            .max((a,b)->{return a-b;})//两个元素进行比较
                            .get();//终端操作得到元素
        System.out.println(max);

 

 

boolean bo=Arrays.stream(i).distinct()
                .anyMatch((e)->{return  e>5;}); //只要有一个元素满足返回true，否则false
        System.out.println(bo);

List<Integer>list=Arrays.stream(i).distinct()
                                          .collect(Collectors.toList());//将流中的元素放入一个集合
        System.out.println(list);

  

 以下是对于对象的Stream使用

public class StreamDemo3 {
    public static void main(String[] args) {
        Car car=new Car(111,"宝马","粉色");
        Car car1=new Car(222,"宝马","黑色");
        Car car2=new Car(333,"宝马","彩色");
        Car car3=new Car(444,"宝马","白色");
        Car[]cars={car2,car1,car,car3};
        List<Car> list= Arrays.stream(cars).distinct()
                                           .sorted(((o1, o2) -> {
                                               return o1.getNum()-o2.getNum(); }))//排序
                                           .filter((c)->{return c.getColor().equals("粉色");})//筛选只有粉色的车
                                           .collect(Collectors.toList());
        System.out.println(list);
        Map<Integer,String> map=Arrays.stream(cars)
                                      .distinct()
                                      .sorted(((o1, o2) -> {
                                                return o1.getNum()-o2.getNum(); }))
                                      .collect(Collectors.toMap(Car::getNum,Car::getName));
                                      //将Car的num当做键，name当做值。
        System.out.println(map);

        List<String>list1=Arrays.stream(cars)
                                 .map(Car::getColor)//映射出新的元素
                                 .collect(Collectors.toList());
        System.out.println(list1);
    }
}