JDK8新特性知识概括

Lambda表达式

为什么使用 Lambda 表达式?

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

简述：

• Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操 作符。这个操作符为 “->” ， 该操作符被称为 Lambda操作符 或箭头操作符。
• 它将 Lambda 分为两个部分：
  ①左侧：指定了 Lambda 表达式需要的参数列表
  ②右侧：指定了 Lambda 体，是抽象方法的实现逻辑，也即Lambda 表达式要执行的功能。

语法格式：

• 语法格式一：无参，无返回值。

Runnable r1 = () ->{System.out.println("Hello Lambda");};

• 语法格式二：Lambda 需要一个参数，但是没有返回值。

Consumer<String> con = (String str) ->{System.out.println("Hello Lambda");};

• 语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”。

Consumer<String> con = (str) ->{System.out.println("Hello Lambda");};

• 语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略。

Consumer<String> con = str ->{System.out.println("Hello Lambda");};

• 语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值。

Comparator<Integer> com = (x,y) -> {
	System.out.println("实现函数式接口方法!");
	return Integer.compare(x,y);
};

• 语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略。

Comparator<Integer> com = (x,y) -> Integer.compare(x,y);

类型推断:

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

public interface Comparator<T>{
 int compare(T o1,T o2);
}

• 可根据Comparator中的T类型推断出compare方法中的参数类型。

函数式(Functional)接口

什么是函数式(Functional)接口：

• 只包含一个抽象方法的接口，称为函数式接口。
• 你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda 表达式抛出一个受检异常(即：非运行时异常)，那么该异常需要在目标接口的抽象方法上进行声明）。
• 我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检 查它是否是一个函数式接口。同时 javadoc也会包含一条声明，说明这个 接口是一个函数式接口。
• 在java.util.function包下定义了Java 8 的丰富的函数式接口

如何理解函数式接口：

• Java从诞生日起就是一直倡导“一切皆对象”，在Java里面面向对象(OOP)编程是一切。但是随着python、scala等语言的兴起和新技术的挑战，Java不得不做出调整以便支持更加广泛的技术要求，也即java不但可以支持OOP还 可以支持OOF（面向函数编程）。
• 在函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的编程语言中，Lambda表达式的类型是函数。但是在Java8中，有所不同。在Java8中，Lambda表达式是对象，而不是函数，它们必须依附于一类特别的 对象类型——函数式接口。
• 简单的说，在Java8中，Lambda表达式就是一个函数式接口的实例。这就是Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口 的实例，那么该对象就可以用Lambda表达式来表示。
• 所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。

函数式接口举例：

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

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

方法引用与构造器引用

方法引用(Method References):

• 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！
• 方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向 一个方法，可以认为是Lambda表达式的一个语法糖。
• 要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致！
• 格式：使用操作符 “::” 将类(或对象) 与 方法名分隔开来。
• 如下三种主要使用情况：
  ①对象::实例方法名
  ②类::静态方法名
  ③类::实例方法名

//例如：
Consumer<String> con = (x) ->System.out.println(x);
//等同于
Consumer<String> con2 = System.out::println;

//例如：
Comparator<Integer> com = (x,y) ->Integer.compare(x,y);
//等同于
Comparator<Integer> com1 = Integer::compare;

//例如：
BiPredicate<String,String> bp = (x,y) -> x.equals(y);
//等同于
BiPredicate<String,String> bp1 = String::equals;

注意：

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

构造器引用:

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

//例如：
Function<Integer,MyClass> fun = (n) -> new MyClass(n);
//等同于：
Function<Integer,MyClass> fun = MyClass::new;

数组引用:

• 格式： type[] :: new

//例如：
Function<Integer,Integer[]> fun = (n) -> new Integer[n];
//等同于：
Function<Integer,Integer[]> fun = Integer[]::new;

Stream API

为什么要使用Stream API：

• 实际开发中，项目中多数数据源都来自于Mysql，Oracle等。但现在数据源可以更多了，有MongDB，Radis等，而这些NoSQL的数据就需要Java层面去处理。
• Stream 和 Collection 集合的区别：Collection 是一种静态的内存数据结构，而 Stream
  是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向 CPU，通过 CPU 实现计算

什么是 Stream：

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

注意：

• Stream 自己不会存储元素。

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

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

Stream 的操作三个步骤：

1. 创建 Stream
   一个数据源（如：集合、数组），获取一个流
2. 中间操作
   一个中间操作链，对数据源的数据进行处理
3. 终止操作(终端操作)
   一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

创建 Stream方式：

1. 通过集合
   default Stream<E> stream() : 返回一个顺序流
   default Stream<E> parallelStream() : 返回一个并行流
2. 通过数组
   static <T> Stream<T> stream(T[] array): 返回一个流
3. 通过Stream的of()
   public static<T> Stream<T> of(T… values) : 返回一个流
4. 创建无限流
   迭代
   public static<T> Stream<T> iterate(final T seed, final UnaryOperator f)
   生成
   public static<T> Stream<T> generate(Supplier s)

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

flatMap和map的区别：

• map(Function f)：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
• flatMap(Function f)：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
• 当接收的是一个流时，flatMap可以自动把流中的每一个元素取出来，而map不可以，因此flatMap实现了扁平化操作。

Stream 的终止操作：
终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，如：List、Integer，甚至是 void 。 流进行了终止操作后，不能再次使用。

map 和 reduce 的连接通常称为 map-reduce 模式，因 Google 用它来进行网络搜索而出名。

Collector 接口中方法的实现决定了如何对流执行收集的操作(如收集到 List、Set、Map)。
另外， Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例。

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提供很多有用的方法，这样我们就不用显式进行空值检测。

方法详情：

flatMap和map方法注意事项：

<U> Optional<U> flatMap(Function<? super T,Optional<U>> mapper) 
如果一个值存在，应用提供的 Optional映射函数给它，返回该结果，否则返回一个空的 Optional 。 

<U> Optional<U> map(Function<? super T,? extends U> mapper) 
如果存在一个值，则应用提供的映射函数，如果结果不为空，则返回一个 Optional结果的 Optional 。

• 两种的区别是map的返回值Optional对象是在map方法里面自动封装好了。而flatMap方法是自己的实现的逻辑中自己封装。

Optional用途：

• 举例：一个非洲的Zoo，提供add一个animal进来的功能，可是有可能是用Future来捕捉动物的，也就是说可能没有catch到animal，但是为了防止以后使用的时候，有NPE错误，只有做判断。
• Optional实现的功能，有很多替代方案，if-else、三目等都可以；但Optional是用于函数式的一个整体中的一环，让函数式更流畅。

①不使用Optional的版本，提变量，判空，必不可少，很繁琐

List<Animal> zoo = new ArrayList<>();

Animal animal = manCatch();
   if(animal != null){
       zoo.add(animal);
   }

②使用Optional 和函数式编程，一行搞定，而且像说话一样

List<Animal> zoo = new ArrayList<>();

   manCatch().ifPresent(zoo::add);