官网地址：https://blog.xueqimiao.com/jdk

一、JDK8新特性

1、主要内容

1. Lambda 表达式
2. 函数式接口
3. 方法引用与构造器引用
4. Stream API
5. 接口中的默认方法与静态方法
6. 新时间日期 API
7. 其他

2、Java 8新特性简介

• 速度更快
• 代码更少（增加了新的语法 Lambda 表达式）
• 强大的 Stream API
• 便于并行
• 最大化减少空指针异常 Optional

3、Lambda表达式

1、为什么使用 Lambda 表达式

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

// 匿名内部类
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World"); 
    }
};

// lambda表达式
Runnable runnable = () -> System.out.println("Hello World");

// 使用匿名内部类作为参数传递
TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return Integer.compare(o1.length(),o2.length());
    }
});

// 现在的 Lambda 表达式
Comparator<String> com = (x, y) -> Integer.compare(x.length(), y.length());
TreeSet<String> ts = new TreeSet<>(com);

2、Lambda 表达式语法

Lambda 表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为 ->
， 该操作符被称为 Lambda 操作符或剪头操作符。它将 Lambda 分为

两个部分：

• 左侧：指定了 Lambda 表达式需要的所有参数
• 右侧：指定了 Lambda 体，即 Lambda 表达式要执行的功能。

1、Lambda 需要两个参数，并且有返回值

• 无参
  ，无返回值
  ，Lambda 体只需一条语句

Runnable runnable = () -> System.out.println("Hello World");

2、Lambda 需要一个参数

• Lambda 需要一个
  参数

Consumer<String> fun = (arg) -> System.out.println(arg);

3、Lambda 只需要一个参数时，参数的小括号可以省略

• Lambda 只
  需要一个
  参数时，参数的小括号
  可以省略
  

Consumer<String> fun = arg -> System.out.println(arg);

4、Lambda 需要两个参数，并且有返回值

• Lambda 需要两个
  参数，并且有返回值
  

BinaryOperator<Long> binaryOperator = (Long x,Long y) -> {
    return x + y;
};

// 数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
BinaryOperator<Long> binaryOperator = (x,y) -> {
    return x + y;
};

5、当 Lambda 体只有一条语句时，return 与大括号可以省略

• 当 Lambda 体只有一条
  语句时，return 与大括号可以省略
  

BinaryOperator<Long> binaryOperator = (x,y) -> x + y;

3、类型推断

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

4、案例

1、Employee类

public class Employee {

 private int id;
 private String name;
 private int age;
 private double salary;

 public Employee() {
 }

 public Employee(String name) {
  this.name = name;
 }

 public Employee(String name, int age) {
  this.name = name;
  this.age = age;
 }

 public Employee(int id, String name, int age, double salary) {
  this.id = id;
  this.name = name;
  this.age = age;
  this.salary = salary;
 }
}

2、初始化数据

List<Employee> emps = Arrays.asList(
    new Employee(101, "张三", 18, 9999.99),
    new Employee(102, "李四", 59, 6666.66),
    new Employee(103, "王五", 28, 3333.33),
    new Employee(104, "赵六", 8, 7777.77),
    new Employee(105, "田七", 38, 5555.55)
);

3、获取公司中年龄小于 35 的员工信息

// 获取公司中年龄小于 35 的员工信息
public List<Employee> filterEmployeeAge(List<Employee> emps){
    List<Employee> list = new ArrayList<>();

    for (Employee emp : emps) {
        if(emp.getAge() <= 35){
            list.add(emp);
        }
    }
    return list;
}

public void test3(){
    List<Employee> list = filterEmployeeAge(emps);
    for (Employee employee : list) {
        System.out.println(employee);
    }
}

// 获取公司中工资大于 5000 的员工信息
public List<Employee> filterEmployeeSalary(List<Employee> emps){
    List<Employee> list = new ArrayList<>();

    for (Employee emp : emps) {
        if(emp.getSalary() >= 5000){
            list.add(emp);
        }
    }

    return list;
}

4、优化方式一：策略设计模式

@FunctionalInterface
public interface MyPredicate<T> {
 public boolean test(T t);
}

public List<Employee> filterEmployee(List<Employee> emps, MyPredicate<Employee> mp){
    List<Employee> list = new ArrayList<>();
    for (Employee employee : emps) {
        if(mp.test(employee)){
            list.add(employee);
        }
    }
    return list;
}

public class FilterEmployeeForAge implements MyPredicate<Employee>{
 @Override
 public boolean test(Employee t) {
  return t.getAge() <= 35;
 }
}

public class FilterEmployeeForSalary implements MyPredicate<Employee> {
 @Override
 public boolean test(Employee t) {
  return t.getSalary() >= 5000;
 }
}

public void test4(){
    List<Employee> list = filterEmployee(emps, new FilterEmployeeForAge());
    for (Employee employee : list) {
        System.out.println(employee);
    }

    System.out.println("------------------------------------------");

    List<Employee> list2 = filterEmployee(emps, new FilterEmployeeForSalary());
    for (Employee employee : list2) {
        System.out.println(employee);
    }
}

5、优化方式二：匿名内部类

public void test5(){
    List<Employee> list = filterEmployee(emps, new MyPredicate<Employee>() {
        @Override
        public boolean test(Employee t) {
            return t.getId() <= 103;
        }
    });

    for (Employee employee : list) {
        System.out.println(employee);
    }
}

6、优化方式三：Lambda 表达式

public void test6(){
    List<Employee> list = filterEmployee(emps, (e) -> e.getAge() <= 35);
    list.forEach(System.out::println);

    System.out.println("------------------------------------------");

    List<Employee> list2 = filterEmployee(emps, (e) -> e.getSalary() >= 5000);
    list2.forEach(System.out::println);
}

7、优化方式四：Stream API

public void test7(){
    emps.stream()
        .filter((e) -> e.getAge() <= 35)
        .forEach(System.out::println);

    System.out.println("----------------------------------------------");

    emps.stream()
        .map(Employee::getName)
        .limit(3)
        .sorted()
        .forEach(System.out::println);
}

5、Lambda例子分析

1、优化线程代码

以前我们使用线程可能是这么使用的：

new Thread(new Runnable(){
    @Override
    public void run() {
        System.out.println("thread run");
    }
}).start();

使用lambda可以这么使用：

new Thread(()->{
     System.out.println("thread run");
}).start();

上面的代码只有一行代码，可以再次进行优化写法：

new Thread( ()->System.out.println("thread run")).start();

2、Arrays.sort排序优化

在代码中，我们会使用Arrays.sort对数据进行排序，Arrays.sort是可以对数组、列表集合进行排序的，很多时候会使用的到。那么以前我们的写法是这样子的：

Integer[] playerScore = {89, 100, 77, 90,  86};
// 使用匿名内部类根据 分数从低到高进行排序
Arrays.sort(playerScore,new Comparator<Integer>(){
    /**
     *
     * @param o1 o1是后一个数，第一次比较就是100
     * @param o2 o2是前一个数，第一次比较就是89
     * @return 比较的返回值，第一次就是100.compareTo(89),返回值是1
     */
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1.compareTo(o2);
    }
});
for(Integer score:playerScore){
//输出结果：77,86,89,90,100,
    System.out.print(score);
}

使用lambda可以这么使用：

Arrays.sort(playerScore,(Integer o1,Integer o2)->o1.compareTo(o2) );

类型Integer也可以去掉优化成：

Arrays.sort(playerScore,(o1,o2)->o1.compareTo(o2) );

再次优化还可以这么写：

Arrays.sort(playerScore,Comparator.comparing(Integer::intValue));

其中Integer::intValue（方法引用使用一对冒号 **::**），就是Integer类中的方法intValue：

从高到底呢？

Arrays.sort(playerScore,Comparator.comparing(Integer::intValue).reversed());

3、List遍历

在java8之前对于List的遍历使用for循环的方式，在java8之后遍历打印就显得很简单了：

List<String> languages = Arrays.asList("java","php","python");
//java8 之前
for(String str:languages){
    System.out.print(str+",");
}

for(int i=0;i<languages.size();i++){
    System.out.print(languages.get(i)+",");
}

//java8之后
languages.forEach(language-> System.out.print(language+","));

4、Map遍历

Map<String,Object> map = new HashMap<>();
map.put("author","悟纤");
map.put("age","18");
map.put("blog","微信公众号「SpringBoot」");
map.put("hobby","美女");

//java8之前的方式：方法一 在for-each循环中使用entries来遍历（常用）
System.out.println("方法一 在for-each循环中使用entries来遍历:");
for(Map.Entry<String,Object> entry:map.entrySet()){
    System.out.println("key:"+entry.getKey()+",value:"+entry.getValue());
}

//java8之前的方式：方法二 在for-each循环中遍历keys或values。
System.out.println();
System.out.println("方法二 在for-each循环中遍历keys或values");
//遍历keys and value
for(String key:map.keySet()){
    System.out.println("key:"+key+",value:"+map.get(key));
}
//只遍历values
System.out.println("----------------");
for(Object value:map.values()){
    System.out.println("value:"+value);
}

//java8之前的方式：方法三使用Iterator遍历
System.out.println();
System.out.println("方法三使用Iterator遍历");
Iterator<Map.Entry<String,Object>> entryIterator = map.entrySet().iterator();
while(entryIterator.hasNext()){
    Map.Entry<String,Object> entry =  entryIterator.next();
    System.out.println("key:"+entry.getKey()+",value:"+entry.getValue());
}

//java8之后的方式
System.out.println("\njava8之后的方式");
map.forEach((key,value)->System.out.println("key:"+key+",value:"+value) );

对于对于Map如果没获取到key的话，我们会有一个默认值的显示，比如显示为“-”或者“无”，在java8这样的需求就简单的一匹：

//java8之前没有获取到key显示默认值为"-"
Object birthday = map.get("birthday");
if(birthday == null){
    birthday = "-";
}
System.out.println("birthday:"+birthday);

//java8之后的方式
System.out.println("birthday:"+map.getOrDefault("birthday","-"));

4、函数式接口

1、什么是函数式接口

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

2、自定义函数式接口

@FunctionalInterface
public interface MyNumber {
    public double getValue();
}

// 函数式接口中使用泛型
@FunctionalInterface
public interface MyFunc<T> {
    public T getValue(T t);
}

3、作为参数传递 Lambda 表达式

public String toUpperString(MyFunc<String> mf,String str){
    return mf.getValue(str);
}

String newStr = toUpperString((str) -> str.toLowerCase(),"abc");

作为参数传递 Lambda 表达式：为了将 Lambda 表达式作为参数传递，接收Lambda 表达式的参数类型必须是与该 Lambda 表达式兼容的函数式接口的类型。

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

5、其他接口

6、Consumer消费型接口

• 对类型为T的对象应用操作，包含方法：void accept(T t)

public void test1(){
    happy(10000, (m) -> System.out.println("充点券，每次消费：" + m + "元"));
} 

public void happy(double money, Consumer<Double> con){
    con.accept(money);
}

7、Supplier供给型接口

• 返回类型为T的对象，包含方法：T get();

//需求：产生指定个数的整数，并放入集合中
public List<Integer> getNumList(int num, Supplier<Integer> sup){
    List<Integer> list = new ArrayList<>();

    for (int i = 0; i < num; i++) {
        Integer n = sup.get();
        list.add(n);
    }

    return list;
}

public void test2(){
    List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));

    for (Integer num : numList) {
        System.out.println(num);
    }
}

8、Function<T, R> 函数型接口：

• 对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法：R apply(T t);

//需求：用于处理字符串
public String strHandler(String str, Function<String, String> fun){
    return fun.apply(str);
}

public void test3(){
    String newStr = strHandler("\t\t\t 我是一个函数型接口   ", (str) -> str.trim());
    System.out.println(newStr);

    String subStr = strHandler(" 我是一个函数型接口", (str) -> str.substring(2, 5));
    System.out.println(subStr);
}

9、Predicate断言型接口

• 确定类型为T的对象是否满足某约束，并返回boolean 值。包含方法boolean test(T t);

//需求：将满足条件的字符串，放入集合中
public List<String> filterStr(List<String> list, Predicate<String> pre){
    List<String> strList = new ArrayList<>();

    for (String str : list) {
        if(pre.test(str)){
            strList.add(str);
        }
    }

    return strList;
}

public void test4(){
    List<String> list = Arrays.asList("Hello", "Lambda", "www", "ok");
    List<String> strList = filterStr(list, (s) -> s.length() > 3);
    
    for (String str : strList) {
        System.out.println(str);
    }
}

5、方法引用与构造器引用

1、方法引用

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！（实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致！）方法引用：使用操作符 ::
将方法名和对象或类的名字分隔开来。如下三种主要使用情况：

• 对象::实例方法

  public void test2(){
      Employee emp = new Employee(101, "张三", 18, 9999.99);
  
      Supplier<String> sup = () -> emp.getName();
      System.out.println(sup.get());
  
      System.out.println("----------------------------------");
  
      Supplier<String> sup2 = emp::getName;
      System.out.println(sup2.get());
  }
  
  public void test3(){
      BiFunction<Double, Double, Double> fun = (x, y) -> Math.max(x, y);
      System.out.println(fun.apply(1.5, 22.2));
  
      System.out.println("--------------------------------------------------");
  
      BiFunction<Double, Double, Double> fun2 = Math::max;
      System.out.println(fun2.apply(1.2, 1.5));
  }
  
  

• 类::静态方法

  public void test4(){
      Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
  
      System.out.println("-------------------------------------");
  
      Comparator<Integer> com2 = Integer::compare;
  }
  
  

• 类::实例方法

(x) -> System.out.println(x);
等同于
System.out::println

public void test5(){
    BiPredicate<String, String> bp = (x, y) -> x.equals(y);
    System.out.println(bp.test("abcde", "abcde"));

    System.out.println("-----------------------------------------");

    BiPredicate<String, String> bp2 = String::equals;
    System.out.println(bp2.test("abc", "abc"));

    System.out.println("-----------------------------------------");

    Function<Employee, String> fun = (e) -> e.show();
    System.out.println(fun.apply(new Employee()));

    System.out.println("-----------------------------------------");

    Function<Employee, String> fun2 = Employee::show;
    System.out.println(fun2.apply(new Employee()));
}

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

2、构造器引用

格式：ClassName::new

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

public void test6(){
    Supplier<Employee> sup = () -> new Employee();
    System.out.println(sup.get());

    System.out.println("------------------------------------");

    Supplier<Employee> sup2 = Employee::new;
    System.out.println(sup2.get());
}

public void test7(){
    Function<String, Employee> fun = Employee::new;

    BiFunction<String, Integer, Employee> fun2 = Employee::new;
}

3、数组引用

• 格式： type[] :: new
  

public void test8(){
    Function<Integer, String[]> fun = (args) -> new String[args];
    String[] strs = fun.apply(10);
    System.out.println(strs.length);

    System.out.println("--------------------------");

    Function<Integer, Employee[]> fun2 = Employee[] :: new;
    Employee[] emps = fun2.apply(20);
    System.out.println(emps.length);
}

6、Stream API

1、了解 Stream

Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API(java.util.stream.*)
。Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

2、什么是 Stream

• 流(Stream) 到底是什么呢？

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

注意
：

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

3、Stream 的操作三个步骤

• 创建 Stream

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

• 中间操作

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

• 终止操作(终端操作)

  一个终止操作，执行中间操作链，并产生结果

4、创建 Stream

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

• default Streamstream() : 返回一个顺序流
• default StreamparallelStream() : 返回一个并行流

List<String> list = new ArrayList<>();
Stream<String> stream = list.stream(); //获取一个顺序流
Stream<String> parallelStream = list.parallelStream(); //获取一个并行流

1、由数组创建流

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

• staticStreamstream(T[] array): 返回一个流

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

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

Integer[] nums = new Integer[10];
Stream<Integer> stream1 = Arrays.stream(nums);

2、由值创建流

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

• public staticStreamof(T... values) : 返回一个流

Stream<Integer> stream2 = Stream.of(1,2,3,4,5,6);

3、由函数创建流：创建无限流

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

• 迭代 public staticStreamiterate(final T seed, final UnaryOperatorf)

  Stream<Integer> stream3 = Stream.iterate(0, (x) -> x + 2).limit(10);
  stream3.forEach(System.out::println);
  
  

• 生成 public staticStreamgenerate(Suppliers)

  Stream<Double> stream4 = Stream.generate(Math::random).limit(2);
  stream4.forEach(System.out::println);
  
  

5、Stream 的中间操作

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

1、筛选与切片

//内部迭代：迭代操作 Stream API 内部完成
@Test
public void test2(){
    //所有的中间操作不会做任何的处理
    Stream<Employee> stream = emps.stream()
        .filter((e) -> {
            System.out.println("测试中间操作");
            return e.getAge() <= 35;
        });

    //只有当做终止操作时，所有的中间操作会一次性的全部执行，称为“惰性求值”
    stream.forEach(System.out::println);
}

//外部迭代
@Test
public void test3(){
    Iterator<Employee> it = emps.iterator();

    while(it.hasNext()){
        System.out.println(it.next());
    }
}

@Test
public void test5(){
    emps.parallelStream()
        .filter((e) -> e.getSalary() >= 5000)
        .skip(2)
        .forEach(System.out::println);
}

@Test
public void test6(){
    emps.stream()
        .distinct()
        .forEach(System.out::println);
}

2、映射

/*
  映射
  map——接收 Lambda ， 将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
  flatMap——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
  */
@Test
public void test1(){
    Stream<String> str = emps.stream()
        .map((e) -> e.getName());

    System.out.println("-------------------------------------------");

    List<String> strList = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");

    Stream<String> stream = strList.stream()
        .map(String::toUpperCase);

    stream.forEach(System.out::println);

    Stream<Stream<Character>> stream2 = strList.stream()
        .map(TestStreamAPI1::filterCharacter);

    stream2.forEach((sm) -> {
        sm.forEach(System.out::println);
    });

    System.out.println("---------------------------------------------");

    Stream<Character> stream3 = strList.stream()
        .flatMap(TestStreamAPI1::filterCharacter);

    stream3.forEach(System.out::println);
}

public static Stream<Character> filterCharacter(String str){
    List<Character> list = new ArrayList<>();

    for (Character ch : str.toCharArray()) {
        list.add(ch);
    }
    return list.stream();
} 

3、排序

public void test2(){
    emps.stream()
        .map(Employee::getName)
        .sorted()
        .forEach(System.out::println);

    System.out.println("------------------------------------");

    emps.stream()
        .sorted((x, y) -> {
            if(x.getAge() == y.getAge()){
                return x.getName().compareTo(y.getName());
            }else{
                return Integer.compare(x.getAge(), y.getAge());
            }
        }).forEach(System.out::println);
}

6、Stream 的终止操作

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

1、查找与匹配

/*
  allMatch——检查是否匹配所有元素
  anyMatch——检查是否至少匹配一个元素
  noneMatch——检查是否没有匹配的元素
  findFirst——返回第一个元素
  findAny——返回当前流中的任意元素
  count——返回流中元素的总个数
  max——返回流中最大值
  min——返回流中最小值
  */
@Test
public void test1(){
    boolean bl = emps.stream()
        .allMatch((e) -> e.getStatus().equals(Status.BUSY));

    System.out.println(bl);

    boolean bl1 = emps.stream()
        .anyMatch((e) -> e.getStatus().equals(Status.BUSY));

    System.out.println(bl1);

    boolean bl2 = emps.stream()
        .noneMatch((e) -> e.getStatus().equals(Status.BUSY));

    System.out.println(bl2);
}

@Test
public void test2(){
    Optional<Employee> op = emps.stream()
        .sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))
        .findFirst();

    System.out.println(op.get());

    System.out.println("--------------------------------");

    Optional<Employee> op2 = emps.parallelStream()
        .filter((e) -> e.getStatus().equals(Status.FREE))
        .findAny();

    System.out.println(op2.get());
}

@Test
public void test3(){
    long count = emps.stream()
        .filter((e) -> e.getStatus().equals(Status.FREE))
        .count();

    System.out.println(count);

    Optional<Double> op = emps.stream()
        .map(Employee::getSalary)
        .max(Double::compare);

    System.out.println(op.get());

    Optional<Employee> op2 = emps.stream()
        .min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));

    System.out.println(op2.get());
}

//注意：流进行了终止操作后，不能再次使用
@Test
public void test4(){
    Stream<Employee> stream = emps.stream()
        .filter((e) -> e.getStatus().equals(Status.FREE));

    long count = stream.count();

    stream.map(Employee::getSalary)
        .max(Double::compare);
}

2、归约

@Test
public void test1(){
    List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);

    Integer sum = list.stream()
        .reduce(0, (x, y) -> x + y);

    System.out.println(sum);

    System.out.println("----------------------------------------");

    Optional<Double> op = emps.stream()
        .map(Employee::getSalary)
        .reduce(Double::sum);

    System.out.println(op.get());
}

//需求：搜索名字中 “六” 出现的次数
@Test
public void test2(){
    Optional<Integer> sum = emps.stream()
        .map(Employee::getName)
        .flatMap(TestStreamAPI1::filterCharacter)
        .map((ch) -> {
            if(ch.equals('六'))
                return 1;
            else 
                return 0;
        }).reduce(Integer::sum);

    System.out.println(sum.get());
}

3、收集

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

public void test3(){
    List<String> list = emps.stream()
        .map(Employee::getName)
        .collect(Collectors.toList());

    list.forEach(System.out::println);

    System.out.println("----------------------------------");

    Set<String> set = emps.stream()
        .map(Employee::getName)
        .collect(Collectors.toSet());

    set.forEach(System.out::println);

    System.out.println("----------------------------------");

    HashSet<String> hs = emps.stream()
        .map(Employee::getName)
        .collect(Collectors.toCollection(HashSet::new));

    hs.forEach(System.out::println);
}

public void test4(){
    Optional<Double> max = emps.stream()
        .map(Employee::getSalary)
        .collect(Collectors.maxBy(Double::compare));

    System.out.println(max.get());

    Optional<Employee> op = emps.stream()
        .collect(Collectors.minBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));

    System.out.println(op.get());

    Double sum = emps.stream()
        .collect(Collectors.summingDouble(Employee::getSalary));

    System.out.println(sum);

    Double avg = emps.stream()
        .collect(Collectors.averagingDouble(Employee::getSalary));

    System.out.println(avg);

    Long count = emps.stream()
        .collect(Collectors.counting());

    System.out.println(count);

    System.out.println("--------------------------------------------");

    DoubleSummaryStatistics dss = emps.stream()
        .collect(Collectors.summarizingDouble(Employee::getSalary));

    System.out.println(dss.getMax());
}

//分组
public void test5(){
    Map<Status, List<Employee>> map = emps.stream()
        .collect(Collectors.groupingBy(Employee::getStatus));

    System.out.println(map);
}

//多级分组
@Test
public void test6(){
    Map<Status, Map<String, List<Employee>>> map = emps.stream()
        .collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy((e) -> {
            if(e.getAge() >= 60)
                return "老年";
            else if(e.getAge() >= 35)
                return "中年";
            else
                return "成年";
        })));

    System.out.println(map);
}

//分区
@Test
public void test7(){
    Map<Boolean, List<Employee>> map = emps.stream()
        .collect(Collectors.partitioningBy((e) -> e.getSalary() >= 5000));

    System.out.println(map);
}

@Test
public void test8(){
    String str = emps.stream()
        .map(Employee::getName)
        .collect(Collectors.joining("," , "----", "----"));

    System.out.println(str);
}

@Test
public void test9(){
    Optional<Double> sum = emps.stream()
        .map(Employee::getSalary)
        .collect(Collectors.reducing(Double::sum));

    System.out.println(sum.get());
}

7、并行流与串行流

并行流
就是把一个内容分成多个数据块，并用不同的线程
分别处理每个数据块的流。

Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与顺序流之间进行切换。

public void test2(){
    Optional<Employee> op = emps.stream()
        .sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))
        .findFirst();

    System.out.println(op.get());

    System.out.println("--------------------------------");

    Optional<Employee> op2 = emps.parallelStream()
        .filter((e) -> e.getStatus().equals(Status.FREE))
        .findAny();

    System.out.println(op2.get());
}

8、新时间日期 API

1、使用 LocalDate、LocalTime、LocalDateTime

• LocalDate、LocalTime、LocalDateTime 类的实例是不可变的对象
  ，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的日期或时间，并不包含当前的时间信息。也不包含与时区相关的信息。

• 注：ISO-8601日历系统是国际标准化组织制定的现代公民的日期和时间的表示法

//1. LocalDate、LocalTime、LocalDateTime
@Test
public void test1(){
    LocalDateTime ldt = LocalDateTime.now();
    System.out.println(ldt);

    LocalDateTime ld2 = LocalDateTime.of(2016, 11, 21, 10, 10, 10);
    System.out.println(ld2);

    LocalDateTime ldt3 = ld2.plusYears(20);
    System.out.println(ldt3);

    LocalDateTime ldt4 = ld2.minusMonths(2);
    System.out.println(ldt4);

    System.out.println(ldt.getYear());
    System.out.println(ldt.getMonthValue());
    System.out.println(ldt.getDayOfMonth());
    System.out.println(ldt.getHour());
    System.out.println(ldt.getMinute());
    System.out.println(ldt.getSecond());
}

2、Instant 时间戳

用于“时间戳”的运算。它是以Unix元年(传统的设定为UTC时区1970年1月1日午夜时分)开始所经历的描述进行运算

//2. Instant : 时间戳。 （使用 Unix 元年  1970年1月1日 00:00:00 所经历的毫秒值）
@Test
public void test2(){
    Instant ins = Instant.now();  //默认使用 UTC 时区
    System.out.println(ins);

    OffsetDateTime odt = ins.atOffset(ZoneOffset.ofHours(8));
    System.out.println(odt);

    System.out.println(ins.getNano());

    Instant ins2 = Instant.ofEpochSecond(5);
    System.out.println(ins2);
}

3、Duration 和 Period

• Duration:用于计算两个“时间”间隔
• Period:用于计算两个“日期”间隔

//3.
//Duration : 用于计算两个“时间”间隔
//Period : 用于计算两个“日期”间隔
@Test
public void test3(){
    Instant ins1 = Instant.now();

    System.out.println("--------------------");
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
    }

    Instant ins2 = Instant.now();

    System.out.println("所耗费时间为：" + Duration.between(ins1, ins2));

    System.out.println("----------------------------------");

    LocalDate ld1 = LocalDate.now();
    LocalDate ld2 = LocalDate.of(2011, 1, 1);

    Period pe = Period.between(ld2, ld1);
    System.out.println(pe.getYears());
    System.out.println(pe.getMonths());
    System.out.println(pe.getDays());
}

4、日期的操纵

• TemporalAdjuster : 时间校正器。有时我们可能需要获取例如：将日期调整到“下个周日”等操作。
• TemporalAdjusters : 该类通过静态方法提供了大量的常用 TemporalAdjuster 的实现。

//4. TemporalAdjuster : 时间校正器
@Test
public void test4(){
    LocalDateTime ldt = LocalDateTime.now();
    System.out.println(ldt);

    LocalDateTime ldt2 = ldt.withDayOfMonth(10);
    System.out.println(ldt2);

    LocalDateTime ldt3 = ldt.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));
    System.out.println(ldt3);

    //自定义：下一个工作日
    LocalDateTime ldt5 = ldt.with((l) -> {
        LocalDateTime ldt4 = (LocalDateTime) l;

        DayOfWeek dow = ldt4.getDayOfWeek();

        if(dow.equals(DayOfWeek.FRIDAY)){
            return ldt4.plusDays(3);
        }else if(dow.equals(DayOfWeek.SATURDAY)){
            return ldt4.plusDays(2);
        }else{
            return ldt4.plusDays(1);
        }
    });
    System.out.println(ldt5);
}

5、解析与格式化

java.time.format.DateTimeFormatter 类：该类提供了三种格式化方法：

• 预定义的标准格式
• 语言环境相关的格式
• 自定义的格式

//5. DateTimeFormatter : 解析和格式化日期或时间
@Test
public void test5(){
    //  DateTimeFormatter dtf = DateTimeFormatter.ISO_LOCAL_DATE;

    DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss E");

    LocalDateTime ldt = LocalDateTime.now();
    String strDate = ldt.format(dtf);

    System.out.println(strDate);

    LocalDateTime newLdt = ldt.parse(strDate, dtf);
    System.out.println(newLdt);
}

6、时区的处理

• Java8 中加入了对时区的支持，带时区的时间为分别为：

  ZonedDate、ZonedTime、ZonedDateTime

• 其中每个时区都对应着 ID，地区ID都为 “{区域}/{城市}”的格式例如 ：Asia/Shanghai 等

• ZoneId：该类中包含了所有的时区信息

  getAvailableZoneIds() : 可以获取所有时区时区信息

  of(id) : 用指定的时区信息获取 ZoneId 对象

@Test
public void test6(){
    Set<String> set = ZoneId.getAvailableZoneIds();
    set.forEach(System.out::println);
}

//6.ZonedDate、ZonedTime、ZonedDateTime ： 带时区的时间或日期
@Test
public void test7(){
    LocalDateTime ldt = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
    System.out.println(ldt);

    ZonedDateTime zdt = ZonedDateTime.now(ZoneId.of("US/Pacific"));
    System.out.println(zdt);
}

9、接口中的默认方法与静态方法

1、接口中的默认方法

Java 8中允许接口中包含具有具体实现的方法，该方法称为默认方法
，默认方法使用 default
关键字修饰。

public interface MyFun {
 default String getName(){
  return "哈哈哈";
 }
}

接口默认方法的类优先
原则

若一个接口中定义了一个默认方法，而另外一个父类或接口中又定义了一个同名的方法时

• 选择父类中的方法。如果一个父类提供了具体的实现，那么接口中具有相同名称和参数的默认方法会被忽略。
• 接口冲突。如果一个父接口提供一个默认方法，而另一个接口也提供了一个具有相同名称和参数列表的方法（不管方法是否是默认方法），那么必须覆盖该方法来解决冲突

public interface MyInterface {
 
 default String getName(){
  return "呵呵呵";
 }
}

public interface MyFun {
 default String getName(){
  return "哈哈哈";
 }
}

public class SubClass implements MyFun, MyInterface{
 @Override
 public String getName() {
  return MyInterface.super.getName();
 }
}

2、接口中的静态方法

Java8 中，接口中允许添加静态方法。

public interface MyInterface {

    default String getName(){
        return "呵呵呵";
    }

    public static void show(){
        System.out.println("接口中的静态方法");
    }
}

10、其他新特性

1、Optional 类

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

public void test1(){
    Optional<Employee> op = Optional.of(new Employee());
    Employee emp = op.get();
    System.out.println(emp);
}

public void test2(){
    /*Optional<Employee> op = Optional.ofNullable(null);
  System.out.println(op.get());*/

    Optional<Employee> op = Optional.empty();
    System.out.println(op.get());
}

public void test3(){
    Optional<Employee> op = Optional.ofNullable(new Employee());

    if(op.isPresent()){
        System.out.println(op.get());
    }

    Employee emp = op.orElse(new Employee("张三"));
    System.out.println(emp);

    Employee emp2 = op.orElseGet(() -> new Employee());
    System.out.println(emp2);
}

public void test4(){
    Optional<Employee> op = Optional.of(new Employee(101, "张三", 18, 9999.99));

    Optional<String> op2 = op.map(Employee::getName);
    System.out.println(op2.get());

    Optional<String> op3 = op.flatMap((e) -> Optional.of(e.getName()));
    System.out.println(op3.get());
}

2、重复注解与类型注解

Java 8对注解处理提供了两点改进：可重复
的注解及可用于类型
的注解。

@Target({TYPE,
    FIELD,
    METHOD,
    PARAMETER,
    CONSTRUCTOR,
    LOCAL_VARIABLE
})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotations {
    MyAnnotation[] value();
}

@Repeatable(MyAnnotations.class)
@Target({TYPE,
    FIELD,
    METHOD,
    PARAMETER,
    CONSTRUCTOR,
    LOCAL_VARIABLE,
    ElementType.TYPE_PARAMETER
})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value();
}

@MyAnnotation("Hello")
@MyAnnotation("World")
public void show(@MyAnnotation("abc") String str){}

11、更多

官网：https://blog.xueqimiao.com

JDK9新特性：https://blog.xueqimiao.com/jdk/fcbe01/

JDK10新特性：https://blog.xueqimiao.com/jdk/327540/

JDK11新特性：https://blog.xueqimiao.com/jdk/ef5003/

JDK12新特性：https://blog.xueqimiao.com/jdk/682299/

JDK13新特性：https://blog.xueqimiao.com/jdk/645800/

JDK14新特性：https://blog.xueqimiao.com/jdk/ff3ee3/

JDK15新特性：https://blog.xueqimiao.com/jdk/c10871/

JDK16新特性：https://blog.xueqimiao.com/jdk/faf6a9/

JDK17新特性：https://blog.xueqimiao.com/jdk/d561a3/