• jdk11新特性——新加的一些更实用的API

    目录

    一、集合 增强

    概述：自 Java 9 开始，Jdk 里面为集合（List/ Set/ Map）都添加了 of 和 copyOf 方法，它们两个都用来创建不可变的集合，

    1.1、List集合 of()方法

    • of方法往List集合添加元素，示例如下：

      import java.util.List;
public class Test1 {
    public static void main(String[] args) {
        t1();
    }
	/**
     * list集合 ，往list集合添加元素
     * */
    public static void t1(){
        var list = List.of("a", "b", "c");
        System.out.println(list);

        list.add("d");//不可以添加元素
        System.out.println(list);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16

    • 输出结果如下：
      在这里插入图片描述

    1.2、Set集合 of()方法

    • of方法往Set集合添加元素，示例如下：
      import java.util.Set;
public class Test1 {
    public static void main(String[] args) {
        t2();
    }
	/**
     * set集合 ，往set集合添加元素
     * */
    public static void t2(){
        var set1 = Set.of("a", "b", "c");
        System.out.println("添加的集合元素："+set1);
        System.out.println("所属的类信息："+set1.getClass());
        //添加重复元素时，不是无法添加，而是抛出异常
        var set = Set.of("a", "b", "c","c");
        System.out.println(set);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
    • 输出结果如下：
      在这里插入图片描述

    1.3、Map集合 of()方法

    • of方法往Map集合添加元素，示例如下：

      import java.util.Set;
public class Test1 {
    public static void main(String[] args) {
        t3();
    }
	/**
    * map集合
    * */
   public static void t3(){
       var map = Map.of("key1", "value1","key2","value2");
       System.out.println("添加的集合元素："+map);
       System.out.println("所属的类信息："+map.getClass());
   }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14

    • 输出结果如下：在这里插入图片描述

    1.4、List集合copyOf()方法

    • copyOf()方法复制集合元素，示例如下：

      import java.util.*;
public class Test1 {
    public static void main(String[] args) {
        t4();
    }
	/**
    * List集合copyOf()方法
    * */
   public static void t4(){
   	   //示例1
       var list = List.of("a", "b", "c");
       var copy  = List.copyOf(list);
       System.out.println(list == copy); // true
       //示例2
       var list1 = new ArrayList<String>();
       var copy1 = List.copyOf(list);
       System.out.println(list1 == copy1); // false
   }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19

    • 输出结果如下：

      在这里插入图片描述

    • 示例1和2代码差不多，为什么一个为true,一个为false?

      由下图源码可以看出 copyOf 方法会先判断来源集合是不是 AbstractImmutableList 类型的，如果是，就直接返回，如果不是，则调用 of 创建一个新的集合。
      在这里插入图片描述
      示例2因为用的 new 创建的集合，不属于不可变 AbstractImmutableList 类的子类，所以 copyOf 方法又创建了一个新的实例，所以为false.

    1.5、of()和copyOf()方法创建集合的注意事项

    • 使用of和copyOf创建的集合为不可变集合，不能进行添加、删除、替换、排序等操作，不然会报 java.lang.UnsupportedOperationException 异常。

    二、Stream 增强

    概述：Stream 是 Java 8 中的新特性，Java 9 开始对 Stream 增加了以下 4 个新方法。
    （1）、增加of()方法
    （2）、增加单个参数构造方法，可为null
    （3）、增加 takeWhile() 和 dropWhile()方法
    （4）、iterate重载

    2.1、Stream 新增of()方法

    • of()方法往Stream 流中新增元素，代码示例：

      package com.xz.jdk11.day1;
import java.util.stream.Stream;
public class Test2 {
    public static void main(String[] args) {
        t1();
    }
    public static void t1(){
        //Stream流中添加元素
        Stream<String> stream = Stream.of("a","b","c");
        stream.forEach(System.out::println);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12

    • 输出结果如下：
      在这里插入图片描述

    2.2、Stream 新增ofNullable()方法

    • Stream 中of()方法传入null，会被解析为是一个数组对象，会进一步访问它的长度信息。报空指针异常。示例代码如下：

      package com.xz.jdk11.day1;
import java.util.stream.Stream;
public class Test2 {
    public static void main(String[] args) {
        t2();
    }
    /**
     * Stream流操作
     * */
    public static void t2(){
        //Stream流中of()传入null，会被解析为是一个数组对象，会进一步访问它的长度信息
        Stream<String> stream = Stream.of(null);
        stream.forEach(System.out::println);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15

    • 输出结果如下：
      在这里插入图片描述

    • Stream流中可以使用ofNullable传入null来创建流对象。示例代码如下：

      package com.xz.jdk11.day1;
import java.util.stream.Stream;
public class Test2 {
    public static void main(String[] args) {
        t2();
    }

    /**
     * Stream流操作
     * */
    public static void t2(){
        //Stream流中可以使用ofNullable传入null来创建流对象
        Stream<String> stream = Stream.ofNullable(null);
        stream.forEach(System.out::println);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16

    • 输出结果如下：
      在这里插入图片描述

    2.3、Stream 新增takeWhile() 和 dropWhile()方法

    2.3.1、Stream中takeWhile() 方法示例

    • 示例代码

      package com.xz.jdk11.day1;
	import java.util.stream.Stream;
	public class Test2 {
	    public static void main(String[] args) {
	        t4();
	    }
	
	    /**
	     * Stream流操作
	     * */
	     public static void t4() {
        //从流中一直获取判定器为n < 3 的元素，一旦遇到元素 >3,就终止处理
        Stream<Integer> stream = Stream.of(1, 2, 3, 2, 1);
        Stream<Integer> stream2 = stream.takeWhile(n -> n < 3);
        stream2.forEach(System.out::println);
    }
	}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17

    • 输出结果如下：
      在这里插入图片描述

    2.3.2、Stream中dropWhile() 方法示例

    • 示例代码

      package com.xz.jdk11.day1;
import java.util.stream.Stream;
public class Test2 {
    public static void main(String[] args) {
        t5();
    }

    /**
     * Stream流操作
     * */
    public static void t5() {
        //从流中一直获取判定器为n < 3 不成立就开始计算
        Stream<Integer> stream = Stream.of(1, 2, 3, 2, 1);
        Stream<Integer> stream2 = stream.dropWhile(n -> n < 3);
        stream2.forEach(System.out::println);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17

    • 输出结果如下：
      在这里插入图片描述

    2.4、Stream 新增iterate()重载方法

    • 无限流的示例代码

      package com.xz.jdk11.day1;
import java.util.stream.Stream;
public class Test2 {
    public static void main(String[] args) {
        t6();
    }
    /**
     * Stream流操作
     * */
    public static void t6() {
        //无限流
        Stream<Integer> stream1 = Stream.iterate(1, t->(2*t)+1);
        //因为是无限流，即无限制的计算，因此通过limit()方法去限制输出结果
        stream1.limit(10).forEach(System.out::println);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16

    • 输出结果如下：
      在这里插入图片描述

    • 有限流的示例代码

      package com.xz.jdk11.day1;
import java.util.stream.Stream;
public class Test2 {
    public static void main(String[] args) {
        t7();
    }
    /**
     * Stream流操作
     * */
     public static void t7() {
       //有限流，通过iterate()方法中第二个参数判定器指定什么时候结束迭代
       Stream<Integer> stream2 = Stream.iterate(1, t->t<20,t->(2*t)+1);
       stream2.forEach(System.out::println);
   }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15

    • 输出结果如下：
      在这里插入图片描述

    三、增加了一系列的字符串处理方法

    3.1、判断字符串是否为空白

    • 示例代码

      public class Test3 {
    public static void main(String[] args) {
        t1();
    }
    /**
     * 判断字符串是否为空白
     * */
    public static void t1(){
        String str=" \t \r \n";
        boolean b = str.isBlank();
        System.out.println("判断字符串是否为空白:"+b);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13

    • 输出结果如下：
      在这里插入图片描述

    3.2、去除字符串首尾空白

    • 示例代码
    public class Test3 {
    public static void main(String[] args) {
        t2();
        t3();
    }
     /**
     * 去除字符串首尾空白,包括英文和其他所有语言中的空白字符
     * */
    public static void t2(){
        String string = " \t  \r\n abc \t　";
        String string2 = string.strip(); 
        System.out.println("去除首尾空白的字符串="+string2);
        System.out.println("去除首尾空白的字符串长度="+string2.length());


    }

    /**
     * 去除字符串首尾空白，只能去除码值小于等于32的空白字符
     * */
    public static void t3(){
        String string = " \t  \r\n abc \t　";
        String string3 = string.trim(); 
        System.out.println("去除首尾空白的字符串="+string3);
        System.out.println("去除首尾空白的字符串长度="+string3.length());
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 输出结果如下：
      在这里插入图片描述

    3.3、去除字符串尾部空白

    • 示例代码

      public class Test3 {
    public static void main(String[] args) {
        t4();
    }
    /**
     * 去除字符串尾部空白
     * */
    public static void t4(){
        String string=" \t \r\n abc \t ";
        String s = string.stripTrailing();
        System.out.println("去除字符串尾部空白的字符串="+s);
        System.out.println("去除字符串尾部空白的字符串长度="+s.length());
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14

    • 输出结果如下：
      在这里插入图片描述

    3.4、去除字符串首部空白

    • 示例代码

      public class Test3 {
    public static void main(String[] args) {
        t5();
    }
    /**
     * 去除字符串首部空白
     * */
    public static void t5(){
        String string = " \t  \r\n abc \t　";
        String s = string.stripLeading();
        System.out.println("去除字符串首部空白的字符串="+s);
        System.out.println("去除字符串首部空白的字符串长度="+s.length());
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14

    • 输出结果如下：
      在这里插入图片描述

    3.5、复制字符串

    • 示例代码

      public class Test3 {
    public static void main(String[] args) {
        t6();
    }
     /**
     * 复制字符串
     * */
    public static void t6(){
        String string = "abcd";
        String s = string.repeat(5);
        System.out.println("复制字符串="+s);
        System.out.println("复制字符串的长度="+s.length());
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14

    • 输出结果如下：
      在这里插入图片描述

    3.6、行数统计

    • 示例代码

      public class Test3 {
    public static void main(String[] args) {
        t7();
    }
    /**
     * 行数统计
     * */
    public static void t7(){
        String string = "abcd\n" +
                "abcd";
        System.out.println("行数="+string.lines().count());
        string.lines().forEach(System.out::println);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14

    • 输出结果如下：
      在这里插入图片描述

    四、Optional 加强

    Opthonal 也增加了几个非常酷的方法，现在可以很方便的将一个 Optional 转换成一个 Stream, 或者当一个空 Optional 时给它一个替代的。

    4.1、Optional.of()方法中如果传入的参数是null, 会抛出空指针异常

    • 示例代码

      import java.util.Optional;
public class Test4 {
    public static void main(String[] args) {
        t1();
    }

    /**
     * Optional.of()方法中如果传入的参数是null, 会抛出空指针异常
     * */
    public static void t1(){
        Optional<String> optional = Optional.of(null);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13

    • 输出结果如下：
      在这里插入图片描述

    4.2、Optional.ofNullable()可以兼容空指针, 但是实际传入null后要小心

    • 示例代码

      import java.util.Optional;
public class Test4 {
    public static void main(String[] args) {
        t2();
    }

    /**
     * Optional.ofNullable()可以兼容空指针, 但是实际传入null后要小心
     * */
    public static void t2(){
        // optional.ofNullable可以兼容空指针, 但是实际传入null后要小心
        Optional<Object> optional = Optional.ofNullable(null);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14

    • 输出结果如下：
      在这里插入图片描述

    4.3、Optional.orElse() 如果内部引用为空, 则返回参数中的引用,否则返回内部引用

    • 示例代码

      import java.util.Optional;
public class Test4 {
    public static void main(String[] args) {
        t3();
    }

     /**
     * Optional.orElse() 如果内部引用为空, 则返回参数中的引用,否则返回内部引用
     * */
    public static void t3(){
        // optional.ofNullable可以兼容空指针, 但是实际传入null后要小心
        Optional<Object> optional = Optional.ofNullable(null);
        // optional.orElse()方法 如果内部引用为空, 则返回参数中的引用 即abd
        Object object = optional.orElse("abc");
        System.out.println("返回参数中的引用=="+object);

        // optional.ofNullable可以兼容空指针, 但是实际传入null后要小心
        Optional<Object> optional1 = Optional.ofNullable("123");
        // optional.orElse()方法 如果内部引用不为空, 否则返回内部引用 即123
        Object object1 = optional1.orElse("abc");
        System.out.println("返回内部引用=="+object1);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23

    • 输出结果如下：
      在这里插入图片描述

    4.4、optional.orElseThrow() 传入null后 抛异常

    • 示例代码

      import java.util.Optional;
public class Test4 {
    public static void main(String[] args) {
        t4();
    }

    /**
     *  optional.orElseThrow() 传入null后 抛异常
     * */
    public static void t4(){
        // optional.ofNullable可以兼容空指针, 但是实际传入null后要小心
        Optional<Object> optional = Optional.ofNullable(null);
        // optional.orElseThrow()方法 如果内部引用为空, 则抛异常
        Object object = optional.orElseThrow();
        System.out.println("抛异常=="+object);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17

    • 输出结果如下：
      在这里插入图片描述

  • 相关阅读:
    若依框架：登录时如何解决404和验证码问题
    数据结构——栈
    静态链接和动态链接
    【附源码】计算机毕业设计SSM设计与实现大学常规信息管理系统
    软考高级之系统架构师之项目管理
    python3.6环境下安装gevent，附协程TCP服务器客户端代码
    中小企业如何降低网络攻击和数据泄露的风险？
    Python中如何在模块搜索路径中添加自己的目录
    【电商】管理后台篇之安全、菜单、通知管理
    centos常用命令
  • 原文地址：https://blog.csdn.net/li1325169021/article/details/128177096