【Java 8 Lambda 表达式 和 Java8Stream】

一、Java 8 Lambda 表达式

1.出现的背景

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

     list.sort(new Comparator<User>() {
     @Override
     public int compare(User o1, User o2) {
     return o1.getId()-o2.getId();
   }
}

          在上面的例子里，为了对集合集合进行排序，我们为 Comparator 接口创建 了一个它的匿名内部类对象，重写接口中的方法,来实现排序功能. 简而言之，在 Java 里将普通的方法或函数像参数一样传值并不简单，为此， Java 8 增加了一个语言级的新特性，名为 Lambda 表达式。

(就是用更少的代码实现一样的功能,简化代码)

课堂案例:

@FunctionalInterface  //表示一个功能接口,接口中只能定义一个抽象方法,因为java会进行自动类型推断.
public interface Oper {
    void show();
    //void show1();  写上去,编译器会报错,上面的@FunctionalInterface也会报错
}

public void test(Oper oper){
        oper.show();
    }

 TestOper testOper=new TestOper();
        testOper.test(new Oper() {
            @Override
            public void show() {
                System.out.println("aaa");
            }
        });     // 匿名内部类的写法   

Lambda 表达式简化后:

  testOper.test(()->{
            System.out.println("aaa");
        });

2.Lambda 表达式简介

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

       Lambda 表达式的本质只是一个"语法糖",由编译器推断并帮你转换包装为 常规的代码,因此你可以使用更少的代码来实现同样的功能。

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

3.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 表达式的正文有一条以上的语句必须包含在大括号(代码块) 中，且表达式的返回值类型要与匿名函数的返回类型相同。

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

左侧：lambda 表达式的参数列表

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

(arg1, arg2......) -> { body } (type1 arg1, type2 arg2...) -> { body }

无参数，无返回值，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;}

4.什么是功能接口（Functional interface）

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

          以下是自定义功能接口的示例：

@FunctionalInterface
public interface WorkerInterface {//表示一个功能接口,接口中只能定义一个抽象方法,因为java会进行自动类型推断.
public void doSomeWork();  //只能定义一个抽象方法
//public void domoreWork();  会报编译时错误
}

二、Java8Stream

1.什么是 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 集合中找出红色苹果手机

用原来的知识:遍历这个集合,拿出一个applestore对象,调出对象中的数据(这个做法太过繁琐)

使用 Stream 流快速实现操作

List<Apple> apples = applestore.stream()  //获取流
     .filter(a -> a.getColor().equals("red"))//中间操作
     .collect(Collectors.toList());  //终端操作
  

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

            Java8 中的集合支持一个新的 Stream 方法，它会返回一个流 

什么是流呢？

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

元素列表:

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

数据源:

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

数据处理操作:

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

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

2.获取流

使用 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();

课堂案例:

public static void main(String[] args) {
    Integer []array={4,2,1,3,5};
        Arrays.stream(array);         //数组转为流

        Stream.of(array);             //数组转为流

        ArrayList<Integer>list=new ArrayList<>();
                list.add(1);
                list.add(3);
                list.add(5);
                list.add(2);
                list.add(4);
                list.stream();       //集合转为流

3.流操作

流操作可以分为两类：中间操作和终端操作。

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(): 将其映射成一个新的元素

下面是具体的代码实现:

public static void main(String[] args) {

        Integer []array={4,2,1,3,5,6,8,7,1,5};
        Arrays.stream(array)    //返回一个Stream的流对象
              .distinct()      //去重
              .filter((e)->{return e<6;})  //对流进行过滤操作,又返回一个流对象  
              .sorted((a,b)->{return a-b;}) //对流进行排序,又返回一个流对象
                //中间操作可以有多个
                .limit(3)         //拿到指定数量的元素
                .skip(2)          //跳过指定数量的元素
              .forEach((e)->{      //遍历操作    终端操作只有一个
                  System.out.println(e);
              });

    }

终端操作

forEach: 遍历流中的元素(在之前有具体的代码实现)

toArray:将流中的元素倒入一个数组

Integer []array={4,2,1,3,5,6,8,7,1,5};
Object []obj=Arrays.stream(array)
                          .distinct()
                          .sorted((a,b)->{return a-b;})
                          .toArray();  //将流中的元素放入一个数组(Object类型的数组)
        System.out.println(Arrays.toString(obj));
 输出结果:[1,2,3,4,5,6,7,8]

Min:返回流中元素最小值

Max:返回流中元素最大值

Integer []array={4,2,1,3,5,6,8,7,1,5};
Integer max=Arrays.stream(array)
                .distinct()
                .max((a,b)->{
                    return a-b;   //返回的是一个Option,调用get()拿到里面的数据   终端操作
                })
                .get();
        System.out.println(max);//拿到元素中的最大值
输出结果:8

count:返回流中元素的总个数

Integer []array={4,2,1,3,5,6,8,7,1,5};
long  count=Arrays.stream(array)    
                   .distinct()     
                   .filter((e)->{return e<6;})  
                   .sorted((a,b)->{return a-b;}) 
                   .limit(4)         
                   .count();//返回一个long类型的值(返回元素的总个数)  
        System.out.println(count);
输出结果:8

Reduce:所有元素求和

 Integer []array={4,2,1,3,5,6,8,7,1,5};
Integer sum=Arrays.stream(array)
                          .distinct()
                          .reduce((a,b)->{return a+b;})  //所有元素求和
                          .get();
        System.out.println(sum);
输出结果:36

anyMatch:接收一个 Predicate 函数，只要流中有一个元素满足条件则返 回 true，否则返回 false

allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返 回 true，否则返回 false

 Integer []array={4,2,1,3,5,6,8,7,1,5};
boolean b=Arrays.stream(array)
                         .distinct()
                         .anyMatch((e)->{   //接收Predicate函数,只要流中有一个元素满足条件则返回true，否则返回false
                                return e>5;
                         });
        System.out.println(b);
输出结果:true


        boolean c=Arrays.stream(array)
                .distinct()
                .allMatch((e)->{   //接收Predicate函数,所有元素满足条件则返回true，否则返回false
                    return e>5;
                });
        System.out.println(c);
输出结果:false

findFirst：返回流中第一个元素

collect:将流中的元素倒入一个集合,Collection 或 Map

Integer []array={4,2,1,3,5,6,8,7,1,5};
List<Integer>list= Arrays.stream(array)
                       .distinct()
                       .collect(Collectors.toList());//将流中的元素放到一个list集合中
        System.out.println(list);
输出结果:[4, 2, 1, 3, 5, 6, 8, 7]

 public static void main(String[] args) {
        Car car1=new Car("宝马3",102,"白色");
        Car car2=new Car("宝马2",106,"红色");
        Car car3=new Car("宝马6",103,"粉色");
        Car car4=new Car("宝马5",105,"紫色");
        Car car5=new Car("宝马4",101,"黑色");
        Car car6=new Car("宝马1",104,"彩色");

       Car[]cars={car1,car2,car3,car4,car5,car6};
    List <Car>list=Arrays.stream(cars)
               .sorted((a,b)->{
                 return  a.getNum()-b.getNum();  //按照车牌号排序
               })
               .filter((e)->{
                   return e.getColor().equals("红色");  //取出红色这个元素
               })
                .collect(Collectors.toList());//toSet()去除重复元素
        System.out.println(list);

        List <Car>list1=Arrays.stream(cars)
                .sorted((a,b)->{
                    return  a.getNum()-b.getNum();
                })
                .collect(Collectors.toList());//toSet()去除重复元素
        System.out.println(list1);

        Map<String,String>carmap=Arrays.stream(cars)
                .sorted((a,b)->{
                    return  a.getNum()-b.getNum();
                })
                .collect(Collectors.toMap(Car::getName, Car::getColor));//把名字当作键,颜色当作值,创建map集合
        System.out.println(carmap);
输出结果:
[Car{name='宝马2', num=106, color='红色'}]
[Car{name='宝马4', num=101, color='黑色'}, Car{name='宝马3', num=102, color='白色'}, Car{name='宝马6', num=103, color='粉色'}, Car{name='宝马1', num=104, color='彩色'}, Car{name='宝马5', num=105, color='紫色'}, Car{name='宝马2', num=106, color='红色'}]
{宝马1=彩色, 宝马2=红色, 宝马5=紫色, 宝马6=粉色, 宝马3=白色, 宝马4=黑色}

中间操作的补充

map(): 将其映射成一个新的元素

public static void main(String[] args) {
        Car car1=new Car("宝马3",102,"白色");
        Car car2=new Car("宝马2",106,"红色");
        Car car3=new Car("宝马6",103,"粉色");
        Car car4=new Car("宝马5",105,"紫色");
        Car car5=new Car("宝马4",101,"黑色");
        Car car6=new Car("宝马1",104,"彩色");

       Car[]cars={car1,car2,car3,car4,car5,car6};
    List<String>list2=Arrays.stream(cars)
              .map(Car::getColor)  //把颜色这一列拿出来   (中间操作)
              .collect(Collectors.toList());//放进一个list集合中
        System.out.println(list2);
输出结果:
[白色, 红色, 粉色, 紫色, 黑色, 彩色]