[000-01-006].第15节：java8的新特性

我的后端学习大纲

我的Java学习大纲

---

1.Lambda表达式：

1.1.Java 8新特性简介

• 1.Java 8 (又称为 jdk 1.8) 是 Java 语言开发的一个主要版本
• 2.Java 8 是oracle公司于2014年3月发布，可以看成是自Java 5 以来最具革命性的版本
• 3.Java 8为Java语言、编译器、类库、开发工具与JVM带来了大量新特性,特性大纲如下：
  

---

1.2.Java 8特点：

• 1.速度更快：比如HashMap底层使用的红黑树

• 2.代码更少：比如增加了新的语法：Lambda 表达式

• 3.强大的 Stream API：实现了对内存层面的多个数据进行一些操作，比如对List集合中的数据进行过滤、排序等操作

• 4.便于并行：并行API介绍

  • 并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。相比较串行的流，并行的流可以很大程度上提高程序的执行效率。
  • Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API 可以声明性地通过 parallel() 与 sequential() 在并行流与顺序流之间进行切换。

• 5.最大化减少空指针异常：Optional类去减少空指针异常

• 6.Nashorn引擎：允许在JVM上运行JS应用程序，jjs.exe就是可以执行js程序
  
  

---

1.3. Lambda 表达式使用

a.对Lambda 表达式概述：

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

b.从匿名类到 Lambda 的转换举例

b1.案例1：

b2.案例2：

---

c.Lambda 表达式语法格式：

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

---

1.4.在6种情况下Lambda 表达式使用：

a.格式1：

• 1.语法：
  
• 2.举例子：
  

b.格式2：

• 1.语法：
  
• 2.举例子：

c.格式3：

• 1.语法：
  
• 2.举例：
  

d.格式4

• 1.语法：
  
• 2.举例：
  

e.格式5：

• 1.语法：
  
• 2.举例：
  

f.格式6：

• 1.语法：
  
• 2.举例：
  

1.6.类型推断说明：

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

---

2.函数式(Functional)接口

2.1.什么是函数式(Functional)接口

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

2.2.函数式接口举例：

a.java8中的一些函数式接口：

b.自己定义的函数式接口

2.3.如何理解函数式接口

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

2.4.作为参数传递 Lambda 表达式

2.6.Java中的函数式接口：

a.内置四大核心函数式接口:

b.代码举例：

• 1.案例1：
  
• 2.案例2：
  
  

c.其他函数式接口:

---

3.方法引用与构造器引用

3.1.方法引用

a.方法引用概述：

• 1.当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！
  • System.out.println(str)就是给Lambda体的操作，然后println(str)就是已有的实现方法，所以下面这段Lambda表达式就可以升级为方法引用
    
• 2.方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用本质就是Lambda表达式，所以说方法引用其实就是函数式接口的一个实例。通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖
• 3.方法引用使用的要求：要求接口中的抽象方法的参数列表和返回值类型必须与方法引用的方法的参数列表和返回值类型保持一致 （主要是针对对象::实例方法名 和类::静态方法名两种情况成立

b.方法引用语法格式：

• 1.操作符 “::” 将类(或对象) 与 方法名分隔开来。如下三种主要使用情况：
  • 对象::实例方法名（非静态方法）
  • 类::静态方法名
  • 类::实例方法名（非静态方法）

b1.方法引用情况1：对象::实例方法名（非静态方法）

方法引用使用的要求：要求接口中的抽象方法的形参列表和返回值与方法引用的方法的形参列表与返回值类型相同----情况1适用这种方法

b2.方法引用情况2： 类::静态方法名

方法引用使用的要求：要求接口中的抽象方法的形参列表和返回值与方法引用的方法的形参列表与返回值类型相同----情况2适用这种方法

---

b3.方法引用情况3：类::实例方法名（非静态方法）

---

3.2.构造器引用：

a.构造器引用概述：

• 1.构造器引用与方法引用类似，函数式接口的抽象方法的形参列表与构造器的形参列表一致
• 2.抽象方法的返回值类型：为构造器所属的类的类型

b.语法格式：

• 1.格式： ClassName-类名::new

c.构造器引用举例：

• 1.案例1：
  
• 2.案例2：
• 3.案例3：
  

3.3.数组引用：

a.语法说明：

• 1.格式： type[] :: new
• 2.数组引用可以把数组看成一个特属于的类，那么书写语法就和构造器引用一致了

b.举例子：

---

4.Stream API：

4.1.概述：

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

一句话：Stream API 提供了一种高效且易于使用的处理数据的方式

---

4.2.为什么要使用Stream API:

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

---

4.3.什么是 Stream

• 1.是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。
• 2.注意：
  • Stream 自己不会存储元素。
  • Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
  • Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行

---

4.4.Stream 的操作三个步骤：

a.三个步骤概念介绍：

a1.创建 Stream（Stream实例化）

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

a2.中间操作

• 一个中间操作链，如过滤、映射等，对数据源的数据进行处理

a3.终止操作(终端操作)

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

---

b. Stream三个步骤实操：

b1.Stream实例化：

b1-1.方式一:通过集合

• 1.Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：
  • default Stream<E> stream() : 返回一个顺序流
  • default Stream<E> parallelStream() : 返回一个并行流
• 2.案例演示：
  
• 1.顺序流中的数据和List中存储的数据顺序一致，并行流不一定。数据的顺序是随机的
  

b1-2.方式二：通过数组

• 1.Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：static <T> Stream<T> stream(T[] array): 返回一个流
• 2.重载形式，能够处理对应基本类型的数组：
• public static IntStream stream(int[] array)
• public static LongStream stream(long[] array)
• public static DoubleStream stream(double[] array)
• 3.案例演示：
  

b1-3.方式三：通过Stream的of()

• 1.可以调用Stream类静态方法 of(), 通过显示值创建一个流。它可以接收任意数量的参数：public static<T> Stream<T> of(T... values) : 返回一个流
  

b1-4.方式四：创建无限流

可以使用静态方法 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)
  

---

---

b2.Stream 的中间操作

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

b2-1.筛选与切片

    //1-筛选与切片
    @Test
    public void test1(){
        List<Employee> list = EmployeeData.getEmployees();
        
		// filter(Predicate p)——接收 Lambda ， 从流中排除某些元素。
        Stream<Employee> stream = list.stream();
        
        //练习：查询员工表中薪资大于7000的员工信息
        stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);
        System.out.println();

		// limit(n)——截断流，使其元素不超过给定数量。
        list.stream().limit(3).forEach(System.out::println);
        System.out.println();

	    // skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
        list.stream().skip(3).forEach(System.out::println);
        System.out.println();
        
		//  distinct()——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",41,8000));
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",40,8000));

		// System.out.println(list);
        list.stream().distinct().forEach(System.out::println);
    }

b2-2.映射：

	//映射
    @Test
    public void test2(){
		// map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素。
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);

		// 练习1：获取员工姓名长度大于3的员工的姓名。
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<String> namesStream = employees.stream().map(Employee::getName);
        namesStream.filter(name -> name.length() > 3).forEach(System.out::println);
        
        System.out.println();
        
        //练习2：
        Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest1::fromStringToStream);
        streamStream.forEach(s ->{
            s.forEach(System.out::println);
        });
        
        System.out.println();
        
		// flatMap(Function f)——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
        Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::fromStringToStream);
        characterStream.forEach(System.out::println);
    }
    
    
    //将字符串中的多个字符构成的集合转换为对应的Stream的实例
    public static Stream<Character> fromStringToStream(String str){//aa
        ArrayList<Character> list = new ArrayList<>();
        for(Character c : str.toCharArray()){
            list.add(c);
        }
       return list.stream();

    }

b2-3.排序：

   //3-排序
    @Test
    public void test4(){
		// sorted()——自然排序
        List<Integer> list = Arrays.asList(12, 43, 65, 34, 87, 0, -98, 7);
        list.stream().sorted().forEach(System.out::println);
        //抛异常，原因:Employee没有实现Comparable接口
		//  List<Employee> employees = EmployeeData.getEmployees();
		// employees.stream().sorted().forEach(System.out::println);


		// sorted(Comparator com)——定制排序
        List<Employee> employees = EmployeeData.getEmployees();
        employees.stream().sorted( (e1,e2) -> {

           int ageValue = Integer.compare(e1.getAge(),e2.getAge());
           if(ageValue != 0){
               return ageValue;
           }else{
               return -Double.compare(e1.getSalary(),e2.getSalary());
           }
        }).forEach(System.out::println);
    }

b3.Stream 的终止操作

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

b3-1.匹配与查找:

b3-2.归约：

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

b3-3.收集:

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

---

5.Optional类

5.1.概述：

• 1.到目前为止，臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。以前，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到Google Guava的启发，Optional类已经成为Java 8类库的一部分。
• 2.Optional<T> 类(java.util.Optional) 是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。
• 3.Optional类的Javadoc描述如下：这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

Optional类是为了在程序中避免产生空指针异常而创建的

5.2.Optional 类常用方法：

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

a.创建Optional类对象的方法：

• 1.Optional.of(T t) : 创建一个 Optional 实例，t必须非空；
• 2.Optional.empty() : 创建一个空的 Optional 实例
• 3.Optional.ofNullable(T t)：t可以为null
  

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

• 1.boolean isPresent() : 判断是否包含对象
• 2.void ifPresent(Consumer<? super T> consumer) ：如果有值，就执行Consumer
  接口的实现代码，并且该值会作为参数传给它。

c.获取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接口实现提供的异常。

5.3.空指针测试演示：