Java8新特性

一、Lambda表达式

Lambda表达式是一个匿名函数，可以理解为一段可以传递的代码。

new Thread(()->{
            System.out.println("线程Lambda表达式"+ Thread.currentThread().getName());
        }).start();

Lambda表达式的优点：简化了匿名内部类的使用，语法更加简单。
匿名内部类语法冗余，体验了Lambda表达式后，发现Lambda表达式是简化匿名内部类的一种方式。

1、语法规则

Lambda省去了面向对象的条条框框，Lambda的标准格式由三个部分组成：

	(参数类型:参数名称)->{
		代码体;
	}

格式说明：

• (参数类型:参数名称)：参数列表
• (代码体;)：方法体
• ->：箭头，分割参数列表和方法体

2、原理

匿名内部类的本质是在编译时生成一个Class文件。xxx$1.class

Lambda表达式在从程序运行的时候会形成一个类。
1、在类中新增了一个方法，这个方法的方法体就是Lambda表达式中的代码。
2、还会形成一个匿名内部类，实现接口，重写抽象方法。
3、在接口汇总重写方法会调用新生成的方法。

而写有Lambda表达式的class文件，无法通过反编译工具查看，需要通过jdk自带的一个工具：javap 对字节码进行反汇编操作。

javap -c -p 文件名.class

-c:表示对代码进行反汇编
-p:显示所有的类和成员

3、Lambda表达式的省略写法

在lambda表达式的标准写法基础上，可以使用省略写法的规则为：
1、小括号的参数类型可以省略
2、如果小括号内有且仅有一个参数，则小括号可以省略
3、如果大括号内有且仅有一个语句，可以同时省略大括号，return关键字及语句分号

4、Lambda表达式的适用前提

Lambda表达式的语法是非常简洁的，但是 Lambda表达式不是随便使用的，使用时有几个条件需要特别注意
1、方法的参数或局部变量类型必须为接口才能使用Lambda
2、接口中有且仅有一个抽象方法(@FunctionalInterface)

5、Lambda和匿名内部类的对比

Lambda和匿名内部类的对比

• 所需类型不一样
  1、匿名内部类的类型可以是类、抽象类、接口
  2、Lambda表达式需要的类型必须是接口
• 抽象方法的数量不一样
  1、匿名内部类所需要得接口中的抽象方法的数量是随意的
  2、Lambda表达式所需的接口中只能有一个抽象方法
• 实现原理不一样
  1、匿名内部类是在编译后形成一个class
  2、Lambda表达式是在程序运行的时候动态生成calss

二、函数式接口

1、Supplier

​ 无参有返回值的接口

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

2、Consumer

​ 有参无返回值的接口

@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);

3、Function

​ 有参有返回值的接口,Function接口是根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。有参数有返回值。

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);

4、Predicate

​ 有参，返回值为Boolean的接口

public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);

三、方法引用

1、方法引用的格式

符号表示：::

符号说明：双冒号为方法引用运算符，而它所在的表达式被称为方法引用

应用场景：如果Lambda表达式所要实现的方案，已经有其他方法存在相同的方案，那么则可以使用方法引用。

2、常见的引用方式

方法引用在JDK8中是相当灵活的，有以下几种方式：

2.1对象名::方法名

instanceNmae::methodName

这是最常见的一种用法。如果一个类中已经存在了一个成员方法，则可以通过对象名引用成员方法。

1. 被引用的方法，参数要和接口中的抽象方法的参数一样
2. 当接口抽象方法有返回值时，被引用的方法也必须有返回值

2.2类名::静态方法名

ClassName::staticMethodName

也是比较常用的方式。

2.3类名::普通方法(引用实例方法)

ClassName::methodNmae

Java面向对象中，类名只能调用静态方法，类名引用实例方法是有前提的，实际上是拿第一个参数作为方法的调用者。

2.4类名::构造器

ClassName::new 类名::new 调用的构造器

由于构造器的名称和类名完全一致，所以构造器引用使用::new

的格式。

2.5数组::构造器

TypeName[]::new String[]::new 调用数组的构造器

小结：方法引用是对Lambda表达式符合特定情况下的一种缩写形式，它使得我们的Lambda表达式更加的精简，也可以理解为Lambda表达式的缩写形式，不过要注意的是方法引用只能引用已经存在的方法。

​

四、Stream API

1、Stream流式思想概述

注意：Stream和IO流(InputStream/OutputStream)没有任何关系。

Stream流式思想类似于工厂车间的"生产流水线"，Stream流不是一种数据结构，不保存数据，而是对数据进行加工处理。Stream可以看作是流水线上的一个工序。在流水线上，通过多个工序让一个原材料加工成一个商品。

Stream API能让我们快速完成许多复杂的操作，如筛选、切片、映射、查找、去除重复、统计、匹配和归约。

2、Stream流获取方式

2.1 根据Collection获取

​ 首先，java.util.Collection接口中加入了default方法stream，也就是说collection接口下的所有的实现都可以通过Stream方法来获取Stream流。

public static void main(String[] args) {
    List<string> list = new ArrayList<>();
    list.stream();
    Set<string> set = new Hashset<>();
    set.stream();
    vector vector = new vector();
    vector.stream();
}

但是Map接口并没有实现Collection接口，这时我们可以根据Map获取对应的key value的集合。

public static void main(String[] args) {
    HashMap<Object, Object> map = new HashMap<>();
    Stream<Object> stream = map.keySet().stream();//key
    Stream<Object> stream1 = map.values().stream();//value
    Stream<Map.Entry<Object, Object>> stream2 = map.entrySet().stream();//entry
}

2.2 根据Stream的of方法

​ 在实际开发中我们不可避免的还是会操作到数组中的数据，由于数组对象不可能添加默认方法，所以Stream接口中提供了静态方法of。

public static void main(String[] args) {
    Stream<String> a1 = Stream.of("a1", "a2", "a3");
    String[] arr1= {"aa","bb","cc"};
    Stream<String> arr11 = Stream.of(arr1);
    Integer[] arr2 = {1,2,3,4};
    Stream<Integer> arr21 = Stream.of(arr2);
    arr21.forEach(System.out::println);

    //注意，基本数据类型的数组是不行的
    int[] arr3 = {1,2,3,4};
    Stream.of(arr3).forEach(System.out::println);
}

3、Stream常用方法介绍

Stream常用方法

Stream流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分成两种：

方法名	方法作用	返回值类型	方法种类
count	统计个数	long	终结
forEach	逐级处理	void	终结
filter	过滤	Stream	函数拼接
limit	取用前几个	Stream	函数拼接
skip	跳过前几个	Stream	函数拼接
map	映射	Stream	函数拼接
concat	组合	Stream	函数拼接

终结方法： 返回值类型不再是Stream类型的方法，不再支持链式调用。本小节中，终结方法包括count和forEach方法。

非终结方法： 返回值类型仍然是Stream类型的方法，支持链式调用。(除了终结方法外，区域方法均为非终结方法)

Stream注意事项(重要)

1. Stream只能操作一次
2. Stream方法返回的是新的流
3. Stream不调用终结方法，中间的操作不会执行

3.1 forEach

forEach用来遍历流中的数据的

void forEach(Consumer<? super T> action);

该方法接受一个Consumer接口，会将每一个流元素交给函数处理

public static void main(String[] args) {
    Stream.of("a1", "a2", "a3").forEach(System.out::println);;
}

3.2 count

Stream流中的count方法用来统计其中的元素个数

long count();

该方法返回一个long值，代表元素的个数

public static void main(String[] args) {
    System.out.println(Stream.of("a1", "a2", "a3").count());
}

3.3 filter

filter方法的作用是用来过滤数据的。返回符合条件的数据。可以通过filter方法将一个流转换成另一个子集流。

Stream<T> filter(Predicate<? super T> predicate);

该接口接受一个Predicate函数式接口参数作为筛选条件

public static void main(String[] args) {
    Stream.of("a1", "a2", "a3", "b1", "b2", "b3")
            .filter((s) -> s.contains("b"))
            .forEach(System.out::println);
}

输出：

b1
b2
b3

3.4 limit

limit方法可以对流进行截取处理，只取前n个数据

Stream<T> limit(long maxSize);

参数是一个long类型的数值，如果集合当前长度大于参数就进行截取，否则不操作：

public static void main(String[] args) {
    Stream.of("a1", "a2", "a3", "b1", "b2", "b3")
            .limit(5)
            .forEach(System.out::println);
}

输出：

a1
a2
a3
b1
b2

3.5 skip

如果希望跳过前面几个元素，可以使用skip方法获取一个截取之后的新流。

Stream<T> skip(long n);

操作：

public static void main(String[] args) {
        Stream.of("a1", "a2", "a3", "b1", "b2", "b3")
                .skip(3)
                .forEach(System.out::println);
    }

输出：

b1
b2
b3

3.6 map

如果我们需要将流中的元素映射到另一个流中，可以使用map方法：

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型数据。

public static void main(String[] args) {
        Stream.of("1", "2", "3", "4", "5", "6")
//                .map(msg -> Integer.parseInt(msg))效果等同于下面
                .map(Integer::parseInt)
                .forEach(System.out::println);
    }

3.7 sorted

如果需要将数据排序，可以使用sorted方法：

Stream<T> sorted();

在使用的时候可以根据自然规则排序，也可以通过比较器来指定对应的排序规则

public static void main(String[] args) {
        Stream.of("1", "22", "23", "2", "4", "6")
//                .map(msg -> Integer.parseInt(msg))效果等同于下面
                .map(Integer::parseInt)
//                .sorted()//根据数据的自然顺序排序
                .sorted((o1,o2) -> o2-o1)//根据比较器指定排序规则
                .forEach(System.out::println);
    }

3.8 distinct

如果要去掉重复数据，可以使用distinct方法：

Stream<T> distinct();

Stream流中的distinct方法对于基本数据类型是可以直接去重的，对于自定义类型，我们需要去重写hasCode和equals方法来移除重复元素。

public static void main(String[] args) {
        Stream.of("1", "22", "22", "2", "4", "6")
//                .map(msg -> Integer.parseInt(msg))效果等同于下面
                .map(Integer::parseInt)
//                .sorted()//根据数据的自然顺序排序
                .sorted((o1,o2) -> o2-o1)//根据比较器指定排序规则
                .distinct()//去掉重复的记录
                .forEach(System.out::println);
    }

3.9 reduce方法

如果需要将所有数据归纳得到一个数据，可以使用reduce方法

T reduce(T identity, BinaryOperator<T> acumulator);

使用：

public static void main(String[] args) {
        Integer sum = Stream.of(1, 2, 3, 4)
                //identity默认值
                //第一次的时候会将默认值赋给x
                //之后每次会将上一次的操作结果赋给x y就是每次从数据中获取的元素
                .reduce(0, (x, y) -> {
                    System.out.println("x=" + x + ",y=" + y);
                    return x + y;
                });
        System.out.println(sum);
        //获取最大值
        Integer max = Stream.of(1, 2, 3, 4)
                .reduce(0, (x, y) -> {
                    return x > y ? x : y;
                });
        System.out.println("最大值："+max);
    }

结果：

x=0,y=1
x=1,y=2
x=3,y=3
x=6,y=4
10
最大值：4

3.10 map和reduce的组合

在实际开发中，我们会将map和reduce一块使用

public static void main(String[] args) {
        Integer sumAge = Stream.of(
                        new Person("张三", 18),
                        new Person("李四", 19),
                        new Person("王五", 20),
                        new Person("赵六", 21)
//        ).map(p->p.getAge)
                ).map(Person::getAge)//实现数据类型转换，符合reduce对数据的要求
//                .reduce(0,(x,y)->x+y);
                .reduce(0, Integer::sum);//reduce实现数据的处理
        System.out.println(sumAge);
    }

3.11 mapTolnt

如果需要将Stream中的Integer类型转换为int类型，可以使用mapToInt方法

使用：

public static void main(String[] args) {
    //Integer比int占用的内存多很多，在Stream流操作中会自动装箱和拆箱操作
    Integer[] arr = {1,2,3,4,5,6,7,8};
    Stream.of(arr)
            .filter(i->i>0)
            .forEach(System.out::println);
    //为了提高代码的效率，我们可以先将流中Integer数据转换为int数据，然后再操作
    IntStream intStream = Stream.of(arr)
            .mapToInt(Integer::intValue);
    intStream.filter(i->i>3)
            .forEach(System.out::println);
}

3.12 concat

如果两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat

public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
    Objects.requireNonNull(a);
    Objects.requireNonNull(b);

    @SuppressWarnings("unchecked")
    Spliterator<T> split = new Streams.ConcatSpliterator.OfRef<>(
            (Spliterator<T>) a.spliterator(), (Spliterator<T>) b.spliterator());
    Stream<T> stream = StreamSupport.stream(split, a.isParallel() || b.isParallel());
    return stream.onClose(Streams.composedClose(a, b));
}

使用：

public static void main(String[] args) {
    Stream<String> stream1 = Stream.of("a", "b", "c");
    Stream<String> stream2 = Stream.of("x", "y", "z");
    //通过concat方法将两个流合并成为一个新的流
    Stream.concat(stream1,stream2).forEach(System.out::print);
}

输出：

abcxyz

4、例子

统计个数：list.stream().count

去重： .distinct()

遍历： .forEach(a-> System.out.println(a))

过滤： .filter

限制个数： .limit

跳过： .skip

map映射： .map(a->a+" ")

连接多个数组：Ints.concat()

list转字符串：Joiner.on(“,”).join()

map转字符串：Joiner.on(" , “).withKeyValueSeparator(” = ").join()

list转string：跳过 null：Joiner.on(“,”).skipNulls().join()

list转string：null变为其他值：Joiner.on(“,”).useForNull(“”).join()

根据-切割，将string转为list：Splitter.on(“-”).trimResults().splitToList()

string转为map：Splitter.on(“,”).withKeyValueSeparator(“=”).split()

多个字符进行分割：Splitter.onPattern(“[.|,]”)

每隔n字符进行分割：Splitter.fixedLength(n).splitToList()

取两个集合的并集并去重：listAll.stream().distinct().collect(toList())

List集合去重：list.stream().distinct().collect(toList())

List集合去重：List.stream().collect(collectingAndThen(toCollection(() -> new TreeSet<>(Comparator.comparing(User::getName))), ArrayList::new))

匹配： anyMatch()，只要有一个元素匹配传入的条件，就返回 true。
allMatch()，只有有一个元素不匹配传入的条件，就返回 false；如果全部匹配，则返回 true。
noneMatch()，只要有一个元素匹配传入的条件，就返回 false；如果全部不匹配，则返回 true。

5、Stream结果收集

5.1 结果收集到集合中

操作：

public static void main(String[] args) {
        /**
         * Stream结果收集
         * 收集到集合中
         */
        //收集到List集合中
//        Stream<String> stream = Stream.of("aa", "bb", "cc");
        List<String> list = Stream.of("aa", "bb", "cc", "aa")
                .collect(Collectors.toList());
        System.out.println(list);
        //收集到Set集合中
        Set<String> set = Stream.of("aa", "bb", "cc", "aa")
                .collect(Collectors.toSet());
        System.out.println(set);

        //如果需要获取的类型为具体的实现，比如：ArrayList HashSet
        ArrayList<String> arrayList = Stream.of("aa", "bb", "cc", "aa")
//                .collect(Collectors.toCollection(() -> new ArrayList<>()));
        .collect(Collectors.toCollection(ArrayList::new));
        System.out.println(arrayList);
        HashSet<String> hashSet = Stream.of("aa", "bb", "cc", "aa")
                .collect(Collectors.toCollection(HashSet::new));
        System.out.println(hashSet);
    }

输出：

[aa, bb, cc, aa]
[aa, bb, cc]
[aa, bb, cc, aa]
[aa, bb, cc]

5.2 结果收集到数组中

Stream中提供了toArray方法来将结果放到一个数组中，返回值类型是Object[]，如果我们要指定返回的类型，那么可以使用另一个重载的toArry(IntFunction f)方法

操作：

public static void main(String[] args) {
    /**
     * Stream结果收集收集到数组中
     */
    Object[] objects = Stream.of("aa", "bb", "cc", "aa")
            .toArray();//返回的数组中的元素是Object类型
    System.out.println(Arrays.toString(objects));
    //如果我们需要指定返回的数组中的元素类型
    String[] strings = Stream.of("aa", "bb", "cc", "aa")
            .toArray(String[]::new);
    System.out.println(Arrays.toString(strings));
}

输出：

[aa, bb, cc, aa]
[aa, bb, cc, aa]

5.3 对流中的数据做分区操作

Collectors.partitioningBy会根据值是否为true，把集合的数据分割为两个列表，一个true列表，一个false列表

5.4 对流中的数据做拼接

Collector.joining会根据指定的连接符，将所有的元素连接成一个字符串

6、 并行的Stream流

6.1 串行的Stream流

我们前面使用的Stream流都是串行，也就是在一个线程上面执行

public static void main(String[] args) {
    Stream.of(5,4,1,2,5,5,8)
            .filter(s->{
                System.out.println(Thread.currentThread()+""+s);
                return s>3;
            }).count();
}

输出：

Thread[main,5,main]5
Thread[main,5,main]4
Thread[main,5,main]1
Thread[main,5,main]2
Thread[main,5,main]5
Thread[main,5,main]5
Thread[main,5,main]8

6.2 并行流

parallelStream其实就是一个并行执行的流，它通过默认的ForkJoinPool，可以提高多线程任务的速度。

获取并行流：

public static void main(String[] args) {
    /**
     * 功能描述:获取并行流的两种方式
     */
    ArrayList<Integer> list = new ArrayList<>();
    //通过list接口直接获取并行流
    Stream<Integer> integerStream = list.parallelStream();
    //将已有的串行流转换为并行流
    Stream<Integer> parallel = Stream.of(1, 2, 3).parallel();
}

并行流操作：

public static void main(String[] args) {
        Stream.of(1, 2, 3, 4, 1)
                .parallel()//将流转换为并发流，Stream处理的时候就会通过多线程处理
                .filter(s -> {
                    System.out.println(Thread.currentThread() + "s=" + s);
                    return s > 2;
                }).count();
    }

输出：

Thread[main,5,main]s=3
Thread[main,5,main]s=1
Thread[main,5,main]s=4
Thread[ForkJoinPool.commonPool-worker-1,5,main]s=2
Thread[main,5,main]s=1

Stream并行处理的过程会分而治之，也就是将一个大的任务切分成了多个小任务，这表示每个任务都是线程操作。

五、新日期时间API

JDK 8中增加了一套全新的日期时间API,这套API设计合理,是线程安全的。新的日期及时间API位于java.time包中，下面是一些关键类。

• LocalDate :表示日期，包含年月日,格式为2019-10-16
• LocalTime:表示时间，包含时分秒,格式为16:38:54.158549300
• LocalDateTime:表示日期时间，包含年月日，时分秒,格式为2018-09-06T15:33:56.750
• DateTimeFormatter :日期时间格式化类。
• Instant:时间戳，表示一个特定的时间瞬间。
• Duration:用于计算2个时间(LocalITime, 时分秒)的距离
• Period:用于计算2个日期(LocalDate,年月日)的距离
• ZonedDateTime :包含时区的时间

1、日期LocalDate

public static void main(String[] args) {

        //创建指定的日期
        LocalDate date = LocalDate.of(2022, 2, 22);
        System.out.println("data1 = " + date);

        //得到当前的日期
        LocalDate now = LocalDate.now();
        System.out.println("date2 = " + now);

        //根据LocalData对象获取对应的日期信息
        System.out.println("年："+ now.getYear());
        System.out.println("月："+ now.getMonth());
        System.out.println("月："+ now.getMonthValue());
        System.out.println("月："+ now.getMonth().getValue());
        System.out.println("日："+ now.getDayOfMonth());
        System.out.println("星期："+ now.getDayOfWeek());
        System.out.println("星期："+ now.getDayOfWeek().getValue());
    }

输出：

date = 2022-02-22
now = 2022-07-26
年：2022
月：JULY
月：7
月：7
日：26
星期：TUESDAY
星期：2

2、时间LocalTime

public static void main(String[] args) {
    //得到指定的时间
    LocalTime time = LocalTime.of(14,22,31,22222);
    System.out.println("time:"+time);
    //获取当前的时间
    LocalTime now = LocalTime.now();
    System.out.println("now:"+now);
    //获取时间信息
    System.out.println(now.getHour());
    System.out.println(now.getMinute());
    System.out.println(now.getSecond());
    System.out.println(now.getNano());

}

输出：

time:14:22:31.000022222
now:14:26:40.822
14
26
40
822000000

3、日期时间LocalDateTime

public static void main(String[] args) {
    //得到指定的日期时间
    LocalDateTime localDateTime =
            LocalDateTime.of(2022,
                    2,
                    22,
                    12,
                    12,
                    12,
                    2222);
    System.out.println("localDateTime:"+localDateTime);
    //获取当前的日期时间
    LocalDateTime now = LocalDateTime.now();
    System.out.println("now:"+now);
    //获取日期时间信息
    System.out.println(now.getYear());
    System.out.println(now.getMonthValue());
    System.out.println(now.getDayOfMonth());
    System.out.println(now.getDayOfWeek().getValue());
    System.out.println(now.getHour());
    System.out.println(now.getMinute());
    System.out.println(now.getSecond());
    System.out.println(now.getNano());
}

输出：

localDateTime:2022-02-22T12:12:12.000002222
now:2022-07-26T14:34:56.084
2022
7
26
2
14
34
56
84000000

4、修改、比较

now.with();//修改
now.plus();//加上
now.minus();//减去
//比较
now.isAfter();//是否在后
now.isBefore();//是否在前
now.isEqual();//相等

注意：在进行日期时间修改的时候，原来的LocalDate是不会被修改的，每次操作都是返回了一个新的LocalDate对象，所以在多线程场景下是数据安全的。

5、格式化和解析操作

在JDK8中我们可以通过java.time.format.DateTimeFormatter类进行日期的解析和格式化操作。

public static void main(String[] args) {
    LocalDateTime now = LocalDateTime.now();
    //指定格式  使用系统默认的格式 
    DateTimeFormatter isoLocalDateTime = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
    //将日期时间转换为字符串
    String format = now.format(isoLocalDateTime);
    System.out.println("format = " + format);//2022-07-26T15:01:35.752

    //通过ofPattern 方法来指定特定的格式
    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    String format1 = now.format(dateTimeFormatter);
    System.out.println("format1 = " + format1);//2022-07-26 15:01:35

    //将字符串解析为一个  日期时间类型
    LocalDateTime parse = LocalDateTime.parse("1999-06-27 22:55:16", dateTimeFormatter);
    System.out.println("parse = " + parse);//1999-06-27T22:55:16
}

输出：

format = 2022-07-26T15:01:35.752
format1 = 2022-07-26 15:01:35
parse = 1999-06-27T22:55:16

6、时区

 public static void main(String[] args) {
        //获取所有的时区id
//        ZoneId.getAvailableZoneIds().forEach(System.out::println);

        //获取当前时间 中国使用的 东八区的时区，比标准时间早8个小时
        LocalDateTime now = LocalDateTime.now();
        System.out.println("now = " + now);//2022-07-26T15:56:27.623
        //获取标准时间
        ZonedDateTime bz = ZonedDateTime.now(Clock.systemUTC());
        System.out.println("bz = " + bz);//2022-07-26T07:56:27.624Z
        //使用计算机默认的时区，创建日期时间
        ZonedDateTime now1 = ZonedDateTime.now();
        System.out.println("now1 = " + now1);//2022-07-26T15:56:27.625+08:00[Asia/Shanghai]

        //使用指定的时区创建日期时间
        ZonedDateTime now2 = ZonedDateTime.now(ZoneId.of("America/Marigot"));
        System.out.println("now2 = " + now2);//2022-07-26T03:59:04.910-04:00[America/Marigot]
    }

输出：

now = 2022-07-26T15:59:04.895
bz = 2022-07-26T07:59:04.909Z
now1 = 2022-07-26T15:59:04.909+08:00[Asia/Shanghai]
now2 = 2022-07-26T03:59:04.910-04:00[America/Marigot]