22、java8的其它新特性

一、lambda表达式

本质：作为函数式接口的实现；Lambda表达式就是一个函数式接口的实例

“ -> ” ， 该操作符被称为 Lambda 操作符 或 箭头操作符 。它将 Lambda 分为两个部分：

左侧： 指定了 Lambda 表达式需要的 参数列表

右侧： 指定了 Lambda 体 ，是抽象方法的实现逻辑，也即Lambda 表达式要执行的功能。

二、函数式接口

 1、什么事函数式接口

>只包含一个抽象方法的接口，称为 函数式接口 。

>可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda 表达式抛出一个受检异常( 即：非运行时异常 ) ，那么该异常需要在目标接口的抽象方法上进行声明）。

>可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。

>在 java.util.function 包下定义了 Java 8 的丰富的函数式接口

三、方法引用和构造器引用

1、方法引用

 

> 当要传递给 Lambda 体的操作，已经有实现的方法了，可以使用方法引用！

>方法引用可以看做是 Lambda 表达式深层次的表达。换句话说，方法引用就是Lambda 表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda 表达式的一个语法糖。

> 要求： 实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致！

> 格式：使用操作符 “ :: ” 将类 ( 或对象 ) 与 方法名分隔开来。

> 如下三种主要使用情况：

        对象 :: 实例方法名

        类 :: 静态方法名

        类 :: 实例方法名

注意：当函数式接口方法的第一个参数是需要引用方法的调用者，并且第二 个参数是需要引用方法的参数 ( 或无参数 ) 时： ClassName::methodName

 

2、构造器引用

格式： ClassName::new

与函数式接口相结合，自动与函数式接口中方法兼容。可以把构造器引用赋值给定义的方法，要求 构造器参数列表要与接口中抽象方法的参数列表一致！且方法的返回值即为构造器对应类的对象。

 

3、数组引用

格式： type[] :: new

四、stream API

1、介绍

Stream API 说明

>Java8 中有两大最为重要的改变。第一个是 Lambda 表达式 ；另外一个则是 Stream API 。

> Stream API ( java.util.stream) 把真正的函数式编程风格引入到 Java 中。这是目前为止对Java 类库最好的补充，因为 Stream API 可以极大提供 Java 程序员的生产力，让程序员写出高效率、干净、简洁的代码。

> Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。 使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。 也可以使用 Stream API 来并行执行操作。简言之， Stream API 提供了一种高效且易于使用的处理数据的方式。

 

为什么要使用 Stream API

>实际开发中，项目中多数数据源都来自于 Mysql ， Oracle 等。但现在数据源可以更多了，有MongDB ， Radis 等，而这些 NoSQL 的数据就需要Java层面去处理。

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

 

什么是 Stream

是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。

“集合讲的是数据， Stream 讲的是计算！”

注意：

① Stream 自己不会存储元素。

② Stream 不会改变源对象。相反，他们会返回一个持有结果的新 Stream 。

③ Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

2、stream的使用 

2.1stream的创建

创建 Stream 方式一：通过集合

Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：

 default Stream<E> stream() : 返回一个顺序流

 default Stream<E> parallelStream() : 返回一个并行流

 

创建 Stream 方式二：通过数组

Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：

 static <T> Stream<T> stream(T[] array): 返回一个流

重载形式，能够处理对应基本类型的数组：

 public static IntStream stream(int[] array)

 public static LongStream stream(long[] array)

 public static DoubleStream stream(double[] array)

创建 Stream 方式三：通过 Stream 的 of()

可以调用 Stream 类静态方法 of(), 通过显示值创建一个流。它可以接收任意数量的参数。

 public static<T> Stream<T> of(T... values) : 返回一个流

创建 Stream 方式四：创建无限流

可以使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流。

 迭代

public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)

 生成

public static<T> Stream<T> generate(Supplier<T> s)

import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class StreamAPITest {
    //创建Stream方式一：通过集合
    @Test
    public void test1() {
        List<Employee> employees = EmployeeData.getEmployees();
        //default Stream<E> stream() : 返回一个顺序流
        Stream<Employee> stream = employees.stream();
        //default Stream<E> parallelStream() : 返回一个并行流
        Stream<Employee> employeeStream = employees.parallelStream();
    }

    //创建Stream方式二：通过数组
    @Test
    public void test2() {
        int[] arr = new int[]{1,2,3,4,5,5};
        //static <T> Stream<T> stream(T[] array): 返回一个流
        IntStream stream = Arrays.stream(arr);

        List<Employee> employees = EmployeeData.getEmployees();
        Employee[] objects = (Employee[]) employees.toArray();
        Stream<Employee> stream1 = Arrays.stream(objects);
    }

    //创建Stream方式三：通过Stream的静态方法of
    @Test
    public void test3() {
        //public static<T> Stream<T> of(T... values) : 返回一个流
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 3, 4, 5);
    }

    //创建Stream方式四：创建无限流
    @Test
    public void test4() {
        //迭代
        //public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        //遍历前10个偶数
        Stream.iterate(0, t->t+2).limit(10).forEach(System.out::println);

        //生成
        //public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }
}

2.2Stream 的中间操作

多个 中间操作 可以连接起来形成一个 流水线 ，除非流水线上触发终止操作，否则 中间操作不会执行任何的处理 ！而在 终止操作时一次性全 部处理，称为“惰性求值” 。

2.3Stream 的终止操作

 终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List 、 Integer ，甚至是 void 。

 流进行了终止操作后，不能再次使用。

 

 五、Optional类

> 到目前为止，臭名昭著的空指针异常是导致 Java 应用程序失败的最常见原因。以前，为了解决空指针异常，Google 公司著名的 Guava 项目引入了 Optional 类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到Google Guava 的启发， Optional 类已经成为 Java 8 类库的一部分。

> Optional<T> 类 (java.util.Optional) 是一个容器类，它可以保存类型 T 的值，代表这个值存在。或者仅仅保存null ，表示这个值不存在。原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。

> Optional 类的 Javadoc 描述如下：这是一个可以为 null 的容器对象。如果值存在则isPresent() 方法会返回 true ，调用 get() 方法会返回该对象。

 

> Optional 提供很多有用的方法，这样我们就不用显式进行空值检测。

> 创建 Optional 类对象的方法：

        >Optional.of(T t) : 创建一个 Optional 实例， t 必须非空 ；

        >Optional.empty() : 创建一个空的 Optional 实例

        >Optional.ofNullable(T t) ： t 可以为 null

> 判断 Optional 容器中是否包含对象：

        >boolean isPresent() : 判断是否包含对象

        >void ifPresent(Consumer<? super T> consumer) ： 如果有值，就执行 Consumer接口的实现代码，并且该值会作为参数传给它。

> 获取 Optional 容器的对象：

        >T get(): 如果调用对象包含值，返回该值，否则抛异常

        >T orElse(T other) ： 如果有值则将其返回，否则返回指定的 other 对象。

        >T orElseGet(Supplier<? extends T> other) ： 如果有值则将其返回，否则返回由Supplier接口实现提供的对象。

        >T orElseThrow(Supplier<? extends X> exceptionSupplier) ： 如果有值则将其返回，否则抛出由Supplier 接口实现提供的异常。

@Test
public void test1() {
Boy b = new Boy("张三");
Optional<Girl> opt = Optional.ofNullable(b.getGrilFriend());
// 如果女朋友存在就打印女朋友的信息
opt.ifPresent(System.out::println);
}
@Test
public void test2() {
Boy b = new Boy("张三");
Optional<Girl> opt = Optional.ofNullable(b.getGrilFriend());
// 如果有女朋友就返回他的女朋友，否则只能欣赏“嫦娥”了
Girl girl = opt.orElse(new Girl("嫦娥"));
System.out.println("他的女朋友是：" + girl.getName());
}

@Test
public void test3(){
Optional<Employee> opt = Optional.of(new Employee("张三", 8888));
//判断opt中员工对象是否满足条件，如果满足就保留，否则返回空
Optional<Employee> emp = opt.filter(e -> e.getSalary()>10000);
System.out.println(emp);
}
@Test
public void test4(){
Optional<Employee> opt = Optional.of(new Employee("张三", 8888));
//如果opt中员工对象不为空，就涨薪10%
Optional<Employee> emp = opt.map(e -> 
{e.setSalary(e.getSalary()%1.1);return e;});
System.out.println(emp);
}