概述

Java 8是oracle公司于2014年3月发布，可以看成是自Java 5 以来最具革命性的版本。Java 8为Java语言、编译器、类库、开发工具与JVM带来了大量新特性

• 速度更快
• 代码更少（增加了新的语法：Lambda表达式）
• Stream API
• 便于并行
• 最大化减少空指针异常：Optional
• Nashorn引擎，允许在JVM上运行JS应用
• 并行流与串行流
  1. 并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。相比较串行的流，并行的流可以很大程度上提高程序的执行效率
  2. Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作
  3. Stream API 可以声明性地通过 parallel() 与 sequential() 在并行流与顺序流之间进行切换

Lambda表达式

（1）为什么使用Lambda表达式

Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

（2）Lambda表达式语法

Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为“->” ， 该操作符被称为 Lambda 操作符或箭头操作符。它将 Lambda 分为两个部分

• 格式：
  1. -> :lambda操作符 或 箭头操作符
  2. ->左边：lambda形参列表 （其实就是接口中的抽象方法的形参列表
  3. ->右边：lambda体 （其实就是重写的抽象方法的方法体

（3）Lambda表达式使用前后对比示例

@Test
public void test1(){

    Runnable r1 = new Runnable() {
        @Override
        public void run() {
            System.out.println("run1");
        }
    };

    r1.run();

    System.out.println("***********************");

    Runnable r2 = () -> System.out.println("run2");

    r2.run();
}

举例二：
@Test
public void test2(){

    Comparator<Integer> com1 = new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return Integer.compare(o1,o2);
        }
    };

    int compare1 = com1.compare(12,21);
    System.out.println(compare1);

    System.out.println("***********************");
    //Lambda表达式的写法
    Comparator<Integer> com2 = (o1,o2) -> Integer.compare(o1,o2);

    int compare2 = com2.compare(32,21);
    System.out.println(compare2);


    System.out.println("***********************");
    //方法引用
    Comparator<Integer> com3 = Integer :: compare;

    int compare3 = com3.compare(32,21);
    System.out.println(compare3);
}

（4）如何使用

如何使用Lambda表达式，主要分为六种情况

（5）类型推断

• 上述 Lambda 表达式中的参数类型都是由编译器推断得出的
• Lambda表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型
• Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的类型推断

（6）小结

• ->左边：lambda形参列表的参数类型可以省略(类型推断)；如果lambda形参列表只一个参数，其一对()也可以省略
• ->右边：lambda体应该使用一对{}包裹；如果lambda体只一条执行语句（可能是return语句，省略这一对{}和return关键字

函数式（Functional）接口

（1）什么是函数式接口

• 只包含一个抽象方法的接口，称为函数式接口。可以通过 Lambda 表达式来创建该接口的对象
• 可以在一个接口上使用@FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口
• 在java.util.function包下定义了Java 8 的丰富的函数式接口

（2）如何理解函数式接口

• Java不但可以支持OOP还可以支持OOF（面向函数编程）
• 在Java8中，Lambda表达式就是一个函数式接口的实例，这就是Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口的实例，那么该对象就可以用Lambda表达式来表示
• 以前用匿名实现类表示的都可以用Lambda表达式来写

（3）Java内置四大核心函数式接口

函数式接口	参数类型	返回类型	用途
Consumer 消费型接口	T	void	对类型为T的对象应用操作，包含方法：void accept(T t)
Supplier 供给型接口	无	T	返回类型为T的对象，包含方法：T get()
Function<T,R> 函数型接口	T	R	对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法：R apply(T t)
Predicate 断定型接口	T	boolean	确定类型为T的对象是否满足某约束，并返回boolean值。包含方法：boolean test(T t)

（4）什么时候使用Lambda表达式？

当需要对一个函数式接口实例化的时候，可以使用Lambda表达式

（5）什么时候使用给定的函数式接口？

如果开发中需要定义一个函数式接口，首先看看在已有的jdk提供的函数式接口是否提供了能满足需求的函数式接口。如果有，则直接调用即可，不需要自己再自定义了。

Stream API

（1）概述

• Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API
• Stream API ( java.util.stream) 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码
• Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简言之，Stream API 提供了一种高效且易于使用的处理数据的方式

（2）为什么要使用Stream API

Stream 和 Collection 集合的区别：Collection 是一种静态的内存数据结构，而 Stream 是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向 CPU，通过 CPU 实现计算。

（3）什么是Stream

• Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列
• 集合关注的是数据，Stream关注的是计算
• Stream关注的是对数据的运算，与CPU打交道
• java8提供了一套api,使用这套api可以对内存中的数据进行过滤、排序、映射、归约等操作。类似于sql对数据库中表的相关操作

（4）Stream注意点

• Stream自己不会存储元素
• Stream不会改变源对象；他们会返回一个持有结果的新Stream
• Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行

（5）Stream的操作三个步骤

• 创建Stream

  一个数据源（如，集合、数组），获取一个流

• 一系列的中间操作

  一个中间操作链，对数据源的数据进行处理

• 终止操作

  一旦执行终止操作，就执行中间操作链，并产生结果，之后，不会再被使用

Optional类

（1）概述

• 为了解决Java中空指针问题而生
• Optional 类(java.util.Optional) 是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。

（2）Optional类的常用方法

• Optional提供很多有用的方法，这样我们就不用显式进行空值检测
• 创建Optional类对象的方法：
  1. Optional.of(T t) : 创建一个 Optional 实例，t必须非空；
  2. Optional.empty() : 创建一个空的 Optional 实例
  3. Optional.ofNullable(T t)：t可以为null
• 判断Optional容器中是否包含对象：
  1. boolean isPresent() : 判断是否包含对象
  2. void ifPresent(Consumer<? super T> consumer) ：如果有值，就执行Consumer接口的实现代码，并且该值会作为参数传给它。
• 获取Optional容器的对象：
  1. T get(): 如果调用对象包含值，返回该值，否则抛异常
  2. T orElse(T other) ：如果有值则将其返回，否则返回指定的other对象
  3. T orElseGet(Supplier<? extends T> other) ：如果有值则将其返回，否则返回由Supplier接口实现提供的对象
  4. T orElseThrow(Supplier<? extends X> exceptionSupplier) ：如果有值则将其返回，否则抛出由Supplier接口实现提供的异常

@Test
    public void test1() {
        //empty():创建的Optional对象内部的value = null
        Optional<Object> op1 = Optional.empty();
        if (!op1.isPresent()) {//Optional封装的数据是否包含数据
            System.out.println("数据为空");

        }
        System.out.println(op1);
        System.out.println(op1.isPresent());
        //如果Optional封装的数据value为空，则get()报错。否则，value不为空时，返回value.
//        System.out.println(op1.get());

    }

    @Test
    public void test2() {
        String str = "hello";
//        str = null;
        //of(T t):封装数据t生成Optional对象。要求t非空，否则报错。
        Optional<String> op1 = Optional.of(str);
        //get()通常与of()方法搭配使用。用于获取内部的封装的数据value
        String str1 = op1.get();
        System.out.println(str1);

    }

    @Test
    public void test3() {
        String str = "beijing";
        str = null;
        //ofNullable(T t) ：封装数据t赋给Optional内部的value。不要求t非空
        Optional<String> op1 = Optional.ofNullable(str);
        //orElse(T t1):如果Optional内部的value非空，则返回此value值。如果
        //value为空，则返回t1.
        String str2 = op1.orElse("shanghai");

        System.out.println(str2);//
    }