JDK7~13的新特性

我会带着你远行 2022-10-30 05:22 333阅读 0赞

### 目录 ###

*   *   *  jdk7
         *   *  新的资源关闭方式 try-with-resources
         *  jdk8
         *   *  接口新增的默认方法、静态方法
             *  新增的base64加解密api
             *  新增的时间日期类、时间日期处理类
             *  新增的NPE处理类Optional
             *  新增的函数式接口、lambda表达式
             *   *  函数式接口
                 *  lambda表达式
                 *  jdk8内置的函数式接口
             *  新增的方法引用方式::
             *  新增的集合操作方式Stream
             *   *  stream的基本使用
                 *  map()
                 *  filter()
                 *  sorted()
                 *  limit()
                 *  allMatch()、anyMatch()
                 *  max()、min()
                 *  reduce()
                 *  foreach()
                 *  collect()
                 *  paralleStream 并行流
             *  新的内存空间Matespace
         *  jdk9
         *   *  接口新增的私有方法
             *  增强的try-with-resource
             *  新增的创建只读集合的api
             *  模块化
         *  jdk10
         *   *  新增的创建只读集合的api
             *  新增的局部变量类型推断var
         *  jdk11
         *   *  新增的http客户端
             *  javac、java命令的优化
         *  jdk13

### jdk7 ###

#### 新的资源关闭方式 try-with-resources ####

以前的资源关闭方式 try…finally

OutputStream os = null;
    try { 
        os = new FileOutputStream("C:/Users/chy/Desktop/1.txt");
        os.write("hello".getBytes());
    } catch (FileNotFoundException e) { 
        //...
    } catch (IOException e) { 
        //...
    } finally { 
        if (os != null) { 
            try { 
                os.close();
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    }

需要在finally中关闭，且在finally中还可能需要嵌套try，代码冗杂；如果需要关闭多个资源，关闭顺序还可能写错。

jdk7新增的资源关闭方式 try-with-resources

/** * 在try()中定义要关闭的资源，try代码块执行完毕后会自动关闭该资源，无需手动关闭。关闭时会自动flush刷出数据，无需手动调用flush()。 * 相当于自动提供了一个关闭资源的finally代码块，如果执行try代码块时发生异常，资源也能正常关闭。 * 如果有手动写的finally代码块，会在手动写的finally代码块之前执行。 */
    try (OutputStream os = new FileOutputStream("C:/Users/chy/Desktop/1.txt")) { 
        os.write("hello".getBytes());
    } catch (FileNotFoundException e) { 
        //...
    } catch (IOException e) { 
        //...
    }
    
    
    /** * 如果有多个要关闭的资源，分号隔开。关闭顺序与声明顺序相反，后声明的先关闭。 * 只要实现了AutoCloseable接口的类，都可以使用此种方式关闭资源。 * IO流的4个抽象基类InputStream、OutputStream、Reader、Writer都实现了AutoCloseable接口，IO流基本都可以使用此方式关闭 */
    try (
        OutputStream os1 = new FileOutputStream("C:/Users/chy/Desktop/1.txt");
        OutputStream os2 = new FileOutputStream("C:/Users/chy/Desktop/2.txt")
    ) { 
        os1.write("hello".getBytes());
    } catch (FileNotFoundException e) { 
        //...
    } catch (IOException e) { 
        //...
    }

自动关闭资源，方便，代码也简洁，尽量用try-with-resources代替try…finally来关闭资源。

### jdk8 ###

#### 接口新增的默认方法、静态方法 ####

public interface Animal { 
    
        void run();
    
        void eat();
    
        default void breath() { 
            System.out.println("默认方法实现...");
        }
    
        static void test() { 
            System.out.println("静态⽅法...");
        }
        
    }

jdk8以前：接口中的方法只能是抽象方法，不能有方法体（实现）

jdk8

*  接口新增了默认方法：方法使用default修饰（default并不是访问权限，接口中的方法都只能是public），必须提供方法体（实现）。实现类会继承默认方法，可根据需要重写默认方法，实现类调用默认方法时，如果进行了重写则默认调用本类中的默认方法，否则调用接口中的默认方法。
 *  接口新增了静态方法：方法使用static修饰，必须提供方法体（实现），通过接口名调用。关于静态方法，注意：子类会继承父类的静态方法，但子接口、实现类不会继承父接口的静态方法。

接口新增了默认方法、静态方法，但和抽象类相比，接口依然不能表达对象状态的变化（接口中不能定义对象的成员字段），接口不能完全替代抽象类。

#### 新增的base64加解密api ####

base64常用于数据的加解密，比如登录使用http+密码明文很不安全，最好使用https，如果坚持要用http，最好加密敏感数据后再进行传输。

jdk7的base64加解密方式

//原文本
    String text = "年年有鱼";
    //编码后的文本
    String encodedText;
    
    //编码
    BASE64Encoder encoder = new BASE64Encoder();
    encodedText = encoder.encode(text.getBytes("UTF-8"));
    System.out.println("编码后得到的文本：" + encodedText);
    
    //解码
    BASE64Decoder decoder = new BASE64Decoder();
    text = new String(decoder.decodeBuffer(encodedText), "UTF-8");
    System.out.println("解码后得到的原文本：" + text);

编解码性能差，据说会在将来的版本中删除。

jdk8提供了性能更好的base64加解密方式

//原文本
    String text = "年年有鱼";
    //编码后的文本
    String encodedText;
    
    //编码
    Base64.Encoder encoder = Base64.getEncoder();
    encodedText = encoder.encodeToString(text.getBytes("UTF-8"));
    System.out.println("编码后得到的文本：" + encodedText);
    
    //解码
    Base64.Decoder decoder = Base64.getDecoder();
    text = new String(decoder.decode(encodedText), "UTF8");
    System.out.println("解码后得到的原文本：" + text);

#### 新增的时间日期类、时间日期处理类 ####

*  jdk7的时间日期类：Date、Calendar，非线程安全，api设计差、不好使用。
 *  jdk8新增的时间日期类：LocalDate 日期、LocalTime 时间、LocalDateTime 日期+时间，api众多，操作方便。  
     
 *  jdk7的时间日期处理类：DateFormat、SimpleDateFormat，SimpleDateFormat简单易用，但非线程安全
 *  jdk8新增的时间日期处理类：DateTimeFormatter，同样好用，但线程安全

//新增的三个时间日期类，创建对象的方法都是静态方法，通过类名直接调用
    LocalDateTime today = LocalDateTime.now();
    LocalDateTime dt = LocalDateTime.of(2020, 1, 1, 1, 1, 1);
    
    //使用新增的时间日期处理类进行格式化
    DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    String formatDT = dtf.format(today);
    System.out.println("格式化后得到的时间日期：" + formatDT);
    
    //计算2个时间日期的差值。第二个参数减第一个参数
    Duration duration = Duration.between(dt, today);
    //Duration包含了多种差值表示方式
    System.out.println("dt距today多少天：" + duration.toDays());
    System.out.println("dt距today多少小时：" + duration.toHours());

#### 新增的NPE处理类Optional ####

使用大段大段的if…else…判空，可读性差，可以用Optional替代对象成员变量的if判空。

User user = null;
    
    
    //user可以为null
    Optional<User> optional = Optional.ofNullable(user);
    
    //user不能为null，为null时会发生NPE
    Optional<User> optional = Optional.of(user);
    
    
    //Optional可以看做对对象的包装，判断内部对象是否为null
    boolean present = optional.isPresent();
    
    //获取内部对象，内部对象为null时会发生NPE
    User user = optional.get();
    
    
    
    //可以对optional中的对象进行过滤，满足条件才保留在optional中，以新对象的形式返回
    //user可以为null，为null时不会发生NPE
    optional = optional.filter(user -> StringUtils.isBlank(user.getUsername()) && user.getUsername().length() < 10);
    
    
    String defaultHeadImg = "/xxx/xxx.png";
    
    //user对象的headImg属性不为null，则返回headImg，为null则返回设置的默认值
    String headImg = optional.map(user -> user.getHeadImg()).orElse(defaultHeadImg);
    
    //可以把lambda表达式的返回值作为默认值
    String headImg = optional.map(user -> user.getHeadImg()).orElseGet(() -> defaultHeadImg);
    
    //也可以直接抛出异常
    String headImg = optional.map(user -> user.getHeadImg()).orElseThrow(() -> new RuntimeException("未选择头像"));
    
    //以上三句代码，user为null时也不会发生NPE
    
    
    //也可以先进行判断，内部对象不为null才进行操作
    optional.ifPresent(user -> { 
        //传入的是对象地址，对形参的操作就是对实参的操作
        //...
    });

*  创建Optional对象，对内部对象进行判空，再进行操作，这样使用Optional没有意义，比原先的if判空还写得复杂。
 *  Optional适合在对象可能为null（需要判空）时单次获取对象的属性，不是每种判空都适合使用Optional，比如对包装类、String这些简单对象的判空，比如要多次获取对象的（多个）属性进行操作。高频使用map()方法会显得很繁琐，最好先对对象进行判空，再进行后续操作，有时候使用if直接判空更好。

#### 新增的函数式接口、lambda表达式 ####

##### 函数式接口 #####

jdk8新增了函数式接口，以支持函数式编程

@FunctionalInterface  //标识为函数式接口
    public interface MyStringUtils { 
    
        String join(String str1, String str2);
    
    }

函数式接口中的抽象方法有且只能有1个，可以有静态方法、默认实现的方法，但抽象方法必须有、且只能有1个。

##### lambda表达式 #####

lambda表达式可以实现只有一个抽象方法的接口，不局限于函数式接口，只要接口中只有一个抽象方法，就可以使用lambda表达式实现。

//原来的写法：使用匿名内部类
    MyStringUtils myStringUtils1 = new MyStringUtils() { 
        @Override
        public String join(String str1, String str2) { 
            return str1 + str2;
        }
    };
    
    
    //使用lambda表达式。lambda表达式实质是使用匿名内部类，语法糖，代码更加简洁
    MyStringUtils myStringUtils2 = (str1, str2) -> str1 + str2;
    
    
    //相比于匿名内部类，lambda表达式除了简洁之外，还可以直接访问外部变量，但只能访问、不能修改
    String username = "chy";
    userlist.forEach(user -> { 
    	//可以直接使用外部变量username
        if (username.equals(user.getUsername())) { 
            System.out.println(user);
        }
    });

*  只有一个参数时，可以省略()
 *  方法体中只有一条语句时，可以省略\{ \}
 *  方法体中只有一条语句，且方法有返回值时，可以缺省return关键字

##### jdk8内置的函数式接口 #####

jdk、各种框架都内置了多个函数式接口，jdk8常见的内置函数式接口如下

*  Consumer：void accept(T t); 消费型接口，有入参、无返回值，用于处理传入的参数。
 *  Supplier：T get(); 供给型接口，无入参、有返回值，用于提供某个类型的实例。
 *  Function<T, R>：R apply(T t); 函数型接口，有入参、有返回值，用于处理传入的数据，并返回结果。
 *  BiFunction：R apply(T t, U u); Function只能接收⼀个参数，BiFunction可以接收2个参数
 *  Predicate： boolean test(T t); 断⾔型接口，有入参、有返回值，返回值为布尔类型，用于校验传入的数据。

示例

public class Test { 
    
        /** * 过滤list中的元素，返回满足条件的元素 */
        public static <T> List<T> filterList(List<T> list, Predicate<T> predicate) { 
            List<T> resultList = new ArrayList<>();
            for (T ele : list) { 
                //调用predicate的test()进行判断
                if (predicate.test(ele)) { 
                    resultList.add(ele);
                }
            }
            return resultList;
        }
    
        public static void main(String[] args) { 
            List<String> list = Arrays.asList("zhangsan", "lisi", "wangwu");
            //条件：字符串长度>5
            List<String> resultList = filterList(list, ele -> ele.length() > 5);
            System.out.println("满足条件的元素：" + resultList);
        }
    
    }

#### 新增的方法引用方式:: ####

在lambda表达式中，可以使用双冒号引用方法

User user = new User();
    Optional<User> optional = Optional.ofNullable(user);
    
    //原来的调用方式：u.getHeadImg()
    String headImg1 = optional.map(u->u.getHeadImg()).orElse("/xxx/defaultHeadImg.png");
    //新的调用方式：User::getHeadImg
    String headImg2 = optional.map(User::getHeadImg).orElse("/xxx/defaultHeadImg.png");

这种方法引用方式只能在lambda表达式中使用

#### 新增的集合操作方式Stream ####

stream 流，可以将集合转换为流，进而对集合中的元素进行⼀系列的操作，比如排序、过滤、聚合等。

##### stream的基本使用 #####

eg. 把手机号的中间4位替换为\*\*\*\*

List<String> list = Arrays.asList("13712798761", "13712798762", "13712798763");
    
    //stream()是转换为对应的流对象 Stream<T>
    List<String> resultList = list.stream()
            //map()返回的也是流对象 Stream
            .map(ele -> new StringBuilder(ele).replace(3, 7, "****").toString())
            //将Stream转回List
            .collect(Collectors.toList());
    
    System.out.println(resultList);

//可以使用集合对象的.stream()方法创建流，也可以使用Stream的静态方法创建流，比如
    Stream<Integer> stream = Stream.of(1, 2, 3);
    
    //jdk也封装了一些常见类型的流，比如IntStream、LongStream、DoubleStream
    IntStream intStream = IntStream.of(1, 2, 3);
    //这些流根据自身的元素类型，有一些额外的方法，比如sum()、average()
    int sum = intStream.sum();
    OptionalDouble average = intStream.average();
    
    //Optional也封装一些常见类型，比如OptionalInt、OptionalLong、OptionalDouble

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

map()可以将流中的元素映射为指定类型，类似于类型转换。

> .map(ele -> new StringBuilder(ele).replace(3, 7, “\*\*\*\*”).toString())

流中的元素原本是String类型，lambda表达式的方法体缺省了return关键字，方法体其实是 return new StringBuilder(ele).replace(3, 7, “\*\*\*\*”).toString()); 返回String类型的元素。  
   
eg. 把List<User>转换为List<UserDTO>传给其它服务处理

List<User> userlist = Arrays.asList(
            new User(1, "chy1", "abcd1", "13723456781"),
            new User(2, "chy2", "abcd2", "13723456782"),
            new User(3, "chy3", "abcd2", "13723456783")
    );
    
    List<UserDTO> userDTOList = userlist.stream()
            .map(user -> { 
            	//增删改一些字段，比如去除密码之类的敏感信息
                String tel = new StringBuilder(user.getTel()).replace(3, 7, "****").toString();
                return new UserDTO(user.getId(), user.getUsername(), tel);
            })
            .collect(Collectors.toList());
    
    System.out.println(userDTOList);

##### filter() #####

filter()用于筛选流中满足条件的元素，只保留满足条件的元素。

List<User> resultList = userlist.stream()
                   // filter()的参数是函数式断言接口 Predicate，返回布尔值即可，true表示保留
                   // .filter(user->user.getUsername().startsWith("ch") && user.getUsername().endsWith("2"))
                   .filter(user -> { 
                       String username = user.getUsername();
                       if (username.startsWith("ch") && username.endsWith("2")) { 
                           return true;
                       }
                       return false;
                   })
                   .collect(Collectors.toList());

##### sorted() #####

sorted()可以对流中的元素排序

List<User> resultList = userlist.stream()
                  // 按id的大小升序排列
                  .sorted(Comparator.comparing(user -> user.getId()))
    
                  // 按username的长度升序排列
                  // .sorted(Comparator.comparing(user -> user.getUsername().length()))
    
                  // lambda方法体有2个参数，第一个指定用来排序的字段，第二个指定升|降序，缺省第二个时默认Comparator.naturalOrder() 升序
                  // .sorted(Comparator.comparing(user -> user.getId(), Comparator.naturalOrder()))
    
                  // 降序方式
                  // .sorted(Comparator.comparing(user -> user.getId(), Comparator.reverseOrder()))
                  // .sorted(Comparator.comparing(user -> user.getUsername().length(), Comparator.reverseOrder()))
    
                  .collect(Collectors.toList());

##### limit() #####

limit()用于指定流中要保留的元素个数。

List<User> resultList = userlist.stream()
            //只保留2个元素
            .limit(2)
            .collect(Collectors.toList());

很多方法都可以搭配使用，可以多次使用同一个方法。

##### allMatch()、anyMatch() #####

allMatch()用于判断流中的元素是否都满足指定条件，anyMatch()用于判断流中是否有元素满足指定条件（有一个元素满足即可）。

//参数都是断言接口Predicate
    boolean b1 = userlist.stream().anyMatch(user -> StringUtils.isNotBlank(user.getUsername()));
    boolean b2 = userlist.stream().allMatch(user -> StringUtils.isNotBlank(user.getUsername()));

##### max()、min() #####

max()、min()用于获取流中指定字段的值最大、最小的元素。

//lambda表达式的参数是2个元素，Integer.compare()的参数是要比较的2个值，实质是指定要比较的字段，元素、值要对应
    Optional<User> max2 = userlist.stream().max((user1, user2) -> Integer.compare(user1.getId(), user2.getId()));
    
    //可以简写如下
    Optional<User> max1 = userlist.stream().max(Comparator.comparingInt(user -> user.getId()));

返回值是Optional类型，包含了整个元素。

##### reduce() #####

reduce()可以逐步将2个相邻元素替换为1个元素，减少流中的元素数，直到流中只剩下一个元素。

eg. 求元素之和、之积

//lambda的参数表示2个相邻元素
    int sum1 = Stream.of(1, 2, 3, 4, 5).reduce((ele1, ele2) -> ele1 + ele2).get();
    
    //可以设置一个初始值，相当于在流中的第一个元素之前暂时插入一个新元素参与计算
    int sum2 = Stream.of(1, 2, 3, 4, 5).reduce(100, (ele1, ele2) -> ele1 + ele2);

*  1，2，3，4，5
 *  3，3，4，5
 *  6，4，5
 *  10，5
 *  15

IntStream之类的数值型流有sum()方法可以求和，但很多流中的元素是OrderItem之类的复杂类型，需要使用reduce()来操作元素的成员变量。

eg. 求最大、最小值

int sum1 = Stream.of(1, 2, 3, 4, 5).reduce((ele1, ele2) -> ele1 > ele2 ? ele1 : ele2).get();
    
    int sum2 = Stream.of(1, 2, 3, 4, 5).reduce((ele1, ele2) -> Integer.max(ele1, ele2)).get();

也可以使用流的max()、min()方法实现

##### foreach() #####

集合、stream都有foreach()方法，用于遍历元素

//方法体即循环体
    userlist.stream().forEach(user -> System.out.println(user));
    userlist.forEach(user -> System.out.println(user));

注意点

*  循环体中不能使用break、continue
 *  循环体中可以使用return，但return无效
 *  不管是使用迭代器、增强for循环，还是使用foreach遍历集合，不要在循环体中增删当前遍历的集合|stream中的元素，增删元素会导致遍历出错

##### collect() #####

collect()是收集器，可以将流中的元素收集到指定容器中。

//收集到list中，使用的是ArrayList
    List<Integer> collect1 = Stream.of(1, 2, 3).collect(Collectors.toList());
    
    //收集到set中，使用的是HashSet
    Set<Integer> collect2 = Stream.of(1, 2, 3).collect(Collectors.toSet());
    
    
    //可以指定目标集合类型
    LinkedList<Integer> collect3 = Stream.of(1, 2, 3).collect(Collectors.toCollection(LinkedList::new));
    CopyOnWriteArrayList<Integer> collect4 = Stream.of(1, 2, 3).collect(Collectors.toCollection(CopyOnWriteArrayList::new));
    
    
    //可以转换为map：toMap()、toConcurrentMap()

如果元素是字符串，可以拼接（收集）元素到一个字符串中

//直接拼接，不使用分隔符（即使用空串作为分隔符）
    String str1 = Stream.of("hello", "word").collect(Collectors.joining());
    
    //可以指定分隔符
    String str2 = Stream.of("hello", "word").collect(Collectors.joining(" "));
    
    //可以指定分隔符、前缀、后缀
    String str3 = Stream.of("hello", "word").collect(Collectors.joining(" ", "", "!"));

流的分组统计

//将满足条件（true）的分为一组，将不满足条件（false）的分为一组，2个key分别是true、false
    Map<Boolean, List<Integer>> map1 = Stream.of(1, 2, 3, 4, 5).collect(Collectors.partitioningBy(ele -> ele > 3));
    
    
    //按指定字段进行分组，一组就是一个List<Student>
    //eg.统计员工中各个省份的有哪些，统计订单中各个状态的订单有哪些
    Map<String, List<Student>> map2 = studentList.stream().collect(Collectors.groupingBy(student -> student.getProvince()));
    
    
    //lambda表达式的方法体多了一个参数，按指定字段分组统计元素个数
    //eg.统计员工中各个省份的人数，统计订单中各个状态的订单数
    Map<String, Long> map3 = studentList.stream().collect(Collectors.groupingBy(student -> student.getProvince(), Collectors.counting()));

对于数值型字段，可以聚合统计流的多个指标

//summarizingInt包含了统计字段的数据类型，支持Int、Long、Double
    IntSummaryStatistics intSummaryStatistics = studentList.stream().collect(Collectors.summarizingInt(student -> student.getAge()));
    
    long count = intSummaryStatistics.getCount();
    double average = intSummaryStatistics.getAverage();
    int max = intSummaryStatistics.getMax();
    int min = intSummaryStatistics.getMin();
    long sum = intSummaryStatistics.getSum();

##### paralleStream 并行流 #####

//以下2种方式构建的都是串行流
    Stream<Integer> stream1 = Stream.of(1, 2);
    Stream<User> stream2 = userlist.stream();
    
    //以下2种方式构建的是并行流。调用parallel()方法，可以将串行流转换为并行流
    Stream<Integer> parallelStream1 = Stream.of(1, 2).parallel();
    Stream<User> parallelStream2 = userlist.parallelStream();

并行流的使用方式和串行流相同，只是串行流是单线程执行流操作，并行流使用多线程执行流操作。

涉及多线程时，注意2点

*  多线程不一定比单线程快：多线程有分配线程资源、切换线程上下文的时间开销，如果是执行时间长的大任务，多线程往往比单线程快；如果是执行时间很短的小任务，单线程可能比多线程快。遍历集合时是否要使用多线程要看元素个数，几十个元素的小集合一般使用单线程即可，几千上万个元素的大集合、循环体又有点耗时的，可以使用多线程。
 *  使用多线程时一定要注意线程安全问题，对于线程共享资源，该使用线程安全类的使用线程安全类，该加锁的加锁。

一般使用串行流即可，如果元素较多，可以使用并行流，使用并行流时要注意线程安全问题。

#### 新的内存空间Matespace ####

jdk、jvm都只是一个标准、规范，有多种实现，此处以主流的jvm实现Hotspot为准。

jdk7用永久代（permanent generation）来此存储类的元数据，永久代使用的是jvm的内存空间，可能发生OOM。

jdk8使用元空间（Metaspace）代替永久代，元空间使用本地内存，受制于机器物理内存的大小，基本不会发生OOM。

### jdk9 ###

#### 接口新增的私有方法 ####

public interface Animal { 
    
        private void m1() { 
            System.out.println("私有方法");
        }
    
        default void m2() { 
            System.out.println("默认方法");
            m1();
        }
    
        static void m3() { 
            System.out.println("静态方法");
        }
    
    }

私有方法使用private修饰，自然不会被继承，只能在当前接口中调用，且必须提供方法体（实现），不然没有意义。

说明

*  接口中的私有方法、默认方法、静态方法都必须提供方法体（实现）。
 *  私有方法不能被继承，默认方法可以被继承，接口中的静态方法不能被继承，但类中的静态方法可以被继承。

#### 增强的try-with-resource ####

OutputStream os1 = new FileOutputStream("C:/Users/chy/Desktop/1.txt");
    OutputStream os2 = new FileOutputStream("C:/Users/chy/Desktop/2.txt");
    
    //可以将资源声明放在try()外面，()中指定资源变量即可，有多个时分号隔开 try (os1; os2)
    try (os1) { 
        os1.write("hello".getBytes());
    } catch (FileNotFoundException e) { 
        e.printStackTrace();
    } catch (IOException e) { 
        e.printStackTrace();
    }

#### 新增的创建只读集合的api ####

之前创建只读集合的方式

List<String> list = new ArrayList<>();
    list.add("chy");
    //设置为只读集合。原集合不变，返回一个只读集合
    list = Collections.unmodifiableList(list);
    
    
    Set<String> set = new HashSet<>();
    set.add("chy");
    //设置为只读集合
    set = Collections.unmodifiableSet(set);
    
    
    Map<String, String> map = new HashMap<>();
    map.put("name", "chy");
    //设置为只读集合
    map = Collections.unmodifiableMap(map);
    
    
    //Arrays.asList()创建的也是只读集合
    List<String> list = Arrays.asList("chy1", "chy2");

jdk9新增的方式

List<String> list = List.of("chy1", "chy2");
    
    Set<String> set = Set.of("chy1", "chy2");
    
    Map<String, Object> map = Map.of("name", "chy", "age", 20);

#### 模块化 ####

jdk9将把jdk、jre、jar等分成较小的模块，使用时无需全部引入，只引入所需的模块即可，模块化降低了代码耦合度、大大缩小了应用体积。

### jdk10 ###

#### 新增的创建只读集合的api ####

ArrayList<String> list1 = new ArrayList<>();
    list1.add("chy");
    
    //jdk10的List、Set、Map都提供了静态方法copyOf()创建对应的只读集合，原集合不变，以新集合的方式返回
    List<String> list2 = List.copyOf(list1);

jdk9、10的这2个api实质都是调用 ImmutableCollections 类的方法创建只读集合。immutable 只读的、不可变更的。

#### 新增的局部变量类型推断var ####

//声明时可以声明为var类型，声明时就必须初始化，初始化时不能赋null，会自动根据赋的值推断变量类型
    var a = 1;
    var b = 2;
    System.out.println(a + b);

var只能用于声明局部变量，不能用于声明方法形参，不能作为方法的返回值类型。

### jdk11 ###

#### 新增的http客户端 ####

基本使用

//要请求的uri
    URI uri = URI.create("http://www.baidu.com");
    
    
    //创建httpClient。可以HttpClient.newHttpClient()直接创建HttpClient对象，但连接最好都设置超时时间
    HttpClient httpClient = HttpClient.newBuilder()
            .connectTimeout(Duration.ofMillis(5000))
            .build();
    
    
    //创建请求。get请求方式
    HttpRequest request = HttpRequest.newBuilder()
            .timeout(Duration.ofMillis(5000))
            .uri(uri)
            // 默认就是get方式，可省略
            // .GET()
            // 配置项
            .header("key1", "value1")
            .header("key2", "value2")
            .build();
    
    
    //执行请求
    try { 
        HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
        //使用响应中的数据
        System.out.println(response.body());
    } catch (IOException e) { 
        e.printStackTrace();
    } catch (InterruptedException e) { 
        e.printStackTrace();
    }

发送post方式的请求

//post请求方式传递表单数据
    String formData = "username=chy&password=1234";
    HttpRequest request1 = HttpRequest.newBuilder()
            .uri(uri)
            .header("Content-Type", "application/x-www-formurlencoded")
            .POST(HttpRequest.BodyPublishers.ofString(formData))
            .build();
    
    
    //post方式传递json数据
    String jsonData = "{\"username\":\"chy\",\"password\":\"abcd\"}";
    HttpRequest request2 = HttpRequest.newBuilder()
            .uri(uri)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonData))
            .build();

发送异步请求

// 同步请求
    // HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
    // System.out.println(response.body());
    
    
    // 异步请求
    CompletableFuture<String> completableFuture = httpClient.sendAsync(request, HttpResponse.BodyHandlers.ofString())
            .thenApply(response -> response.body());
    
    //要执行的其它代码
    //......
    
    //使用响应。completableFuture.get()会阻塞当前线程，直到请求完成返回了响应，或者超时
    String resposeBody = completableFuture.get();
    System.out.println(resposeBody);

发送http2请求

HttpRequest request = HttpRequest.newBuilder()
            .timeout(Duration.ofMillis(5000))
            .uri(uri)
            //指定httpClient使用的http协议版本
            .version(HttpClient.Version.HTTP_2)
            .header("key1", "value1")
            .header("key2", "value2")
            .build();

目前http协议的主流版本是http1.1，http2是下一代版本。http2强制使用https，需要服务器支持http2。

#### javac、java命令的优化 ####

以前编译执行：先javac编译，再java执行，本地会生成.class文件。

jdk11：无需javac编译，直接java执行即可，本地不会生成.class文件。

### jdk13 ###

jdk13新增了文本块、增强了switch表达式，但这2个特性在jdk13中都是预览状态、没有正式发布。