Java 8的新特性（入门）

àì夳堔傛蜴生んèń 2023-09-30 12:58 7阅读 0赞

Java8新特性

## 一，简介 ##

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

新特性简介：

⚫ 速度更快

⚫ 代码更少（增加了新的语法 **Lambda** **表达式**）

⚫ 强大的 **Stream API**

⚫ 便于并行

⚫ 最大化减少空指针异常 Optional

其中最为核心的为 Lambda 表达式与Stream API

## 二. Lambda表达式 ##

### 1.简介 ###

为什么使用Lambda 表达式：

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

### 2.从匿名类到 Lambda 的转换 ###

![image-20220406195554023][]

![image-20220406195612370][]

### 3.语法 ###

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

\*\*左侧：\*\*指定了 Lambda 表达式需要的所有参数

\*\*右侧：\*\*指定了 Lambda 体，即 Lambda 表达式要执行的功能

语法格式一：无参，无返回值，Lambda体只需一条语句

![image-20220406195904706][]

语法格式二：Lambda需要一个参数

![image-20220406195912217][]

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

![image-20220406195916325][]

语法格式四：Lambda需要两个参数，并且有返回值

Comparator<Integer> comparator = (x , y)->{
        
        System.out.println("包含多条语句应有大括号");
        System.out.println("比较x,y的大小");
        return Integer.compare(x,y);
    };

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

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

语法格式六：Lambda表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“数据推断”

![image-20220406200219387][]

**类型推断**

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

--------------------

## 三.函数式接口 ##

### 1.定义 ###

⚫ 只包含一个抽象方法的接口，称为**函数式接口**。

⚫ 你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda

表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方

法上进行声明）。

⚫ 我们可以在任意函数式接口上使用 **@FunctionalInterface** 注解，

这样做可以检查它是否是一个函数式接口，同时 javadoc 也会包

含一条声明，说明这个接口是一个函数式接口。

### 2.自定义函数式接口 ###

![image-20220406200641777][]

### 3.作为参数传递Lambda 表达式 ###

![image-20220406200857587][]

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

### \*练习： ###

![image-20220406193815767][]

MyFunction

package Test;
    
    @FunctionalInterface
    public interface MyFunction {
        
        public String getValue(String str);
    }

Test2

package Test;
    
    import org.testng.annotations.Test;
    public class Test2 {
        
    
        @Test
        public void test2(){
        
            //先去掉首尾空格
            String strtrim  = strHandler("\t\t\t Java8",(str) -> str.trim());
            System.out.println(strtrim);
            //截取字符
            String newstr = strHandler("abcdefghijklmn",str -> str.substring(2,5));
            System.out.println(newstr);
            
    }
        //用于处理字符串的方法
        public String strHandler(String str,MyFunction myFunction){
        
            return myFunction.getValue(str);
        }
    
    }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4atDP0r0-1649521532194)(https://gitee.com/yan-chaochao/typora-library/raw/master/typora-library/image-20220406193939471.png)\]

## 四.Java四大内置的函数接口 ##

<table> 
 <thead> 
  <tr> 
   <th>函数式接口</th> 
   <th>参数类型</th> 
   <th><strong>返回类型</strong></th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Consumer&lt; T &gt;消费型接口</td> 
   <td>T</td> 
   <td>void</td> 
   <td>对类型为T的对象应用操作：void accept(T t)</td> 
  </tr> 
  <tr> 
   <td>Supplier&lt; T &gt;供给型接口</td> 
   <td>无</td> 
   <td>T</td> 
   <td>返回类型为T的对象：T get()</td> 
  </tr> 
  <tr> 
   <td>Function&lt;T, R&gt;函数型接口</td> 
   <td>T</td> 
   <td>R</td> 
   <td>对类型为T的对象应用操作，并返回结果为R类型的对象：R apply(T t)</td> 
  </tr> 
  <tr> 
   <td>Predicate 断言型接口</td> 
   <td>T</td> 
   <td>boolean</td> 
   <td>确定类型为T的对象是否满足某约束，并返回boolean值：boolean test(T t)</td> 
  </tr> 
 </tbody> 
</table>

### 1.消费型接口 ###

@Test
        public void test01(){
            //Consumer
            Consumer<Integer> consumer = (x) -> System.out.println("消费型接口" + x);
            //test
            consumer.accept(100);
        }

![image-20220406202250800][]

### 2.供给型接口 ###

@Test
    public void test02(){
        
        List<Integer> list = new ArrayList<>();
        List<Integer> integers = Arrays.asList(1,2,3);
        list.addAll(integers);
        //Supplier<T>
        Supplier<Integer> supplier = () -> (int)(Math.random() * 10);
        list.add(supplier.get());
        System.out.println(supplier);
        for (Integer integer : list) {
        
            System.out.println(integer);
        }
    }

![image-20220406202809121][]

### 3.函数型接口 ###

@Test
    public void test03(){
        
        //Function<T, R>
        String oldStr = "abc123456xyz";
        Function<String, String> function = (s) -> s.substring(1, s.length()-1);
        //test
        System.out.println(function.apply(oldStr));
    }

![image-20220406203052718][]

### 4.断言型接口 ###

@Test
    public void test04(){
        
        //Predicate<T>
        Integer age = 35;
        Predicate<Integer> predicate = (i) -> i >= 35;
        if (predicate.test(age)){
        
            System.out.println("你该退休了");
        } else {
        
            System.out.println("我觉得还OK啦");
        }
    }

![image-20220406204316191][]

### 其他接口 ###

![image-20220406205344089][]

## 五.引用 ##

### 1.方法引用 ###

#### 定义： ####

若 Lambda 表达式体中的内容已有方法实现，则我们可以使用“方法引用”

语法格式：

*  对象 :: 实例方法
 *  类 :: 静态方法
 *  类 :: 实例方法

#### 对象::实例方法 ####

package study;
    import org.testng.annotations.Test;
    import java.io.PrintStream;
    import java.util.function.Consumer;
    
    public class Test3 {
        @Test
        public void test01(){
            PrintStream ps = System.out;
            Consumer<String> con1 = (s) -> ps.println(s);
            con1.accept("aaa");
            Consumer<String> con2 = ps::println;
            con2.accept("bbb");
        }
    }

\*\*注意：\*\*Lambda 表达实体中调用方法的参数列表、返回类型必须和函数式接口中抽象方法保持一致

![image-20220406221201511][]

#### 类::静态方法 ####

package study;
    
    import org.testng.annotations.Test;
    
    import java.io.PrintStream;
    import java.util.Comparator;
    import java.util.function.Consumer;
    
    public class Test3 {
        @Test
        public void test02(){
            Comparator<Integer> com1 = (x, y) -> Integer.compare(x, y);
            System.out.println(com1.compare(1, 2));
            Comparator<Integer> com2 = Integer::compare;
            System.out.println(com2.compare(2, 1));
    
        }
    }

![image-20220406221426478][]

#### 类::实例方法 ####

package study;
    import org.testng.annotations.Test;
    import java.io.PrintStream;
    import java.util.Comparator;
    import java.util.function.BiPredicate;
    import java.util.function.Consumer;
    
    public class Test3 {
        
        @Test
        public void test03(){
        
            BiPredicate<String, String> bp1 = (x, y) -> x.equals(y);
            System.out.println(bp1.test("a","b"));
    
            BiPredicate<String, String> bp2 = String::equals;
            System.out.println(bp2.test("c","c"));
        }
    }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9yibnowR-1649521532197)(C:\\Users\\lenovo\\AppData\\Roaming\\Typora\\typora-user-images\\image-20220406221640623.png)\]

\*\*条件：\*\*Lambda 参数列表中的第一个参数是方法的调用者，第二个参数是方法的参数时，才能使用 ClassName :: Method

### 2.构造器引用 ###

格式：

ClassName :: new

@Test
        public void test04(){
        
            Supplier<List> sup1 = () -> new ArrayList();
            //构造器引用方式
            Supplier<List> sup2 = ArrayList::new;
    
        }

\*\*注意：\*\*需要调用的构造器的参数列表要与函数时接口中抽象方法的参数列表保持一致

### 3.数组引用 ###

@Test
        public void test05(){
        
            Function<Integer,String[]> fun1 = (x)->new String[x];
            String[] str1 = fun1.apply(10);
            System.out.println(str1.length);
            Function<Integer,String[]> fun2 = String[]::new;
            String[] str2 = fun2.apply(20);
            System.out.println(str2.length);
    
        }

![image-20220407143349256][]

## 六.Stream API ##

### 1.了解Stream ###

#### （1）简介 ####

Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一

个则是 **Stream API(java.util.stream.\*)**。

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对

集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。

使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数

据库查询。也可以使用 Stream API 来并行执行操作。简而言之，

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

#### （2）什么是Stream ####

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

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

**“集合讲的是数据，流讲的是计算！”**

**注意：**

①Stream 自己不会存储元素。

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

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

--------------------

### 2.Stream的操作三个步骤 ###

⚫ **创建 Stream**

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

⚫ **中间操作**

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

⚫ **终止操作(终端操作)**

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

--------------------

### 3.创建Stream ###

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

⚫ default Stream stream() : 返回一个顺序流

⚫ default Stream parallelStream() : 返回一个并行流

#### (1)由数组创建流 ####

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

⚫ static Stream stream(T\[\] array): 返回一个流重载形式，能够处理对应基本类型的数组：

⚫ public static IntStream stream(int\[\] array)

⚫ public static LongStream stream(long\[\] array)

⚫ public static DoubleStream stream(double\[\] array)

#### (2)由值创建流 ####

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

⚫ public static Stream of(T… values) : 返回一个流

#### (3)由函数创建流：创建无限流 ####

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

⚫ 迭代

public static Stream iterate(final T seed, final

UnaryOperator f)

⚫ 生成

public static Stream generate(Supplier s) :

代码举例：

@Test
        public void test06(){
        
    
            //1.可以通过Collection系列集合提供的stream（）或parallelStream（）
            //集合流:
            // - Collection.stream() 穿行流
            // - Collection.parallelStream() 并行流
            List<String> list = new ArrayList<>();
            Stream<String> stream1 = list.stream();
            
            //2.通过Arrays中的静态方法stream（）获取数组连接
            //Arrays.stream(array)
            String[] strings = new String[10];
            Stream<String> stream2 = Arrays.stream(strings);
    
            //3.通过Stream 类中静态方法of()
            //Stream.of(...)
            Stream<Integer> stream3 = Stream.of(1, 2, 3);
    
            //4.创建无限流
            //迭代
            Stream<Integer> stream4 = Stream.iterate(0, (i) -> i+2);
            stream4.limit(10).forEach(System.out::println);
            //生成
            Stream.generate(() -> Math.random())
                    .limit(5)
                    .forEach(System.out::println);
        }

![image-20220407153100700][]

--------------------

### 4.Stream中间操作 ###

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

#### (1)筛选与切片 ####

![image-20220407153632420][]

*  内部迭代：迭代操作由 Stream API 完成
    
    ![image-20220407181241062][]
 *  外部迭代：我们通过迭代器完成

![image-20220407181248504][]

#### (2)映射 ####

*  map：接收 Lambda ，将元素转换为其他形式或提取信息；接受一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素

@Test
        public void test08(){
        
            List<String> list = Arrays.asList("a", "b", "c");
            list.stream()
                    .map((str) -> str.toUpperCase())
                    .forEach(System.out::println);
        }

![image-20220407182455717][]

*  flatMap：接收一个函数作为参数，将流中每一个值都换成另一个流，然后把所有流重新连接成一个流

public class Tests {
        
        public Stream<Character> filterCharacter(String str){
        
            List<Character> list = new ArrayList<>();
            for (char c : str.toCharArray()) {
        
                list.add(c);
            }
            return list.stream();
        }
    }
    @Test
    public void test09(){
        
        List<String> list = Arrays.asList("aaa", "bbb", "ccc");
        Tests tests = new Tests();
        list.stream()
                .flatMap(tests::filterCharacter)
                .forEach(System.out::println);
    }

结果：

a
    a
    a
    b
    b
    b
    c
    c
    c
    
    ===============================================
    Default Suite
    Total tests run: 1, Passes: 1, Failures: 0, Skips: 0
    ===============================================

![image-20220407181824196][]

#### (3)排序 ####

<table> 
 <thead> 
  <tr> 
   <th align="center">方法</th> 
   <th align="center">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><strong>sorted()</strong></td> 
   <td align="center">产生一个新流，其中按自然顺序排序</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>sorted(Comparator comp)</strong></td> 
   <td align="center">产生一个新流，其中按比较器顺序排序</td> 
  </tr> 
 </tbody> 
</table>

\*\*sorted()\*\*自然排序

@Test
        public void test10(){
        
            List<String> list = Arrays.asList("c", "a", "b");
            list.stream()
                    .sorted()
                    .forEach(System.out::println);
        }

结果：

a
    b
    c
    
    ===============================================
    Default Suite
    Total tests run: 1, Passes: 1, Failures: 0, Skips: 0
    ===============================================
    
    进程已结束,退出代码0

**sorted(Comparator comp)** 比较器顺序排序

@Test
        public void test05(){
        
            emps.stream()
                    .sorted((e1, e2) -> {
         //compara()
                        if (e1.getAge().equals(e2.getAge())){
        
                            return e1.getName().compareTo(e2.getName());
                        } else {
        
                            return e1.getAge().compareTo(e2.getAge());
                        }
                    })
                    .forEach(System.out::println);
        }

--------------------

### 5.Stream的终止操作 ###

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

#### (1)查找与匹配 ####

<table> 
 <thead> 
  <tr> 
   <th align="center">方法</th> 
   <th align="center">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><strong>allMatch(Predicate p)</strong></td> 
   <td align="center">检查是否匹配所有元素</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>anyMatch</strong>(<strong>Predicate p</strong>)</td> 
   <td align="center">检查是否至少匹配一个元素</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>noneMatch(Predicate p)</strong></td> 
   <td align="center">检查是否没有匹配所有元素</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>findFirst()</strong></td> 
   <td align="center">返回第一个元素</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>findAny()</strong></td> 
   <td align="center">返回当前流中的任意元素</td> 
  </tr> 
 </tbody> 
</table>

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zpJIIb7C-1649521532199)(https://gitee.com/yan-chaochao/typora-library/raw/master/typora-library/image-20220407154558408.png)\]

*  allMatch：检查是否匹配所有元素
 *  anyMatch：检查是否至少匹配一个元素
 *  noneMatch：检查是否没有匹配所有元素
 *  findFirst：返回第一个元素
 *  findAny：返回当前流中的任意元素
 *  count：返回流中元素的总个数
 *  max：返回流中最大值
 *  min：返回流中最小值

@Test
    public void test01(){
        List<Status> list = Arrays.asList(Status.FREE, Status.BUSY, Status.VOCATION);
    
        boolean flag1 = list.stream()
            .allMatch((s) -> s.equals(Status.BUSY));
        System.out.println(flag1);
    
        boolean flag2 = list.stream()
            .anyMatch((s) -> s.equals(Status.BUSY));
        System.out.println(flag2);
    
        boolean flag3 = list.stream()
            .noneMatch((s) -> s.equals(Status.BUSY));
        System.out.println(flag3);
    
        // 避免空指针异常
        Optional<Status> op1 = list.stream()
            .findFirst();
        // 如果Optional为空 找一个替代的对象
        Status s1 = op1.orElse(Status.BUSY);
        System.out.println(s1);
    
        Optional<Status> op2 = list.stream()
            .findAny();
        System.out.println(op2);
    
        long count = list.stream()
            .count();
        System.out.println(count);
    }

#### (2)归约 ####

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZE8zIeHc-1649521532200)(https://gitee.com/yan-chaochao/typora-library/raw/master/typora-library/image-20220407180925241.png)\]

@Test
    public void test01(){
        
            List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
            Integer integer = list.stream()
                    .reduce(0, (x, y) -> x + y);
            System.out.println(integer);
    }

结果：

45
    
    ===============================================
    Default Suite
    Total tests run: 1, Passes: 1, Failures: 0, Skips: 0
    ===============================================
    
    
    进程已结束,退出代码0

--------------------

#### (3)收集 ####

<table> 
 <thead> 
  <tr> 
   <th align="center">方法</th> 
   <th align="center">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><strong>collect(Collector c)</strong></td> 
   <td align="center">将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法</td> 
  </tr> 
 </tbody> 
</table>

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cvM2TyhW-1649521532200)(C:\\Users\\lenovo\\AppData\\Roaming\\Typora\\typora-user-images\\image-20220407205347159.png)\]

![image-20220407205358891][]

--------------------

**代码举例：**

--------------------

###### 1.收集到List ######

public class Test5 {
        
    
        List<Employee> emps = Arrays.asList(
                new Employee(101, "Z3", 19, 9999.99),
                new Employee(102, "L4", 20, 7777.77),
                new Employee(103, "W5", 35, 6666.66),
                new Employee(104, "Tom", 44, 1111.11),
                new Employee(105, "Jerry", 60, 4444.44)
        );
        @Test
        public void test01(){
        
            List<String> list = emps.stream()
                    .map(Employee::getName)
                    .collect(Collectors.toList());
            list.forEach(System.out::println);
        }

![image-20220407205538690][]

###### 2.收集到set ######

public class Test5 {
    
        List<Employee> emps = Arrays.asList(
                new Employee(101, "张三", 19, 9999.99),
                new Employee(102, "李四", 20, 7777.77),
                new Employee(103, "王五", 35, 6666.66),
                new Employee(104, "Jerry", 44, 1111.11),
                new Employee(105, "Jerry", 60, 4444.44)
        );
    
        @Test
        public void test02(){
            Set<String> set = emps.stream()
                    .map(Employee::getName)
                    .collect(Collectors.toSet());
            set.forEach(System.out::println);
        }
    }

![image-20220408201716783][]

###### 3.放入HashSet ######

public class Test5 {
        
        List<Employee> emps = Arrays.asList(
                new Employee(101, "张三", 19, 9999.99),
                new Employee(102, "李四", 20, 7777.77),
                new Employee(103, "王五", 35, 6666.66),
                new Employee(104, "Jerry", 44, 1111.11),
                new Employee(105, "Jerry", 60, 4444.44)
        );
        @Test
        public void tests03(){
            //放入LinkedHashSet
            LinkedHashSet<String> linkedHashSet = emps.stream()
                    .map(Employee::getName)
                    .collect(Collectors.toCollection(LinkedHashSet::new));
            linkedHashSet.forEach(System.out::println);
        }
    }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DLUvx5bm-1649521532201)(https://gitee.com/yan-chaochao/typora-library/raw/master/typora-library/image-20220408202133459.png)\]

###### 4.总数 ######

public class Test5 {
    
        List<Employee> emps = Arrays.asList(
                new Employee(101, "张三", 19, 9999.99),
                new Employee(102, "李四", 20, 7777.77),
                new Employee(103, "王五", 35, 6666.66),
                new Employee(104, "Tom", 44, 1111.11),
                new Employee(105, "Jerry", 60, 4444.44)
    
        );
        @Test
        public void tests03(){
            //总数
            Long count = emps.stream()
                    .collect(Collectors.counting());
            System.out.println(count);
        }
    }

![image-20220408202444646][]

###### 5.平均值 ######

List<Employee> emps = Arrays.asList(
                new Employee(101, "张三", 19, 10000),
                new Employee(102, "李四", 20,20000),
                new Employee(103, "王五", 35, 30000),
                new Employee(104, "Tom", 44, 40000),
                new Employee(105, "Jerry", 60, 50000)
    
        );
        @Test
        public void test(){
        
            //平均值
            Double avg = emps.stream()
                    .collect(Collectors.averagingDouble(Employee::getSalary));
            System.out.println(avg);
    	}
    }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lhLcc6zq-1649521532202)(https://gitee.com/yan-chaochao/typora-library/raw/master/typora-library/image-20220408202629418.png)\]

###### 6.总和 ######

![image-20220408202854330][]

###### 7.最大值 ######

![image-20220408202936556][]

###### 8.最小值 ######

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AcESZB3s-1649521532203)(https://gitee.com/yan-chaochao/typora-library/raw/master/typora-library/image-20220408203048076.png)\]

###### 9.分组 ######

public class Test5 {
        
        List<Employee> emps = Arrays.asList(
                new Employee(101, "张三", 19, 10000),
                new Employee(102, "李四", 20,20000),
                new Employee(103, "王五", 35, 30000),
                new Employee(104, "Tom", 44, 40000),
                new Employee(105, "Jerry", 60, 50000)
        );
        @Test
        public void tests(){
        
            //分组
            Map<Integer, List<Employee>> map = emps.stream()
                    .collect(Collectors.groupingBy(Employee::getId));
            //输出Map
            System.out.println(map);
            System.out.println("------------------------------------------------------");
            //遍历Map
            map.values().forEach(System.out::println);
    	}
    }

![image-20220408204001619][]

###### 10.多级分组 ######

public class Test5 {
        
        List<Employee> emps = Arrays.asList(
                new Employee(101, "张三", 19, 10000),
                new Employee(102, "李四", 20,20000),
                new Employee(103, "王五", 35, 30000),
                new Employee(104, "Tom", 44, 40000),
                new Employee(105, "Jerry", 60, 50000)
    
        );
        @Test
        public void tests(){
        
            //多级分组
            Map<Integer, Map<String, List<Employee>>> mapMap = emps.stream()
                    .collect(Collectors.groupingBy(Employee::getId, Collectors.groupingBy((e) -> {
        
                        if (e.getAge() > 35) {
        
                            return "开除";
                        } else {
        
                            return "继续加班";
                        }
                    })));
            System.out.println(mapMap);
            //遍历Map
            mapMap.values().forEach(System.out::println);
        }
    }

![image-20220408204244339][]

###### 11.分层 ######

true/false

![image-20220408204458941][]

结果：
    {false=[], true=[Employee [id=101, name=张三, age=19, salary=10000.0], Employee [id=102, name=李四, age=20, salary=20000.0], Employee [id=103, name=王五, age=35, salary=30000.0], Employee [id=104, name=Tom, age=44, salary=40000.0], Employee [id=105, name=Jerry, age=60, salary=50000.0]]}

###### 12.总结 ######

public class Test5 {
    
        List<Employee> emps = Arrays.asList(
                new Employee(101, "张三", 19, 10000),
                new Employee(102, "李四", 20,20000),
                new Employee(103, "王五", 35, 30000),
                new Employee(104, "Tom", 44, 40000),
                new Employee(105, "Jerry", 60, 50000)
    
        );
    
        @Test
        public void test05(){
            //总结
            DoubleSummaryStatistics dss = emps.stream()
                    .collect(Collectors.summarizingDouble(Employee::getSalary));
            System.out.println(dss.getMax());
            System.out.println(dss.getMin());
            System.out.println(dss.getSum());
            System.out.println(dss.getCount());
            System.out.println(dss.getAverage());
    	}
    }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cAzuAC2C-1649521532204)(https://gitee.com/yan-chaochao/typora-library/raw/master/typora-library/image-20220408205231325.png)\]

###### 13.连接 ######

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nQqEQAUs-1649521532204)(https://gitee.com/yan-chaochao/typora-library/raw/master/typora-library/image-20220408205329113.png)\]

### 6.案例 ###

（1）给定一个数字列表，如何返回一个由每个数的平方构成的列表呢？(如：给定【1，2，3，4，5】，返回【1，4，9，16，25】)

@Test
    public void test01(){
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        list.stream()
            .map((x) -> x * x)
            .forEach(System.out::println);
    }

![image-20220408210121540][]

（2）怎样使用 map 和 reduce 数一数流中有多少个 Employee 呢？

![image-20220408210207770][]

## 七.并行流与串行流 ##

### 1.简介 ###

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

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

### 2.了解 Fork/Join 框架 ###

\*\*Fork/Join 框架：\*\*就是在必要的情况下，将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），再将一个个的小任务运算的结果进行 join 汇总.。

![image-20220408212059515][]

### 3.Fork/Join 框架与传统线程池的区别 ###

采用 “**工作窃取**”模式（work-stealing）：当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。相对于一般的线程池实现,fork/join框架的优势体现在对其中包含的任务的处理方式上.在一般的线程池中,如果一个线程正在执行的任务由于某些原因无法继续运行,那么该线程会处于等待状态.而在fork/join框架实现中,如果某个子问题由于等待另外一个子问题的完成而无法继续运行.那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行.这种方式减少了线程的等待时间,提高了性能.

### 4.Fork/Join的实现 ###

在实现前要继承一个类

RecursiveTask（有返回值）

或者

RecursiveAction（无返回值）

Recursive（英文翻译：递归）

public class ForkJoinCalculate extends RecursiveTask<Long> {
        
    
        private static final long serialVersionUID = 1234567890L;
    
        private long start;
        private long end;
    
        private static final long THRESHPLD = 10000;
    
        public ForkJoinCalculate(long start, long end) {
        
            this.start = start;
            this.end = end;
        }
    
        @Override
        protected Long compute() {
        
            long length = end - start;
    
            if (length <= THRESHPLD) {
        
                long sum = 0;
                for (long i = start; i <= end; i++) {
        
                    sum += i;
                }
            } else {
        
                long middle = (start + end) / 2;
    
                ForkJoinCalculate left = new ForkJoinCalculate(start, end);
                left.fork(); //拆分子任务 压入线程队列
    
                ForkJoinCalculate right = new ForkJoinCalculate(middle + 1, end);
                right.fork();
    
                return left.join() + right.join();
            }
    
            return null;
        }
    }
    
    public class TestForkJoin {
        
    
        /**
         * ForkJoin 框架
         */
        @Test
        public void test01(){
        
            Instant start = Instant.now();
    
            ForkJoinPool pool = new ForkJoinPool();
            ForkJoinCalculate task = new ForkJoinCalculate(0, 100000000L);
    
            Long sum = pool.invoke(task);
            System.out.println(sum);
    
            Instant end = Instant.now();
            System.out.println(Duration.between(start, end).getNano());
        }
    
        /**
         * 普通 for循环
         */
        @Test
        public void test02(){
        
            Instant start = Instant.now();
    
            Long sum = 0L;
            for (long i = 0; i < 100000000L; i++) {
        
                sum += i;
            }
    
            Instant end = Instant.now();
            System.out.println(Duration.between(start, end).getNano());
        }
    }

Java8并行流/串行流

@Test
    public void test03(){
        
        //串行流(单线程)：切换为并行流 parallel()
        //并行流：切换为串行流 sequential()
        LongStream.rangeClosed(0, 100000000L)
            .parallel() //底层：ForkJoin
            .reduce(0, Long::sum);
    
    }

--------------------

## 八.Optional ##

### 1.定义： ###

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

### 2.常用方法： ###

1.  Optional.of(T t)：创建一个 Optional 实例
2.  Optional.empty(T t)：创建一个空的 Optional 实例
3.  Optional.ofNullable(T t)：若 t 不为 null，创建 Optional 实例，否则空实例
4.  isPresent()：判断是否包含某值
5.  orElse(T t)：如果调用对象包含值，返回该值，否则返回 t
6.  orElseGet(Supplier s)：如果调用对象包含值，返回该值，否则返回 s 获取的值
7.  map(Function f)：如果有值对其处理，并返回处理后的 Optional，否则返回 Optional.empty()
8.  flatmap(Function mapper)：与 map 相似，要求返回值必须是 Optional

###### (1)Optional.of ######

创建一个 Optional 实例

（此代码中未传递任何值）

在构造过程中Optional.of(null);会发生空指针异常

@Test
        public void test01(){
        
            Optional<Employee> op = Optional.of(new Employee());
            Employee employee = op.get();
            System.out.println(employee);
        }

![image-20220408222527897][]

###### (2)Optional.empty ######

创建一个空的 Optional 实例

@Test
        public void test01(){
        
            Optional<Employee> op = Optional.empty();
    
            System.out.println(op.get());
        }

此代码会发生空指针异常

###### (3)Optional.ofNullable ######

Optional.ofNullable(T t)：若 t 不为 null，创建 Optional 实例，否则空实例

@Test
        public void test01(){
        
            Optional<Employee> op = Optional.ofNullable(null);
            System.out.println(op.get());
        }

###### (4)isPresent ######

isPresent()：判断是否包含某值

@Test
        public void test03(){
        
            Optional<Employee> op = Optional.ofNullable(new Employee());
            if (op.isPresent()) {
        
                System.out.println(op.get());
            }
            else {
        
                System.out.println("null");
            }
        }

![image-20220408223355565][]

public class Test5 {
        
        @Test
        public void test03(){
        
            Optional<Employee> op = Optional.ofNullable(null);
            if (op.isPresent()) {
        
                System.out.println(op.get());
            }else {
        
                System.out.println("null");
            }
        }
    }

![image-20220408223517529][]

###### (5)orElse ######

orElse(T t)：如果调用对象包含值，返回该值，否则返回 t

public class Test5 {
        
        @Test
        public void test03(){
        
            Optional<Employee> op = Optional.ofNullable(new Employee());
    
            Employee employee = op.orElse(new Employee(101, "张三", 19, 9999.99));
            System.out.println(employee);
        }
    }

![image-20220408223947193][]

public class Test5 {
        
        @Test
        public void test03(){
        
            Optional<Employee> op = Optional.ofNullable(null);
    
            Employee employee = op.orElse(new Employee(101, "张三", 19, 9999.99));
            System.out.println(employee);
        }
    }

![image-20220408224032199][]

###### (6)orElseGet ######

orElseGet(Supplier s)：如果调用对象包含值，返回该值，否则返回 s 获取的值

public class Test5 {
        
        @Test
        public void test03(){
        
            Optional<Employee> op = Optional.ofNullable(null);
    
            Employee employee = op.orElseGet(()->new Employee());
    
            System.out.println(employee);
        }
    }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2Gotdzf9-1649521532207)(https://gitee.com/yan-chaochao/typora-library/raw/master/typora-library/image-20220408224508823.png)\]

###### (7)map ######

map(Function f)：如果有值对其处理，并返回处理后的 Optional，否则返回 Optional.empty()

public class Test5 {
        
        @Test
        public void test03(){
        
            Optional<Employee> op = Optional.ofNullable(new Employee(101, "张三", 19, 9999.99));
    
            Optional<String> str = op.map((e -> e.getName()));
            System.out.println(str);
        }
    }

![image-20220408224753512][]

###### (8)flatmap ######

flatmap(Function mapper)：与 map 相似，要求返回值必须是 Optional

public class Test5 {
        
        @Test
        public void test03(){
        
            Optional<Employee> op = Optional.ofNullable(new Employee(101, "张三", 19, 9999.99));
    
            Optional <String> str =  op.flatMap((e -> Optional.of(e.getName())));
            System.out.println(str);
        }
    }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q7CIqzZc-1649521532208)(https://gitee.com/yan-chaochao/typora-library/raw/master/typora-library/image-20220408225128991.png)\]

--------------------

## 九.接口 ##

### 默认方法 ###

public interface MyFun {
        
    
        default String getName(){
        
            return "libo";
        }
    
        default Integer getAge(){
        
            return 22;
        }
    }

类优先原则：

![image-20220409002711843][]

### 静态方法 ###

public interface MyFun {
    
        static void getAddr(){
            System.out.println("addr");
        }
    
        static String Hello(){
            return "Hello World";
        }
    }

--------------------

## 十.新时间日期API ##

### 1.与传统日期处理的转换 ###

传统的日期格式化：

public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            Callable<Date> task = new Callable<Date>() {
        
                @Override
                public Date call() throws Exception {
        
                    return DateFormatThreadLocal.convert("20161218");
                }
            };
            ExecutorService pool = Executors.newFixedThreadPool(10);
    
            List<Future<Date>> result = new ArrayList<>();
            for (int i = 0; i < 10; i++) {
        
                result.add(pool.submit(task));
            }
    
            for (Future<Date> future : result) {
        
    
                System.out.println(future.get());
    
            }
        }

程序运行报错

解决方法：

上锁：

public class Test5 {
        
    
        public class DateFormatThreadLocal {
        
            private static final ThreadLocal<DateFormat> df = new ThreadLocal<DateFormat>(){
        
                protected DateFormat initialValue(){
        
                    return new SimpleDateFormat("yyyyMMdd");
                }
            };
    
            public static Date convert(String source) throws ParseException{
        
                return df.get().parse(source);
            }
        }
        
        
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            Callable<Date> task = new Callable<Date>() {
        
                @Override
                public Date call() throws Exception {
        
                    return DateFormatThreadLocal.convert("20161218");
                }
            };
            ExecutorService pool = Executors.newFixedThreadPool(10);
    
            List<Future<Date>> result = new ArrayList<>();
            for (int i = 0; i < 10; i++) {
        
                result.add(pool.submit(task));
            }
    
            for (Future<Date> future : result) {
        
    
                System.out.println(future.get());
    
            }
        }
    }

![image-20220409010703681][]

Java8DataTimeFormatter：

public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyyMMdd");
    
            Callable<LocalDate> task = new Callable<LocalDate>() {
        
    
                @Override
                public LocalDate call()throws ExecutionException {
        
                    return LocalDate.parse("20161218",dtf);
                }
            };
            ExecutorService pool = Executors.newFixedThreadPool(10);
    
            List<Future<LocalDate>> result = new ArrayList<>();
            for (int i = 0; i < 10; i++) {
        
                result.add(pool.submit(task));
            }
            for (Future<LocalDate> future : result) {
        
    
                System.out.println(future.get());
            }
            pool.shutdown();
        }

![image-20220409013216324][]

### 2.使用LocalDate、LocalTime、LocalDateTime ###

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

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

![image-20220409013416695][]

#### (1)获取当前时间 ####

@Test
        public void test1(){
        
            LocalDateTime dateTime = LocalDateTime.now();
            System.out.println(dateTime);
        }

结果：

2022-04-09T23:04:33.948455500

#### (2)时间加减运算 ####

加：

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5KRdtdB7-1649521532209)(https://gitee.com/yan-chaochao/typora-library/raw/master/typora-library/image-20220409230746965.png)\]

@Test
        public void test1(){
            LocalDateTime dateTime = LocalDateTime.now();
            System.out.println(dateTime);
            LocalDateTime dateTime1 = dateTime.plusYears(2);
            System.out.println(dateTime1);
        }

![image-20220409230830807][]

减：

![image-20220409230921786][]

@Test
        public void test1(){
        
            LocalDateTime dateTime = LocalDateTime.now();
            System.out.println(dateTime);
            LocalDateTime dateTime1 = dateTime.minusYears(2);
            System.out.println(dateTime1);
        }

![image-20220409230953898][]

#### (3)获取年 月 时 分 秒 ####

![image-20220409231124588][]

@Test
        public void test1(){
        
            LocalDateTime dateTime = LocalDateTime.now();
            System.out.println(dateTime);
            //获取年
            System.out.println(dateTime.getYear());
            //获取月（英语）
            System.out.println(dateTime.getMonth());
            //获取今年的已过天数
            System.out.println(dateTime.getDayOfYear());
            //获取今天月份的值
            System.out.println(dateTime.getMonthValue());
            //获取小时
            System.out.println(dateTime.getHour());
            //获取分
            System.out.println(dateTime.getMinute());
            //获取秒
            System.out.println(dateTime.getSecond());
        }
    }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LWA89GeP-1649521532211)(https://gitee.com/yan-chaochao/typora-library/raw/master/typora-library/image-20220409231718228.png)\]

![image-20220409231935311][]

### 3.Instant时间戳 ###

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

@Test
        public void test1(){
        
            Instant instant = Instant.now();//默认获取UTC时区
            System.out.println(instant);
    
            OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
            System.out.println(offsetDateTime);
    
            System.out.println("时间戳："+instant.toEpochMilli());
        }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8mDYYr3r-1649521532211)(https://gitee.com/yan-chaochao/typora-library/raw/master/typora-library/image-20220409235313519.png)\]

### 4.Duration:用于计算两个“时间”间隔 ###

public class Test5 {
        @Test
        public void test1()  {
            Instant instant = Instant.now();//默认获取UTC时区
            //系统等待1000毫秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
    
            }
    
            Instant instant1 = Instant.now();
    
            Duration duration = Duration.between(instant,instant1);
            //精确到毫秒
            System.out.println(duration);
            //精确到天
            System.out.println(duration.toDays());
    
    
            LocalTime localTime = LocalTime.now();
    
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
    
            LocalTime localTime1 = LocalTime.now();
    
          System.out.println(Duration.between(localTime,localTime1).toMillis());
        }
    }

![image-20220410000319689][]

### 5. Period:用于计算两个“日期”间隔 ###

@Test
        public void test1()  {
        
           LocalDate localDate = LocalDate.of(2015,1,1);
           LocalDate localDate1 = LocalDate.now();
           Period period = Period.between(localDate,localDate1);
           System.out.println(period);
           System.out.println(period.getYears());
        }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gz4nwKDf-1649521532212)(https://gitee.com/yan-chaochao/typora-library/raw/master/typora-library/image-20220410000610842.png)\]

### 6.日期的操纵 ###

#### (1)时间校正器 ####

TemporalAdjuster : 时间校正器。有时我们可能需要获取例如：将日期调整到“下个周日”等操作。

TemporalAdjusters: 该类通过静态方法提供了大量的常用 TemporalAdjuster 的实现。

例如获取下个周日：

![image-20220410000809620][]

@Test
        public void test01(){
        
            //TemporalAdjusters：时间校正器
            LocalDateTime ldt1 = LocalDateTime.now();
            System.out.println(ldt1);
    
            //指定日期时间中的 年 月 日 ...
            LocalDateTime ldt2 = ldt1.withDayOfMonth(10);
            System.out.println(ldt2);
    
            //指定时间校正器
            LocalDateTime ldt3 = ldt1.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));
            System.out.println(ldt3);
    
            //自定义时间校正器
            LocalDateTime ldt5 = ldt1.with((ta) -> {
        
                LocalDateTime ldt4 = (LocalDateTime) ta;
                DayOfWeek dow1 = ldt4.getDayOfWeek();
                if (dow1.equals(DayOfWeek.FRIDAY)) {
        
                    return ldt4.plusDays(3);
                } else if (dow1.equals(DayOfWeek.SATURDAY)) {
        
                    return ldt4.plusDays(2);
                } else {
        
                    return ldt4.plusDays(1);
                }
            });
            System.out.println(ldt5);
        }

![image-20220410000920523][]

### 7.时间格式化 ###

java.time.format.DateTimeFormatter类：该类提供了三种

格式化方法：

⚫ 预定义的标准格式

⚫ 语言环境相关的格式

⚫ 自定义的格式

@Test
        public void test01(){
        
            //默认格式化
            DateTimeFormatter dtf1 = DateTimeFormatter.ISO_DATE_TIME;
            LocalDateTime ldt1 = LocalDateTime.now();
            String str1 = ldt1.format(dtf1);
            System.out.println(str1);
    
            //自定义格式化 ofPattern
            DateTimeFormatter dtf2 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            LocalDateTime ldt2 = LocalDateTime.now();
            String str2 = ldt2.format(dtf2);
            System.out.println(str2);
    
            //解析
            LocalDateTime newDate = ldt1.parse(str1, dtf1);
            System.out.println(newDate);
        }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YmZqTqXf-1649521532213)(https://gitee.com/yan-chaochao/typora-library/raw/master/typora-library/image-20220410001413337.png)\]

### 8.时区的处理 ###

Java8 中加入了对时区的支持，带时区的时间为分别为：ZonedDate、ZonedTime、ZonedDateTime其中每个时区都对应着 ID，地区ID都为 “\{区域\}/\{城市\}”的格式

例如 ：Asia/Shanghai 等

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

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

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

@Test
        public void test02(){
        
            //查看支持的时区
            Set<String> set = ZoneId.getAvailableZoneIds();
            set.forEach(System.out::println);
    
            //指定时区
            LocalDateTime ldt1 = LocalDateTime.now(ZoneId.of("Europe/Tallinn"));
            System.out.println(ldt1);
    
            //在已构建好的日期时间上指定时区
            LocalDateTime ldt2 = LocalDateTime.now(ZoneId.of("Europe/Tallinn"));
            ZonedDateTime zdt1 = ldt2.atZone(ZoneId.of("Europe/Tallinn"));
            System.out.println(zdt1);
        }

结果：

Asia/Aden
    America/Cuiaba
    Etc/GMT+9
    Etc/GMT+8
    Africa/Nairobi
    America/Marigot
    Asia/Aqtau
    Pacific/Kwajalein
    America/El_Salvador
    Asia/Pontianak
    Africa/Cairo
    Pacific/Pago_Pago
    Africa/Mbabane
    Asia/Kuching
    Pacific/Honolulu
    Pacific/Rarotonga
    America/Guatemala
    Australia/Hobart
    Europe/London
    America/Belize
    America/Panama
    Asia/Chungking
    America/Managua
    America/Indiana/Petersburg
    Asia/Yerevan
    Europe/Brussels
    GMT
    Europe/Warsaw
    America/Chicago
    Asia/Kashgar
    Chile/Continental
    Pacific/Yap
    CET
    Etc/GMT-1
    Etc/GMT-0
    Europe/Jersey
    America/Tegucigalpa
    Etc/GMT-5
    Europe/Istanbul
    America/Eirunepe
    Etc/GMT-4
    America/Miquelon
    Etc/GMT-3
    Europe/Luxembourg
    Etc/GMT-2
    Etc/GMT-9
    America/Argentina/Catamarca
    Etc/GMT-8
    Etc/GMT-7
    Etc/GMT-6
    Europe/Zaporozhye
    Canada/Yukon
    Canada/Atlantic
    Atlantic/St_Helena
    Australia/Tasmania
    Libya
    Europe/Guernsey
    America/Grand_Turk
    Asia/Samarkand
    America/Argentina/Cordoba
    Asia/Phnom_Penh
    Africa/Kigali
    Asia/Almaty
    US/Alaska
    Asia/Dubai
    Europe/Isle_of_Man
    America/Araguaina
    Cuba
    Asia/Novosibirsk
    America/Argentina/Salta
    Etc/GMT+3
    Africa/Tunis
    Etc/GMT+2
    Etc/GMT+1
    Pacific/Fakaofo
    Africa/Tripoli
    Etc/GMT+0
    Israel
    Africa/Banjul
    Etc/GMT+7
    Indian/Comoro
    Etc/GMT+6
    Etc/GMT+5
    Etc/GMT+4
    Pacific/Port_Moresby
    US/Arizona
    Antarctica/Syowa
    Indian/Reunion
    Pacific/Palau
    Europe/Kaliningrad
    America/Montevideo
    Africa/Windhoek
    Asia/Karachi
    Africa/Mogadishu
    Australia/Perth
    Brazil/East
    Etc/GMT
    Asia/Chita
    Pacific/Easter
    Antarctica/Davis
    Antarctica/McMurdo
    Asia/Macao
    America/Manaus
    Africa/Freetown
    Europe/Bucharest
    Asia/Tomsk
    America/Argentina/Mendoza
    Asia/Macau
    Europe/Malta
    Mexico/BajaSur
    Pacific/Tahiti
    Africa/Asmera
    Europe/Busingen
    America/Argentina/Rio_Gallegos
    Africa/Malabo
    Europe/Skopje
    America/Catamarca
    America/Godthab
    Europe/Sarajevo
    Australia/ACT
    GB-Eire
    Africa/Lagos
    America/Cordoba
    Europe/Rome
    Asia/Dacca
    Indian/Mauritius
    Pacific/Samoa
    America/Regina
    America/Fort_Wayne
    America/Dawson_Creek
    Africa/Algiers
    Europe/Mariehamn
    America/St_Johns
    America/St_Thomas
    Europe/Zurich
    America/Anguilla
    Asia/Dili
    America/Denver
    Africa/Bamako
    Europe/Saratov
    GB
    Mexico/General
    Pacific/Wallis
    Europe/Gibraltar
    Africa/Conakry
    Africa/Lubumbashi
    Asia/Istanbul
    America/Havana
    NZ-CHAT
    Asia/Choibalsan
    America/Porto_Acre
    Asia/Omsk
    Europe/Vaduz
    US/Michigan
    Asia/Dhaka
    America/Barbados
    Europe/Tiraspol
    Atlantic/Cape_Verde
    Asia/Yekaterinburg
    America/Louisville
    Pacific/Johnston
    Pacific/Chatham
    Europe/Ljubljana
    America/Sao_Paulo
    Asia/Jayapura
    America/Curacao
    Asia/Dushanbe
    America/Guyana
    America/Guayaquil
    America/Martinique
    Portugal
    Europe/Berlin
    Europe/Moscow
    Europe/Chisinau
    America/Puerto_Rico
    America/Rankin_Inlet
    Pacific/Ponape
    Europe/Stockholm
    Europe/Budapest
    America/Argentina/Jujuy
    Australia/Eucla
    Asia/Shanghai
    Universal
    Europe/Zagreb
    America/Port_of_Spain
    Europe/Helsinki
    Asia/Beirut
    Asia/Tel_Aviv
    Pacific/Bougainville
    US/Central
    Africa/Sao_Tome
    Indian/Chagos
    America/Cayenne
    Asia/Yakutsk
    Pacific/Galapagos
    Australia/North
    Europe/Paris
    Africa/Ndjamena
    Pacific/Fiji
    America/Rainy_River
    Indian/Maldives
    Australia/Yancowinna
    SystemV/AST4
    Asia/Oral
    America/Yellowknife
    Pacific/Enderbury
    America/Juneau
    Australia/Victoria
    America/Indiana/Vevay
    Asia/Tashkent
    Asia/Jakarta
    Africa/Ceuta
    Asia/Barnaul
    America/Recife
    America/Buenos_Aires
    America/Noronha
    America/Swift_Current
    Australia/Adelaide
    America/Metlakatla
    Africa/Djibouti
    America/Paramaribo
    Asia/Qostanay
    Europe/Simferopol
    Europe/Sofia
    Africa/Nouakchott
    Europe/Prague
    America/Indiana/Vincennes
    Antarctica/Mawson
    America/Kralendijk
    Antarctica/Troll
    Europe/Samara
    Indian/Christmas
    America/Antigua
    Pacific/Gambier
    America/Indianapolis
    America/Inuvik
    America/Iqaluit
    Pacific/Funafuti
    UTC
    Antarctica/Macquarie
    Canada/Pacific
    America/Moncton
    Africa/Gaborone
    Pacific/Chuuk
    Asia/Pyongyang
    America/St_Vincent
    Asia/Gaza
    Etc/Universal
    PST8PDT
    Atlantic/Faeroe
    Asia/Qyzylorda
    Canada/Newfoundland
    America/Kentucky/Louisville
    America/Yakutat
    Asia/Ho_Chi_Minh
    Antarctica/Casey
    Europe/Copenhagen
    Africa/Asmara
    Atlantic/Azores
    Europe/Vienna
    ROK
    Pacific/Pitcairn
    America/Mazatlan
    Australia/Queensland
    Pacific/Nauru
    Europe/Tirane
    Asia/Kolkata
    SystemV/MST7
    Australia/Canberra
    MET
    Australia/Broken_Hill
    Europe/Riga
    America/Dominica
    Africa/Abidjan
    America/Mendoza
    America/Santarem
    Kwajalein
    America/Asuncion
    Asia/Ulan_Bator
    NZ
    America/Boise
    Australia/Currie
    EST5EDT
    Pacific/Guam
    Pacific/Wake
    Atlantic/Bermuda
    America/Costa_Rica
    America/Dawson
    Asia/Chongqing
    Eire
    Europe/Amsterdam
    America/Indiana/Knox
    America/North_Dakota/Beulah
    Africa/Accra
    Atlantic/Faroe
    Mexico/BajaNorte
    America/Maceio
    Etc/UCT
    Pacific/Apia
    GMT0
    America/Atka
    Pacific/Niue
    Australia/Lord_Howe
    Europe/Dublin
    Pacific/Truk
    MST7MDT
    America/Monterrey
    America/Nassau
    America/Jamaica
    Asia/Bishkek
    America/Atikokan
    Atlantic/Stanley
    Australia/NSW
    US/Hawaii
    SystemV/CST6
    Indian/Mahe
    Asia/Aqtobe
    America/Sitka
    Asia/Vladivostok
    Africa/Libreville
    Africa/Maputo
    Zulu
    America/Kentucky/Monticello
    Africa/El_Aaiun
    Africa/Ouagadougou
    America/Coral_Harbour
    Pacific/Marquesas
    Brazil/West
    America/Aruba
    America/North_Dakota/Center
    America/Cayman
    Asia/Ulaanbaatar
    Asia/Baghdad
    Europe/San_Marino
    America/Indiana/Tell_City
    America/Tijuana
    Pacific/Saipan
    SystemV/YST9
    Africa/Douala
    America/Chihuahua
    America/Ojinaga
    Asia/Hovd
    America/Anchorage
    Chile/EasterIsland
    America/Halifax
    Antarctica/Rothera
    America/Indiana/Indianapolis
    US/Mountain
    Asia/Damascus
    America/Argentina/San_Luis
    America/Santiago
    Asia/Baku
    America/Argentina/Ushuaia
    Atlantic/Reykjavik
    Africa/Brazzaville
    Africa/Porto-Novo
    America/La_Paz
    Antarctica/DumontDUrville
    Asia/Taipei
    Antarctica/South_Pole
    Asia/Manila
    Asia/Bangkok
    Africa/Dar_es_Salaam
    Poland
    Atlantic/Madeira
    Antarctica/Palmer
    America/Thunder_Bay
    Africa/Addis_Ababa
    Asia/Yangon
    Europe/Uzhgorod
    Brazil/DeNoronha
    Asia/Ashkhabad
    Etc/Zulu
    America/Indiana/Marengo
    America/Creston
    America/Punta_Arenas
    America/Mexico_City
    Antarctica/Vostok
    Asia/Jerusalem
    Europe/Andorra
    US/Samoa
    PRC
    Asia/Vientiane
    Pacific/Kiritimati
    America/Matamoros
    America/Blanc-Sablon
    Asia/Riyadh
    Iceland
    Pacific/Pohnpei
    Asia/Ujung_Pandang
    Atlantic/South_Georgia
    Europe/Lisbon
    Asia/Harbin
    Europe/Oslo
    Asia/Novokuznetsk
    CST6CDT
    Atlantic/Canary
    America/Knox_IN
    Asia/Kuwait
    SystemV/HST10
    Pacific/Efate
    Africa/Lome
    America/Bogota
    America/Menominee
    America/Adak
    Pacific/Norfolk
    Europe/Kirov
    America/Resolute
    Pacific/Tarawa
    Africa/Kampala
    Asia/Krasnoyarsk
    Greenwich
    SystemV/EST5
    America/Edmonton
    Europe/Podgorica
    Australia/South
    Canada/Central
    Africa/Bujumbura
    America/Santo_Domingo
    US/Eastern
    Europe/Minsk
    Pacific/Auckland
    Africa/Casablanca
    America/Glace_Bay
    Canada/Eastern
    Asia/Qatar
    Europe/Kiev
    Singapore
    Asia/Magadan
    SystemV/PST8
    America/Port-au-Prince
    Europe/Belfast
    America/St_Barthelemy
    Asia/Ashgabat
    Africa/Luanda
    America/Nipigon
    Atlantic/Jan_Mayen
    Brazil/Acre
    Asia/Muscat
    Asia/Bahrain
    Europe/Vilnius
    America/Fortaleza
    Etc/GMT0
    US/East-Indiana
    America/Hermosillo
    America/Cancun
    Africa/Maseru
    Pacific/Kosrae
    Africa/Kinshasa
    Asia/Kathmandu
    Asia/Seoul
    Australia/Sydney
    America/Lima
    Australia/LHI
    America/St_Lucia
    Europe/Madrid
    America/Bahia_Banderas
    America/Montserrat
    Asia/Brunei
    America/Santa_Isabel
    Canada/Mountain
    America/Cambridge_Bay
    Asia/Colombo
    Australia/West
    Indian/Antananarivo
    Australia/Brisbane
    Indian/Mayotte
    US/Indiana-Starke
    Asia/Urumqi
    US/Aleutian
    Europe/Volgograd
    America/Lower_Princes
    America/Vancouver
    Africa/Blantyre
    America/Rio_Branco
    America/Danmarkshavn
    America/Detroit
    America/Thule
    Africa/Lusaka
    Asia/Hong_Kong
    Iran
    America/Argentina/La_Rioja
    Africa/Dakar
    SystemV/CST6CDT
    America/Tortola
    America/Porto_Velho
    Asia/Sakhalin
    Etc/GMT+10
    America/Scoresbysund
    Asia/Kamchatka
    Asia/Thimbu
    Africa/Harare
    Etc/GMT+12
    Etc/GMT+11
    Navajo
    America/Nome
    Europe/Tallinn
    Turkey
    Africa/Khartoum
    Africa/Johannesburg
    Africa/Bangui
    Europe/Belgrade
    Jamaica
    Africa/Bissau
    Asia/Tehran
    WET
    Europe/Astrakhan
    Africa/Juba
    America/Campo_Grande
    America/Belem
    Etc/Greenwich
    Asia/Saigon
    America/Ensenada
    Pacific/Midway
    America/Jujuy
    Africa/Timbuktu
    America/Bahia
    America/Goose_Bay
    America/Virgin
    America/Pangnirtung
    Asia/Katmandu
    America/Phoenix
    Africa/Niamey
    America/Whitehorse
    Pacific/Noumea
    Asia/Tbilisi
    America/Montreal
    Asia/Makassar
    America/Argentina/San_Juan
    Hongkong
    UCT
    Asia/Nicosia
    America/Indiana/Winamac
    SystemV/MST7MDT
    America/Argentina/ComodRivadavia
    America/Boa_Vista
    America/Grenada
    Asia/Atyrau
    Australia/Darwin
    Asia/Khandyga
    Asia/Kuala_Lumpur
    Asia/Famagusta
    Asia/Thimphu
    Asia/Rangoon
    Europe/Bratislava
    Asia/Calcutta
    America/Argentina/Tucuman
    Asia/Kabul
    Indian/Cocos
    Japan
    Pacific/Tongatapu
    America/New_York
    Etc/GMT-12
    Etc/GMT-11
    America/Nuuk
    Etc/GMT-10
    SystemV/YST9YDT
    Europe/Ulyanovsk
    Etc/GMT-14
    Etc/GMT-13
    W-SU
    America/Merida
    EET
    America/Rosario
    Canada/Saskatchewan
    America/St_Kitts
    Arctic/Longyearbyen
    America/Fort_Nelson
    America/Caracas
    America/Guadeloupe
    Asia/Hebron
    Indian/Kerguelen
    SystemV/PST8PDT
    Africa/Monrovia
    Asia/Ust-Nera
    Egypt
    Asia/Srednekolymsk
    America/North_Dakota/New_Salem
    Asia/Anadyr
    Australia/Melbourne
    Asia/Irkutsk
    America/Shiprock
    America/Winnipeg
    Europe/Vatican
    Asia/Amman
    Etc/UTC
    SystemV/AST4ADT
    Asia/Tokyo
    America/Toronto
    Asia/Singapore
    Australia/Lindeman
    America/Los_Angeles
    SystemV/EST5EDT
    Pacific/Majuro
    America/Argentina/Buenos_Aires
    Europe/Nicosia
    Pacific/Guadalcanal
    Europe/Athens
    US/Pacific
    Europe/Monaco
    2022-04-09T19:15:34.387271300
    2022-04-09T19:15:34.388271900+03:00[Europe/Tallinn]
    
    ===============================================
    Default Suite
    Total tests run: 1, Passes: 1, Failures: 0, Skips: 0
    ===============================================
    
    
    进程已结束,退出代码0

与传统日期处理的转换

![image-20220410001702808][]

@Test
        public void test03(){
        
            // Date 转 LocalDateTime 
            Date date = new Date();
            Instant instant = date.toInstant();
            ZoneId zoneId = ZoneId.systemDefault();
            LocalDateTime localDateTime = instant.atZone(zoneId).toLocalDateTime();
    
            // LocalDateTime 转 Date
            LocalDateTime localDateTime = LocalDateTime.now();
            ZoneId zoneId = ZoneId.systemDefault();
            ZonedDateTime zdt = localDateTime.atZone(zoneId);
            Date date = Date.from(zdt.toInstant());
    
            // 原则：利用 时间戳Instant
        }

--------------------

### 十一.重复注解与类型注解 ###

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

型的注解。

![image-20220410002256434][]

### 重复注解 ###

定义注解：

@Repeatable(MyAnnotations.class) //指定容器类
    @Target({
        ElementType.TYPE, ElementType.METHOD,  ElementType.FIELD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyAnnotation {
        
        String value() default "Java 8";
    }

定义容器：

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

@Test：
    public class Test01 {
        
        //重复注解
        @Test
        @MyAnnotation("Hello")
        @MyAnnotation("World")
        public void test01() throws NoSuchMethodException {
        
            Class<Test01> clazz = Test01.class;
            Method test01 = clazz.getMethod("test01");
            MyAnnotation[] mas = test01.getAnnotationsByType(MyAnnotation.class);
            for (MyAnnotation ma : mas) {
        
                System.out.println(ma.value());
            }
        }

### 类型注解 ###

Java 8 新增注解：新增ElementType.TYPE\_USE 和ElementType.TYPE\_PARAMETER（在Target上）

[image-20220406195554023]: https://img-blog.csdnimg.cn/img_convert/60250c35fdc4161eb68cb85182755080.png
[image-20220406195612370]: https://img-blog.csdnimg.cn/img_convert/976d3834966508286b9738ad5cad5999.png
[image-20220406195904706]: https://img-blog.csdnimg.cn/img_convert/3bd69fb96327674ef71a753167f55b3f.png
[image-20220406195912217]: https://img-blog.csdnimg.cn/img_convert/9fb6ac7c3bc29d56155a99d021affb0e.png
[image-20220406195916325]: https://img-blog.csdnimg.cn/img_convert/7b4fa07e4aa3c00f1e60466df4e10f54.png
[image-20220406200219387]: https://img-blog.csdnimg.cn/img_convert/55a1f66f77ec5d934fc17d2edf406016.png
[image-20220406200641777]: https://img-blog.csdnimg.cn/img_convert/d2cba46c51fa5c6124179664bcbd4dba.png
[image-20220406200857587]: https://img-blog.csdnimg.cn/img_convert/595d6189788e452c3fa8b6fb83f61bc6.png
[image-20220406193815767]: https://img-blog.csdnimg.cn/img_convert/2c86b4695947fe948b7ae4d195a0019e.png
[image-20220406202250800]: https://img-blog.csdnimg.cn/img_convert/932a37d3641128adc06f4466579cacbf.png
[image-20220406202809121]: https://img-blog.csdnimg.cn/img_convert/001bb7b2e211aec0d2fad95a27137331.png
[image-20220406203052718]: https://img-blog.csdnimg.cn/img_convert/153e2b0c62d31ba8da8ffa8ab12d593e.png
[image-20220406204316191]: https://img-blog.csdnimg.cn/img_convert/969eb4871d87c1be3d79fa9f509e2707.png
[image-20220406205344089]: https://img-blog.csdnimg.cn/img_convert/706c2e25a74e2ae3a4bc79b125aff810.png
[image-20220406221201511]: https://img-blog.csdnimg.cn/img_convert/24b702c42a175f9a16497cacefb293bd.png
[image-20220406221426478]: https://img-blog.csdnimg.cn/img_convert/e579f7a6b64b9cf8f4096faa4fc11d66.png
[image-20220407143349256]: https://img-blog.csdnimg.cn/img_convert/a7f54d8311e275b9d24cd70523df79e5.png
[image-20220407153100700]: https://img-blog.csdnimg.cn/img_convert/e9a34fdccdf6d8798297d101ec771dac.png
[image-20220407153632420]: https://img-blog.csdnimg.cn/img_convert/6213ae81ac81fc3c44ec52e375d419e3.png
[image-20220407181241062]: https://img-blog.csdnimg.cn/img_convert/90f3809acddbe6c1e244173dacfeebb1.png
[image-20220407181248504]: https://img-blog.csdnimg.cn/img_convert/2f665f6c5c344c104e71920a671667ce.png
[image-20220407182455717]: https://img-blog.csdnimg.cn/img_convert/20e5ffb0b54629239a0c51233be14aa2.png
[image-20220407181824196]: https://img-blog.csdnimg.cn/img_convert/1603ecfb982d19e197f6d6f22b357da0.png
[image-20220407205358891]: https://img-blog.csdnimg.cn/img_convert/713760bf156603ff5167c213ec6d2110.png
[image-20220407205538690]: https://img-blog.csdnimg.cn/img_convert/7df41e144d6c2478c36afcc5b79d7129.png
[image-20220408201716783]: https://img-blog.csdnimg.cn/img_convert/4713141fc93da6113506221d7f07f532.png
[image-20220408202444646]: https://img-blog.csdnimg.cn/img_convert/39c1ef8e375423cbf54040a11d9d95b9.png
[image-20220408202854330]: https://img-blog.csdnimg.cn/img_convert/ff5a4c965205a64226cb066ee424e265.png
[image-20220408202936556]: https://img-blog.csdnimg.cn/img_convert/4e08276b4d12dd0e2b4a9b4b465c3856.png
[image-20220408204001619]: https://img-blog.csdnimg.cn/img_convert/927614af51eb56b4ee2e774520a56ffd.png
[image-20220408204244339]: https://img-blog.csdnimg.cn/img_convert/b854ca07bda5c24ece8c2848f3fe0182.png
[image-20220408204458941]: https://img-blog.csdnimg.cn/img_convert/e83a558da4b8aac15695cc9bbb7283ca.png
[image-20220408210121540]: https://img-blog.csdnimg.cn/img_convert/9da01f22cb817cb57d1a9f41ef30a228.png
[image-20220408210207770]: https://img-blog.csdnimg.cn/img_convert/d3f858945a6a558875ef6db0f2fdc5a3.png
[image-20220408212059515]: https://img-blog.csdnimg.cn/img_convert/d364685562df95c254c8ece09fcd1c2d.png
[image-20220408222527897]: https://img-blog.csdnimg.cn/img_convert/d6132feca5c4a7163083f031d6a7334d.png
[image-20220408223355565]: https://img-blog.csdnimg.cn/img_convert/d47d3da20fa3055c795ec7758af3c376.png
[image-20220408223517529]: https://img-blog.csdnimg.cn/img_convert/b18f8cc98ec44204aee98302863b07b3.png
[image-20220408223947193]: https://img-blog.csdnimg.cn/img_convert/a2a0caa8d4ba16a085fc7f824fc7e662.png
[image-20220408224032199]: https://img-blog.csdnimg.cn/img_convert/0967302779f03ddf9b81518a1d1b3b66.png
[image-20220408224753512]: https://img-blog.csdnimg.cn/img_convert/2f6f4c2011424dfc07b48fc0020e7856.png
[image-20220409002711843]: https://img-blog.csdnimg.cn/img_convert/46ad52dd3f375960db0914f2dbbb3ab3.png
[image-20220409010703681]: https://img-blog.csdnimg.cn/img_convert/68de350ca396e0ea342faabad5b6957c.png
[image-20220409013216324]: https://img-blog.csdnimg.cn/img_convert/f0047aff46bd771e9a7b1b4b7ac75993.png
[image-20220409013416695]: https://img-blog.csdnimg.cn/img_convert/2c7fe440d1b887c0e2529c031fac5036.png
[image-20220409230830807]: https://img-blog.csdnimg.cn/img_convert/51ef7479a7e1579228c993c3917c7f71.png
[image-20220409230921786]: https://img-blog.csdnimg.cn/img_convert/5b0fb497a8834ccb740efa7ff9df7eb2.png
[image-20220409230953898]: https://img-blog.csdnimg.cn/img_convert/08ed3087380a39a03d7ef5472df13304.png
[image-20220409231124588]: https://img-blog.csdnimg.cn/img_convert/23d6fd1ac731b92c9509db133d0aef91.png
[image-20220409231935311]: https://img-blog.csdnimg.cn/img_convert/d97822258433da93ad1083e6fe46c60d.png
[image-20220410000319689]: https://img-blog.csdnimg.cn/img_convert/f932763052a2e8483dedac299adbda71.png
[image-20220410000809620]: https://img-blog.csdnimg.cn/img_convert/0e82d7e4b93babc0f351b004355e7aac.png
[image-20220410000920523]: https://img-blog.csdnimg.cn/img_convert/c7ba6d8b5f58abccfbc16844ff974c96.png
[image-20220410001702808]: https://img-blog.csdnimg.cn/img_convert/41f6eebab018991758f8bff4f15345a7.png
[image-20220410002256434]: https://img-blog.csdnimg.cn/img_convert/0a8a5439741d4ffc195a3c153b77fc14.png