Java8新特性 (jdk1.8)_java1.8

Java8新特性 (jdk1.8)

**Java 8(又称为jdk 1.8)**是Java语言开发的一个主要版本。

Java 8是oracle公司于2014年3月发布，可以看成是自Java5以来最具革命性的版本。

Java 8为Java语言、编译器、类库、开发工具与JVM带来了大量新特性。

Java8 新特性的好处：

• 速度更快
• 代码更少(增加了新的语法: Lambda表达式 )
• 强大的 Stream API
• 便于并行
• 最大化减少空指针异常:Optional
• Nashorn引擎，允许在JVM上运行JS应用

① Lambda表达式

为什么使用Lambda表达式？

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

Lambda表达式 在 Java 8 语言中引入 的 一 种 新的语法元素和操作符。

这个操作符为 “ -> ” 该操作符被称为 Lambda操作符 或 箭头操作符 。

它将 Lambda 分为两个部分：

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

package com.cs.java8;

import org.junit.Test;

import java.util.Comparator;

public class LambdaTest {
    @Test
    public void test1(){
        //普通写法：
        Runnable r1 = new Runnable() {
            @Override
            public void run(){
                System.out.println("我爱北京天安门");
            }
        };
        r1.run();
        System.out.println("============================");
        //Lambda表达式写法：
        Runnable r2 = () -> System.out.println("华东师范给大家个");
        r2.run();
    }

    @Test
    public void test2(){
        //1.普通写法
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };
        System.out.println(com1.compare(67, 8));
        System.out.println("-----------------------------------------------");
        //2.Lambda表达式写法:
        Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2);
        System.out.println(com2.compare(4 , 7));
        System.out.println("-----------------------------------------------");
        //3.方法引用的写法：
        Comparator<Integer> com3 = Integer :: compare;
        System.out.println(com3.compare(55 ,55));
     }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

② Lambda表达式的6种语法格式

2.1 语法格式一: 无参、无返回值

//普通写法：
Runnable r1 = new Runnable() {
    @Override
    public void run(){
        System.out.println("我爱北京天安门");
    }
};
-------------------------------------------
//Lambda表达式写法：
Runnable r2 = () -> {System.out.println("华东师范给大家个");};
1
2
3
4
5
6
7
8
9
10

2.2 语法格式二: Lambda 需要一个参数, 但是没有返回值。

//普通写法:
Consumer<String> consumer1 = new Consumer<String>() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
};
-----------------------------------------
//Lambda表达式写法:
Consumer<String> consumer2 = (String s) -> {System.out.println(s);};
1
2
3
4
5
6
7
8
9
10

2.3 语法格式三: 数据类型可以省略

因为可由编译器推断得出，称为“类型推断“

//普通写法:
Consumer<String> consumer1 = new Consumer<String>() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
};
-----------------------------------------
//Lambda表达式写法:
Consumer<String> consumer2 = (String s) -> {System.out.println(s);};
//数据类型省略写法：
Consumer<String> consumer2 = (s) -> {System.out.println(s);};
1
2
3
4
5
6
7
8
9
10
11
12

2.4 语法格式四: Lambda 若只需要一个参数时, 参数的小括号可以省略

//普通写法:
Consumer<String> consumer1 = new Consumer<String>() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
};
-----------------------------------------
//Lambda表达式写法:
Consumer<String> consumer2 = (String s) -> {System.out.println(s);};
//数据类型省略写法：
Consumer<String> consumer3 = (s) -> {System.out.println(s);};
//参数小括号省略写法:
Consumer<String> consumer3 = s -> {System.out.println(s);};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

//普通写法
Comparator<Integer> comparator1 = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        System.out.println("实现函数式接口方法");
        return Integer.compare(o1, o2);
    }
};
----------------------
//Lambda表达式写法:
Comparator<Integer> comparator2 = (o1, o2) -> {
    System.out.println("实现函数式接口方法");
    return Integer.compare(o1, o2);
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

//普通写法
Comparator<Integer> comparator1 = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return Integer.compare(o1, o2);
    }
};
----------------------
//Lambda表达式写法:
Comparator<Integer> comparator2 = (o1, o2) -> Integer.compare(o1, o2);
1
2
3
4
5
6
7
8
9
10

类型推断

③ 函数式(Functional)接口

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

Lambda表达式的本质: 作为函数式接口的实例

3.1 如何理解函数式接口

• Java 从诞生日起就是一直倡导 “一切皆对象”， 在 Java 里面面向对象 (编程是一切。但是随着 python 、 scala 等语言的兴起和新技

  的挑战 Java 不得不做出调整以便支持更加广泛的技术要求，也即 java 不但可以支持 OOP 还可以支持 OOF （面向函数编程）

• 在函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的编程语言中， Lambda 表达式的类型是函数。但是在

  Java8 中，有所不同。在Java8 中， Lambda 表达式是对象，而不是函数，它们必须依附于一类特别的对象类型 函数式接口 。

• 简单的说，在 Java8 中，Lambda 表达式就是一个函数式接口的实例。 这就是Lambda 表达式和函数式接口的关系。也就是说，

  要一个对象是函数式接口的实例，那么该对象就可以用 Lambda 表达式来表示。

• 所以以前用 匿名实现类 表示的现在都可以用 Lambda 表达式来写。

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

(1) Consumer< T > 消费型接口

public class LambdaTest2 {
    @Test
    public void test1(){
        //普通写法
        happyTime(500.00, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("happy time cost " + aDouble);
            }
        });
        //函数式接口,Lambda表达式
        happyTime(488.00, (money) -> System.out.println("happy time " + money));
    }
    public void happyTime(Double money, Consumer<Double> con) {
        con.accept(money);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

(2) Predicate< T> 断定型接口

@Test
public void test2(){
	List<String> list = Arrays.asList("hello","happy","good","morning","night","love");
    //普通写法
    List<String> filterStr1 = filterString(list, new Predicate<String>() {
    	@Override
        public boolean test(String s) {
        	return s.length() > 4;//过滤出长度>4 的字符串
       	}
    });
    System.out.println(filterStr1);
    //函数式接口,Lambda表达式 写法
    List<String> filterStr2 = filterString(list,(s) -> s.length() > 4);
    System.out.println(filterStr2);
}
//根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
public List<String> filterString(List<String> list, Predicate<String> pre) {
    ArrayList<String> filterList = new ArrayList<>();
    for (String s : list) {
        if (pre.test(s)) {
            filterList.add(s);
        }
    }
  	return filterList;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

④ 方法引用与构造器引用

4.1 方法引用(Method References)

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

⑤ 强大的 Stream API

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

5.1 为什么使用 Stream API

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

5.2 什么是 Stream

Stream到底是什么呢?

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

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

注意:

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

5.3 Stream 的三个步骤

• 1 - 创建 stream

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

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

• 3 - 终止操作 (终端操作)
  一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用.
  

5.4 Stream的实例化

(1) 创建Stream方式一: 通过集合

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

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

	//创建Stream流的方式一: 通过集合
    @Test
    public void test1(){

        List<Employee> employeeList = EmployeeData.getEmployees();
        //default Stream<E> stream():返回一个顺序流
        Stream<Employee> stream = employeeList.stream();

        //default Stream<E> parallelStream(): 返回一个并行流
        Stream<Employee> employeeStream = employeeList.parallelStream();
    }
1
2
3
4
5
6
7
8
9
10
11

(2)创建Stream方式二: 通过数组

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

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

  List<Employee> employeeList = EmployeeData.getEmployees();
  Employee[] employeeArray = employeeList.toArray(new Employee[employeeList.size()]);
  
  Stream<Employee> stream = Arrays.stream(employeeArray);
  1
  2
  3
  4

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

• **public static IntStream stream( int[ ] array ) **
• **public static LongStream stream( long[ ] array ) **
• **public static DoubleStream stream( double[ ] array ) **

int[] arr = new int[]{1,3,4,5,7};
//public static IntStream stream(int[] array)
IntStream stream1 = Arrays.stream(arr);
1
2
3

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

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

• **public static< T > Stream< T > of(T… values) : 返回一个流 **

Stream<Integer> integerStream = Stream.of(1, 3, 8, 2, 9);
1

(4) 创建 Stream方式四: 创建无限流

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

• 迭代
  public staticStream iterate(final T seed, final UnaryOperator f)
• 生成
  public static Stream generate(Suppliers)

//迭代: 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)
//生成10个随机数
Stream.generate(Math::random).limit(10).forEach(System.out::println);
1
2
3
4
5
6
7

5.5 Stream的中间操作

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

(1) 筛选与切片

	//1-筛选与切片
    @Test
    public void test1(){
        List<Employee> employeeList = EmployeeData.getEmployees();
        //1- filter(Predicate p) 接收Lambda，从流中排除某些元素
        Stream<Employee> stream = employeeList.stream();
        //查询员工表中薪资大于7000的员工信息
        stream.filter(e -> e.getSalary() > 7000.00).forEach(System.out::println);
        System.out.println("---------------------------");
        //2- limit(long maxSize)截断流，使其元素不超过给定数量
        employeeList.stream().limit(4).forEach(System.out::println);
        System.out.println("---------------------------");
        //3- skip(long n) 跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与 limit(n)互补
        employeeList.stream().skip(4).forEach(System.out::println);
        System.out.println("---------------------------");
        //4- distinct() 筛选，通过流所生成元素的 hashCode()和 equals()去除重复元素
        employeeList.stream().distinct().forEach(System.out::println);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

(2) 映射

public class StreamAPITest1 {
    //2- 映射
    @Test
    public void test2(){
        List<Employee> employeeList = EmployeeData.getEmployees();
//        1- map(Function f) 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
        System.out.println("---------------------------------------------");
//        练习:获取员工姓名长度大于3的员工的姓名。
        employeeList.stream().map(e -> e.getName()).filter(name -> name.length() > 3).forEach(System.out::println);
        System.out.println("--------------------------------------");
//        2- flatMap(Function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
        Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest1::fromStringToStream);
        streamStream.forEach(s -> {
            s.forEach(System.out::println);
        });
        System.out.println("--------------------------------------");
        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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

map() ：相当于 add()
flatMap : 相当于 addAll()

(3) 排序

//3- 排序
    @Test
    public void test3(){
//        sorted() 产生一个新流，其中按自然顺序排序
        List<Integer> integerList = Arrays.asList(78, 56, 199, 2, 36, 5, 67, 89, 200, 6, 5);
        integerList.stream().sorted().forEach(System.out::println);
        System.out.println("------------------------------------------");
//        sorted(Comparator com)产生一个新流，其中按比较器顺序排序
        List<Employee> employeeList = EmployeeData.getEmployees();
        employeeList.stream().sorted((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge()))
                .forEach(System.out::println);
    }
1
2
3
4
5
6
7
8
9
10
11
12

5.6 Stream的终止操作

(1) 匹配与查找

public class StreamAPITest2 {
    //1-匹配与查找
    @Test
    public void test1(){

        List<Employee> employeeList = EmployeeData.getEmployees();
//        aLLMatch(Predicate p)—一检查是否匹配所有元素。
//        练习:是否所有的员工的年龄都大于18
        boolean allMatch = employeeList.stream().allMatch(e -> e.getAge() > 18);
        System.out.println(allMatch);//false
//        anyMatch(Predicate p)—-检查是否至少匹配一个元素练习:
//        是否存在员工的工资大于10000
        boolean anyMatch = employeeList.stream().anyMatch(e -> e.getSalary() > 10000);
        System.out.println(anyMatch);

//        noneMatch (Predicate p)—-检查是否没有匹配的元素。
//        练习:是否存在员工姓“雷”
        boolean noneMatch = employeeList.stream().noneMatch(e -> e.getName().startsWith("雷"));
        System.out.println(noneMatch);
//        findFirst—-返回第一个元素
        Optional<Employee> employee = employeeList.stream().findFirst();
        System.out.println(employee);
//        findAny -- 返回任意一个元素
        Optional<Employee> employee1 = employeeList.stream().findAny();
        System.out.println(employee1);
//        count—-返回流中元素的总个数
        long count = employeeList.stream().count();
        System.out.println(count);
//        max (Comparator c)-返回流中最大值
//        练习:返回最高的工资:
        Optional<Double> max = employeeList.stream().map(Employee::getSalary).max((d1, d2) -> Double.compare(d1, d2));
        System.out.println(max);
//        min(Comparator c)—-返回流中最小值
//        练习:返回最低工资的员工
        Optional<Double> min = employeeList.stream().map(Employee::getSalary).min((d1, d2) -> Double.compare(d1, d2));
        System.out.println(min);
//        forEach( consumer c)—-内部迭代
        employeeList.stream().forEach(System.out::println);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

(2) 归约

public class StreamAPITest3 {
    @Test
    public void test1(){
//        reduce(T identity, BinaryOperator b)--可以将流中元素反复结合起来，得到一个值。返回T
//        练习1:计算1-10的自然数的和
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Integer sum = list.stream().reduce(0, Integer::sum);
        System.out.println("sum = " + sum);//sum = 55
//        reduce(BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回Optional<T>
        Optional<Integer> reduce = list.stream().reduce(Integer::sum);
        System.out.println(reduce);//Optional[55]
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

(3) 收集

强大的Stream APl : 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()方法会返回该对象。