JDK8新特性

• JDK8新特性
• • Lambda表达式
  • 函数式（Functional）接口
  • 方法引用与构造器引用
  • • 方法引用
    • 构造器引用
  • 强大的 StreamAPI
  • • • 创建Stream方式
      • Stream 的中间操作
      • Stream 的终止操作
  • Optional 类

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

特点：

• 速度更快

• 代码更少(增加了新的语法: Lambda 表达式）

• 强大的Stream API

• 便于并行最大化减少空指针异常: Optional

• Nashorn引擎，允许在JVM.上运行JS应用

Lambda表达式

Lambda初体验 ：

-> : Lambda 操作符、箭头操作符

左边：Lambda形参列表（就是抽象方法里的形参）

右边：Lambda 方法体（就是重写抽象方法的方法体）

   @Testpublic void test1() {// 普通写法Runnable r1 = new Runnable() {@Overridepublic void run() {System.out.println("普通写法");}};r1.run();System.out.println("*********************************");// Lambda方式Runnable r2 = () -> System.out.println("Lambda写法");r2.run();}// 普通方式@Testpublic void test2() {}@Testpublic void test3() {Comparator c1 = new Comparator() {@Overridepublic int compare(Integer o1, Integer o2) {return Integer.compare(o1, o2);}};System.out.println(c1.compare(10, 21));System.out.println("*********************");Comparator c2 = (o1, o2) -> {return Integer.compare(o1, o2);};System.out.println(c2.compare(21, 2));}

Lambda 表达式的使用

1. 形参可以省略参数类型，编译器自动进行 “类型推断”
2. Lambda 若只需要一个参数时，参数的小括号可以省略

    @Testpublic void test4() {Consumer c1 = s -> {System.out.println(s);};c1.accept("省略参数小括号");}

3. Lambda 方法体有多条语句时，允许有 return 返回值

4. Lambda 方法体只有一条语句时，return 和 大括号 都可以省略

    @Testpublic void test5() {Comparator c2 = (o1, o2) -> Integer.compare(o1, o2);System.out.println(c2.compare(21, 2));}

Lambda表达式的本质： 就是接函数式口的实例，重写接口中的方法

函数式（Functional）接口

如果一个接口中，只声明了一个抽象方法，该接口就是函数式接口

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

Java提供的四大函数式接口：

Consumer接口：

    @Testpublic void test() {// 普通写法method1(200d, new Consumer() {@Overridepublic void accept(Double aDouble) {System.out.println("消费了 " + aDouble);}});System.out.println("********************************");// Lambda 写法method1(300d, money -> System.out.println("消费了 " + money));}public void method1(Double money, Consumer consumer) {consumer.accept(money);}

Predicate接口：

    @Testpublic void test2() {List lists = new ArrayList<>();lists.add("普京");lists.add("北京");lists.add("西京");lists.add("南京");// 普通写法List list = method2(lists, new Predicate() {@Overridepublic boolean test(String s) {return s.contains("京");}});System.out.println(list);System.out.println("*************************************");// Lambda 写法List list1 = method2(lists,s -> s.contains("京"));System.out.println(list1);}public List method2(List list, Predicate pre) {ArrayList newList = new ArrayList<>();for (String s : list) {if (pre.test(s)) {newList.add(s);}}return newList;}

其他接口：

方法引用与构造器引用

方法引用

• 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用 !
• 方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一一个语法糖。

要求 : 实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致 ！（针对情况一和情况二）

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

• 如下三种主要使用情况:

  ➢对象::实例方法名

  ➢类::静态方法名

  ➢类::实例方法名 （特殊）

个人理解：

​ Lambda 和 方法引用都可以看做是函数式接口的实例，主要目的都是为了重写接口中的抽象方法。

​ Lambda 重写抽象方法主要是自己编写方法体

​ 方法引用重写抽象方法主要是 使用 方法的引用 编写方法体。但是具体是什么样的方法是由要求的。

代码演示：

   // 情况一：对象::实例方法@Testpublic void test1() {// Lambda 方式Consumer con = s -> System.out.println(s);con.accept("Lambda方式");// 方法引用// void accept(T t);// void println(T t)// 接口中的抽象方法的形参列表和返回值，与方法引用的方法形参列表、返回值都一样。Consumer con1 = System.out::println;con1.accept("方法引用");}// 情况二：类::静态方法@Testpublic void test3() {// Lambda方式// int compare(T o1, T o2);//  static int compare(int x, int y)Comparator com1 = (o1,o2) -> Integer.compare(o1,o2);System.out.println(com1.compare(21, 22));// 方法引用的方式Comparator com2 = Integer::compare;System.out.println(com1.compare(23, 22));}// 情况三: 类::实例方法（比较特殊）@Testpublic void test4() {// Lambda 方式// int compare(T o1, T o2);// int compareTo(String anotherString)// 这种情况比较特殊，接口中抽象方法的形参列表和方法引用中的形参列表不一样// 但是该方法是通过另外一个参数调用的，因此也可以使用方法引用Comparator com1 = (s1,s2) -> s1.compareTo(s2);// 方法引用方式Comparator com2 = String::compareTo;}

情况三比较特殊：当方法引用中的形参列表中的一个参数作为方法的调用者时，也可以使用方法引用

构造器引用

  // 传一个参数@Testpublic void test1() {// Lambda 方式Function fun1 = id -> new User(id);System.out.println(fun1.apply(10001L));// 构造器引用Function fun2 = User::new;System.out.println(fun2.apply(10002L));}// 传俩个参数@Testpublic void test2() {// Lambda 方式BiFunction bifun1 = (id,name) -> new User(id,name);System.out.println(bifun1.apply(10L, "李四"));// 构造器引用BiFunction bifun2 = User::new ;System.out.println(bifun2.apply(20L, "王五"));}// 数组引用: 将数组看成一个类，和构造器引用一样@Testpublic void test3() {// Lambda 方式Function fun1 = length -> new String[length];System.out.println(Arrays.toString(fun1.apply(5)));// 数组引用Function fun2 = String[]::new;System.out.println(Arrays.toString(fun2.apply(10)));}

强大的 StreamAPI

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

• Stream API ( java.util.stream)把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充
• Stream是Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用Stream API来并行执行操作。

简言之，StreamAPl 提供了一种高效且易于使用的处理数据的方式。

为什么要使用 Stream Api ？

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

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

Stream到底是什么呢?

是数据渠道，用于操作数据源(集合、数组等)所生成的元素序列。“集合讲的是数据，Stream讲的是计算!”

注意：

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

Stream的操作三个步骤

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

创建Stream方式

通过集合

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

default Stream stream(): 返回一个顺序流
default Stream parallelStream(): 返回一一个并行流

    @Testpublic void test1() {// 方式一：通过集合List userList = User.getUserList();Stream stream = userList.stream();// 返回一个并行流Stream parallelStream = userList.parallelStream();}

通过数组

Arrays 中定义了获取 stream 的方法：

public static  Stream stream(T[] array) {}

    @Testpublic void test2() {// 方式二：通过数组User[] userArray = User.getUserArray();Stream stream = Arrays.stream(userArray);}

通过Stream的of

    @Testpublic void test3() {// 通过Stream的ofStream integerStream = Stream.of(1, 2, 3, 4);}

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

public static Stream iterate(final T seed, final UnaryOperator f) 迭代
public static Stream generate(Supplier s) 生成

    @Testpublic void test4() {// 方式四: 通过 iterate 和 generate// 获取20以内的偶数Stream.iterate(0,t->t+2).limit(10).forEach(System.out::println);// 生成数据Stream> generate = Stream.generate(User::getUserList);}

Stream 的中间操作

筛选与切片

代码演示：

   // 1. 筛选与切片@Testpublic void test1() {Stream stream = User.getUserList().stream();// Stream filter(Predicate predicate); 从流中排除某些元素// forEach: 流的终止操作// 排除工资低于 2000 的stream.filter(user -> user.getSalary() > 2000).forEach(System.out::println);System.out.println("*****************************************************");Stream stream1 = User.getUserList().stream();// Stream limit(long maxSize); 截断流，是其元素不得超过指定数stream1.limit(2).forEach(System.out::println);// 报错：java.lang.IllegalStateException: stream has already been operated upon or closed// 流一旦执行终止操作就会关闭，想要在使用再重新创建一个流// stream1.limit(3).forEach(System.out::println);System.out.println("*****************************************************");Stream stream2 = User.getUserList().stream();// Stream distinct(); 筛选流，通过元素的的hashCode和equals方法去除重复元素stream2.distinct().forEach(System.out::println);System.out.println("*****************************************************");Stream stream3 = User.getUserList().stream();// Stream skip(long n); 跳过 n 个元素，若不足n个元素，则返回一个空流stream3.skip(3).forEach(System.out::println);}

映射

    // 映射@Testpublic void test2() {List users = User.getUserList();//  Stream map(Function mapper);Stream stream = users.stream().map(User::getSalary);System.out.println(stream);}
}

排序

代码演示：

    @Testpublic void test1() {Stream stream = Arrays.asList(2, 1, 33, 22, 11).stream();// Stream sorted(); 按自然顺序排序stream.sorted().forEach(System.out::println);Stream stream1 = User.getUserList().stream();//    Stream sorted(Comparator comparator); 自定义排序规则stream1.sorted(Comparator.comparingDouble(User::getSalary)).forEach(System.out::println);}

Stream 的终止操作

匹配与查找

代码演示：

 @Testpublic void test1() {List users = User.getUserList();// boolean allMatch(Predicate predicate); 检查流中是否所有元素都匹配// 检查是否所有的用户工资都大于 2000boolean allMatch = users.stream().allMatch(user -> user.getSalary() > 2000);System.out.println(allMatch);//  boolean anyMatch(Predicate predicate); 检查流中是否有元素匹配上boolean anyMatch = users.stream().anyMatch(user -> user.getSalary() > 10000);System.out.println(anyMatch);// boolean noneMatch(Predicate predicate); 检查流中是否都不匹配boolean noneMatch = users.stream().noneMatch(user -> user.getName().startsWith("王"));System.out.println(noneMatch);// Optional findFirst(); 返回流中的第一个元素Optional first = users.stream().findFirst();System.out.println(first);// Optional findAny(); 随机返回流中的元素Optional any = users.stream().findAny();System.out.println(any);//long count(); 返回流中元素的个数long count = users.stream().count();System.out.println(count);//  Optional max(Comparator comparator); 返回流中的最大值// 练习：返回工资最高的用户Optional   max = users.stream().max(Comparator.comparingDouble(User::getSalary));System.out.println(max);//Optional min(Comparator comparator); 返回流中的最小值// 练习：返回用户中最少的工资// 使用 map 映射 工资，返回一个只有工资的流Optional min = users.stream().map(User::getSalary).min(Double::compare);System.out.println(min);// void forEach(Consumer action); 迭代遍历users.stream().forEach(System.out::println);}

归约

代码演示：

    // 归约@Testpublic void test2() {List integerList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);// T reduce(T identity, BinaryOperator accumulator); 将流中的值反复结合起来得到一个新的值// 练习：计算1-10的和Integer reduce = integerList.stream().reduce(0, Integer::sum);System.out.println(reduce);List users = User.getUserList();// Optional reduce(BinaryOperator accumulator); 将流中的值反复结合起来得到一个新的值,返回Optional// 练习：计算所有用户的工资总和Optional reduce1 = users.stream().map(User::getSalary).reduce(Double::sum);System.out.println(reduce1);}

收集

形参需要使用 Collectors 提供实例，调用以下方法

Optional 类

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

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

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