JDK17 - 开发者视角，从 JDK8 ~ JDK17 都增加了哪些新特性

谁借莪１个温暖的怀抱￠ 2024-02-05 21:11 64阅读 0赞

**目录**

前言

一、站在开发视角，从 JDK8 升级到 JDK17 都有哪些新特性

1.1、JDK8 新特性

1.1.1、Optional 类

a）简介

b）使用方法

c）使用场景

1.2、JDK9 新特性

1.2.1、Optional - ifPresentOrElse 解决 if-else

1.2.2、Optional - or 解决多重 if 嵌套

1.2.3、Optional - orElseThrow 内置异常

1.2.4、集合增强 - 集合静态工厂

1.2.5、集合增强 - takeWhile 方法

1.2.6、集合增强 - dropWhile 方法

1.2.7、接口可以定义私有方法

1.3、JDK10

1.3.1、copyOf 方法

1.4、JDK14 新特性

1.4.1、支持文本块

1.4.2、空指针异常的精确定位

1.4.3、instanceof 类型转换

1.5、JDK16 新特性

1.5.1、toList 方法

1.6、JDK17 新特性

1.6.2、switch 增强

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

## 前言 ##

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

本文只是站在开发者视角，来看看升级哪些咱们程序员常用的功能~

## 一、站在开发视角，从 JDK8 升级到 JDK17 都有哪些新特性 ##

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

### 1.1、JDK8 新特性 ###

#### 1.1.1、Optional 类 ####

##### a）简介 #####

经过统计，空指针异常是导致 Java 应用程序失败的最常见原因，因此 Google 公司 引入了 **Optional 类以检查空值的方式来避免空指针异常**，使程序员写出更干净的代码.

Optional 类（Java.util.Optional）是一个容器类，可以保存类型T值，表示这个值存在。或者，也可以只保存 null，表示这个值不存在。也就是说，以前用 null 表示一个值不存在，现在 Optional 就可以更好的表达这个概念，避免空指针异常.

##### b）使用方法 #####

> Java文档中说明：这是一个可以为 null 的容器对象.
> 
>  *  如果值存在，则 isPresent() 方法会返回 true，调用 get() 方法就会返回该对象.
>  *  如果值不存在，则 isPresent() 方法会返回 false，调用 get() 方法就会抛出空指针异常.

@Data
    public class Student {
    
        private String name;
        private Integer age;
    
    }

1）创建 Optional 对象案例

*  Optional.of(T t)：创建一个 Optional 对象，t 必须不为空.
 *  Optional.empty()：创建一个空的 Optional 实例.
 *  Optional.ofNullable(T t)：t 可以为 null.

public void test1() {
            //创建一个空的 Optional
            Optional<Object> empty = Optional.empty();
    
            //创建非空的 Optional
            Student student1 = new Student();
            Optional<Student> os1 = Optional.of(student1);
    
            //创建一个空的 Optional
            Student student2 = null;
            Optional<Student> os2 = Optional.of(student2);
        }

2）判断 Optional 容器中是否包含对象

*  boolea isPresent()：判断是否包含对象.
 *  void ifPresent(Consumer<? super T> consumer)： 如果 Optional 中有值，就执行Consumer接口的实现代码，并且该值会作为参数传给它.

public void test2() {
            //ifPresent 无参使用: 判断 os1 中是否有值
            Student student = new Student();
            Optional<Student> os1 = Optional.of(student);
            System.out.println(os1.isPresent()); //true
    
            //ifPresent 有参使用: 若 student 对象不为空，则对该对象进行赋值，并打印一句话
            os1.ifPresent(aa -> { //此处的 aa 就代指 student
                aa.setName("cyk");
                aa.setAge(20);
                System.out.println("个人信息已初始化: " + student);
            });
        }

3）获取 Optional 容器的对象

*  T get()：如果 Optional 包含值，则返回值，否则抛出异常.
 *  T orElse(T other)：如果 Optional 包含值就返回，否则返回指定的 other 对象.
 *  T orElseGet(Supplier<? extends T> other)：如果 Optional 包含值就返回，否则返回由Supplier接口实现提供的对象.
 *  T orElseThrow(Supplier<? extends X> exceptionSupplier)：如果 Optional 包含值则将其返回，否则抛出由 Supplier 接口实现提供的异常.

public void test3() throws Exception {
            //get 获取空对象，报错
            Student student = null;
            Optional<Student> os1 = Optional.ofNullable(student);
            Student student1 = os1.get(); //此处抛出异常: java.util.NoSuchElementException: No value present
    
            //如果 student 为空，就返回一个新对象
            Student student2 = os1.orElse(new Student());
    
            //如果 student 为空，就调用我们自己实现的函数
            Student student3 = os1.orElseGet(() -> new Student());
    
            //如果 student 为空，就抛出我们指定的异常
            os1.orElseThrow(() -> new Exception("自定义异常"));
        }

4）过滤

*  Optional<T> filter(Predicate<? super <T> predicate)：如果值存在，并且这个值匹配给定的 predicate，返回一个Optional用以描述这个值，否则返回一个空的Optional。

public void test4() {
            Student student = new Student("cyk", 20);
            Optional<Student> os1 = Optional.ofNullable(student);
            os1.filter(aa -> aa.getName().equals("cyk")) //此处 aa 代指 student
                    .ifPresent(result -> System.out.println("ok!"));
        }

5）映射

map：入参就是 Optional 中的值，并且具有返回值（返回类型就是Optional 对象中的值类型），如果值才执行函数体，否则返回空的 Optional.

public void test5() {
            Student student = new Student("cyk", 20);
            Optional<Student> os1 = Optional.ofNullable(student);
            //如果 os1 中存在值，就执行 lambda 表达式，如果不存在值，就返回一个空的 Optional
            Optional<Student> result = os1.map(aa -> {
                aa.setAge(aa.getAge() + 1);
                return aa;
            });
            System.out.println(result); //输出: Optional[Student(name=cyk, age=21)]
        }

##### c）使用场景 #####

1）例如当你根据 id 从数据库中获取到用户数据时，如果用户数据不为 null，才能可以将年龄 +1.

public void test1(Integer id) {
            //写法一: 原生
            Userinfo userinfo = userinfoMapper.getUserinfoById(id);
            if(userinfo != null) {
                userinfo.setAge(userinfo.getAge() + 1);
            }
    
            //写法二: 使用 Optional 函数式编程，一行搞定
            Optional.ofNullable(userinfoMapper.getUserinfoById(id)).ifPresent(p -> p.setAge(p.getAge() + 1));
        }

2）当传入的用户数据需要进行判空抛异常处理时

public void test2() {
            Userinfo userinfo = new Userinfo(1, null, 20);
            //原生
            if(userinfo == null || isEmpty(userinfo.getUsername())
                    || isEmpty(userinfo.getAge())) {
                throw new RuntimeException("用户数据不能为空!");
            }
            //用 Optional 改进
            Optional.ofNullable(userinfo)
                    .filter(p -> isEmpty(p.getUsername()) || isEmpty(p.getAge()))
                    .orElseThrow(() -> new RuntimeException("用户数据不能为空"));
        }

3）对象赋值，如果有值，则执行业务逻辑，如果没有值，则返回一个默认的对象.

Optional.ofNullable(userinfo)
                    .map(u -> {
                        //业务逻辑...
                        u.setId(2);
                        u.setUsername("cyk");
                        u.setAge(20);
                        return u;
                    })
                    .orElse(new Userinfo(100, "xxx", 0));

### 1.2、JDK9 新特性 ###

#### 1.2.1、Optional - ifPresentOrElse 解决 if-else ####

为了解决 if-else 的判断判空情况，JDK9 增强了 Optional，提供了 ifPresentOrElse.

Userinfo userinfo = new Userinfo(1, "cyk", 20);
            //if-else
            if(userinfo != null) {
                System.out.println("hello " + userinfo.getUsername());
            } else {
                System.out.println("world");
            }
            //ifPresentOrElse
            Optional.ofNullable(userinfo)
                    .ifPresentOrElse(u -> System.out.println("hello " + u.getUsername()),
                            () -> System.out.println("world"));

#### 1.2.2、Optional - or 解决多重 if 嵌套 ####

多重 if 容易导致代码可读性降低，误判引发空指针，并且对于多种if嵌套的情况我还是建议大家提前 return（逻辑更清晰），因此 JDK9 增强 Optional ，提供了 or 方法.

Userinfo nullinfo = null;
            //原生
            if(nullinfo == null) {
                Userinfo userinfo1 = new Userinfo();
                userinfo1.setId(1);
                if(userinfo1 == null) {
                    Userinfo userinfo2 = new Userinfo();
                    userinfo2.setId(2);
                    return userinfo2;
                }
                return userinfo1;
            }
            //Optional 改进后
            Optional<Userinfo> or = Optional.ofNullable(nullinfo)
                    .or(() -> { // nullinfo 为 null，因此执行此 or
                        Userinfo userinfo1 = new Userinfo();
                        userinfo1.setId(1);
                        return Optional.ofNullable(null); //返回一个空的 Optional
                    })
                    .or(() -> { // 上一个 or 返回的 Optional 中没有值时，执行此 or
                        Userinfo userinfo2 = new Userinfo();
                        userinfo2.setId(2);
                        return Optional.ofNullable(userinfo2);
                    });
            System.out.println(or); //输出: Optional[Userinfo(id=2, username=null, age=null)]

#### 1.2.3、Optional - orElseThrow 内置异常 ####

Optional.ofNullable(null).orElseThrow();

该方法会抛出Optional的内置异常`NoSuchElementException.`

#### 1.2.4、集合增强 - 集合静态工厂 ####

*  此方式创建的集合对象都不允许任何写操作，并且都不能为 null.
 *  set/map 不能保证输出顺序和定义的顺序一致.
 *  与 Arrays.asList 创建的 List 不同，Arrays 创建的 List 可以 update不能 add/remove ，而静态工厂创建的完全不能进行写操作.

//1.创建不可变的 List
            List<String> strList = List.of("aaa", "bbb", "ccc");
            //strList.add("ddd"); //报错: Exception in thread "main" java.lang.UnsupportedOperationException
    
            //2.创建一个不可变的 set/map
            Set<String> set = Set.of("aaa", "bbb", "ccc");
            Map<String, String> map1 = Map.of("1", "aaa", "2", "bbb", "3", "ccc");
            //以上 map 创建方式可能会导致分不清 key value，因此也可以通过以下方式创建
            Map<String, String> map2 = Map.ofEntries(Map.entry("1", "bbb"), Map.entry("2", "bbb"));
            //set/map 不能保证输出的顺序和定义 键值对 的顺序一致
            System.out.println(map1);

#### 1.2.5、集合增强 - takeWhile 方法 ####

takeWhile 用来从前向后遍历，遇到不满足的就结束流，最后返回从前到不满足的截断结果（流对象）.

List<Integer> list = List.of(1, 2, 3, 4, 5, 6, 7);
            List<Integer> result = list.stream().takeWhile(val -> val < 5).toList();
            System.out.println(result); //输出: [1, 2, 3, 4]

> Ps：如果使用不可修改的Set或者Map 在使用这个方法是要注意 会存在每次输出的结果都是不一样的

#### 1.2.6、集合增强 - dropWhile 方法 ####

takeWhile 用来从前向后删除，遇到不满足的就结束流，最后返回原始流剩下的结果（流对象）.

因此，也可以理解为 takeWhile 的补集.

List<Integer> list = List.of(1, 2, 3, 4, 5, 6, 7);
            List<Integer> result = list.stream().dropWhile(val -> val < 5).toList();
            System.out.println(result); //输出: [5, 6, 7]
            System.out.println(list); //Ps: 这里的删除，不影响 list 中原本的值

> Ps：如果使用不可修改的Set或者Map 在使用这个方法和takeWhile一样是要注意；

#### 1.2.7、接口可以定义私有方法 ####

接口可以定义一些私有的方法给 default 方法调用，仅此而已。

### 1.3、JDK10 ###

#### 1.3.1、copyOf 方法 ####

集合提供了 copyOf 方法，返回的不可以修改的集合（修改就抛异常）.

> Ps：这里使用的深拷贝，因此修改原集合不会影响副本.

List<String> srcList = new ArrayList<>();
            srcList.add("aaa");
            srcList.add("bbb");
            List<String> copyList = List.copyOf(srcList);
            srcList.add("ccc");
            System.out.println(srcList); //[aaa, bbb, ccc]
            System.out.println(copyList);//[aaa, bbb]

### 1.4、JDK14 新特性 ###

#### 1.4.1、支持文本块 ####

文本代码块让整个String看上去都是比较整洁的，并且无需进行繁琐的转义.

//原始
            String before = "{\n" +
                            "     \"name\":\"cyk\",\n" +
                            "     \"age\": 20;\n" +
                            "}";
            //增强
            String after = """
                          {
                              "name": "cyk",
                              "age": 20
                          }
                          """;

#### 1.4.2、空指针异常的精确定位 ####

不光可以定义是哪行代码空指针异常，还能定位到调用到哪个方法/属性出现的异常.

//Before:
    
    Exception in thread "main" java.lang.NullPointerException
     at com.dev.wizard.feature.JDK17Demo.optionalMethod_orElseThrow(JDK17Demo.java:99)
     at com.dev.wizard.feature.JDK17Demo.main(JDK17Demo.java:23)
    
    //After:
    
    Exception in thread "main" java.lang.NullPointerException: Cannot read field "student" because "persons" is null
     at com.dev.wizard.feature.JDK17Demo.optionalMethod_orElseThrow(JDK17Demo.java:99)
     at com.dev.wizard.feature.JDK17Demo.main(JDK17Demo.java:23)

#### 1.4.3、instanceof 类型转换 ####

以往 instanceof 只能帮我们检查数据类型是否符合，JDK14 中不仅可以进行类型匹配，还会将匹配到的类型直接赋值新的引用，简化了开发，提高了可读性.

Object val = "aaa";
    
            //before
            if(val instanceof String) {
                String newVal = (String) val;
                System.out.println(newVal);
            }
            //after
            if(val instanceof String newVal) {
                System.out.println(newVal);
            }

### 1.5、JDK16 新特性 ###

#### 1.5.1、toList 方法 ####

`stream().toList` 和 `Collectors.toUnmodifiableList()`都是不可修改的集合，`Collectors.toList()`是生成的是普通的list，可写。

性能比较：toList(优) --> Collectors.toList() --> Collectors.toUnmodifiableList(劣)

List<String> list1 = List.of("aaa", "bbb");
            //可读可写
            List<String> list2 = list1.stream().toList();
            //可读，不可写
            List<String> list3 = list2.stream().collect(Collectors.toList());
            List<String> list4 = list1.stream().collect(Collectors.toUnmodifiableList());

### 1.6、JDK17 新特性 ###

#### 1.6.2、switch 增强 ####

JDK17 中的 switch 主要是使用 -> 替代了 break 语句，看上去更加简洁.

*看上去 switch 是想替代 if-else 的感觉~*

1）字符串匹配

//1.字符串匹配
            String val1 = "aaa";
    
            //before
            switch (val1) {
                case "abc":
                    System.out.println("abc!");
                    break;
                case "aaa":
                    System.out.println("aaa!");
                    break;
                default:
                    System.out.println("error!");
            }
            //after
            switch (val1) {
                case "abc" -> System.out.println("abc!");
                case "aaa" -> System.out.println("aaa");
                default -> System.out.println("error");
            }

2）类型判断

//2.类型判断
            Object val2 = "aaa";
    
            //before
            if(val2 instanceof String) {
                String newVal = (String) val2;
                System.out.println("String:" + newVal);
            } else if(val2 instanceof Integer) {
                Integer newVal = (Integer) val2;
                System.out.println("Integer:" + newVal);
            } else {
                System.out.println(val2);
            }
    
            //after
            switch (val2) {
                case String str -> {
                    String newVal = str;
                    System.out.println("String:" + newVal);
                }
                case Integer num -> {
                    Integer newVal = num;
                    System.out.println("Integer:" + newVal);
                }
                default -> System.out.println(val2);
            }

3）对 null 的处理

//3.对 null 的处理
            String val3 = null;
            switch (val3) {
                case null -> System.out.println("null!");
                case "aaa" -> System.out.println("aaa!");
                case "bbb" -> System.out.println("bbb!");
                default -> System.out.println("error");
            }

4）对条件判断的处理

//4.对条件判断的处理
            Object obj = 1;
            switch (obj) {
                case String str -> {
                    String newVal = str;
                    System.out.println("String:" + newVal);
                }
                case Integer num && num < 3 -> {
                    Integer newVal = num;
                    System.out.println("Integer:" + newVal);
                }
                default -> System.out.println("error!");
            }

![6acafc61f4bc4348a2ce02ba4a051e87.gif][]

[6acafc61f4bc4348a2ce02ba4a051e87.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/62802820038a48288aa0202f4d79d678.png