JDK21新增特性

顺序集合(Sequenced Collections)

提供了几个新的接口，用于实现有序的集合。

在没有提供有序集合操作之前，我们进行集合的序列操作一般如下

First	element	Last element
List	list.get(0)	list.get(list.size() - 1)
Deque	deque.getFirst()	deque.getLast()
SortedSet	sortedSet.first()	sortedSet.last()
LinkedHashSet	linkedHashSet.iterator().next()	// missing

JDK新提供的几个接口：

• SequencedCollection
• SequencedSet
• SequencedMap

集合的继承实现关系如下所示：

 public static void main(String[] args) {

    //    SequencedCollection
    List<String> list = new ArrayList<>();

    list.reversed();
    list.getFirst();
    list.getLast();
    list.removeFirst();
    list.removeLast();

    //    SequencedSet
    LinkedHashSet<String> set = new LinkedHashSet<>();
    set.getFirst();
    set.getLast();
    set.reversed();

    TreeSet<String> treeSet = new TreeSet<>();
    treeSet.getFirst();
    treeSet.getLast();
//    treeSet.reversed();

    // SequencedMap
    LinkedHashMap<String, Object> map = new LinkedHashMap<>();
    map.firstEntry();
    map.lastEntry();
    map.reversed();
    map.putFirst("first",1);
    map.putLast("last","last");
    map.pollFirstEntry();
    map.pollLastEntry();
  }

记录模式（Record Patterns）

增强Java程序对record模式的记录值的解构
records模式和类型模式可以嵌套

目标：

• 1.支持record类实例的结构，适配更多场景的数据查询
• 2.增加嵌套类型，可以使用更多类型组合数据类型的查询

模式匹配和记录：

record类实例对于编码程序来说可以精确到数据的类型，并可以创建获取数据的可使用方法

  @Test
  public void testRecordInstance(){
    record Test1(String t1,String t2){}
    Test1 test1 = new Test1("1", "2");
    //Test1(String t1,String t2)是record模式，明确声明了本地变量的类型
    if(test1 instanceof Test1(String t1,String t2)){
      System.out.println(t1);
      System.out.println(t2);
    }
  }

record 嵌套模式

  @Test
  public void test2(){
    record Point(int x,int y){}
    enum Color{RED,YELLOW}
    record ColoredPoint(Point p,Color c){};
    record  Rectangle(ColoredPoint upperLeft,ColoredPoint lowerPoint){}
    //一个测试record嵌套类实例
    Rectangle rectangle = new Rectangle(new ColoredPoint(new Point(1, 1), Color.RED), null);
    //现在我们要获取upperLeft的Color我们就可以这样实现
    if(rectangle instanceof Rectangle(ColoredPoint l,ColoredPoint r)){
      System.out.println(l.c);
    }
    //如果需要跟进一步解析，也可以通过更进一步定义内部嵌套类型
    if(rectangle instanceof Rectangle(ColoredPoint(Point p,Color c),ColoredPoint ur)){
      //直接调用定义的变量c,就可以获取到对应的记录值
      System.out.println(c);
    }
  }

• 类型匹配必须要准确，如下，定义的record类是Object，但是判断是String类型，就回出现无法匹配的错误

  @Test
  public void test3(){
    record Pair(Object x, Object y) {}
    Pair p = new Pair(42, 42);
    if (p instanceof Pair(String s, String t)) {
      System.out.println(s + ", " + t);
    } else {
      System.out.println("Not a pair of strings");
    }

  }

Switch的模式匹配（Pattern Matching for switch）

增加switch表达式的表达式和语法，使复杂的数据匹配查询更加安全和简洁

目标：

1.case标签使用表达式
2.通过要求模式

如果选择器的值与case标签的模式匹配，swtich语句阻塞。

  @Test
  public void test1(){
    Object obj = new String("1");
    String result = switch(obj){
      case Integer i -> String.format("int : %d",i);
      case String s-> String.format("string : %s",s);
      default -> obj.toString();
    };
    System.out.println(result);
  }

switch判断 和 null判断

在此之前，null判断和switch语句是分开的，一般先判断是非空状态，非空的时候才进行switch语句判断
之后的语法中整合了null测试进入switch语法中

  @Test
  public void test2(){
    String obj = null;
    switch(obj){
      case null -> System.out.println("is null");
      case String i-> System.out.println(i);
    }
  }

switch case语句

case标签匹配常量，在JDK21之前，经常通过if语句进行判断，而之后，增加了case语句的标签
case when 表达式作为扩展
另一种形式：可以通过常量，简化判断逻辑增加可读性

    @Test
    public void test1() {
        String str = "YES";
        switch (str) {
            case null -> {
            }
            case String s
                    when s.equalsIgnoreCase("YES") -> {
                System.out.println("YES");
            }
            case String s
                    when s.equalsIgnoreCase("NO") -> {
                System.out.println("NO");
            }
            case "A", "a" -> {
                System.out.println(str);
            }
            default -> {
                System.out.println("DEFAULT");
            }
        }

    }

swith和枚举常量

  改进枚举常量的大小写标签；
  扩展大小写标签，除常量外，还包括模式和null；
  扩展switch语句和switch表达式的选择器表达式允许的类型范围（以及对switch块的穷尽性进行所需的更丰富的分析）
  允许可选的when子句跟在case标签后面。

    @Test
    public void test5() {
         interface CardClassification  {}
         enum Suit implements CardClassification { CLUBS, DIAMONDS, HEARTS, SPADES }
        final class Tarot implements CardClassification {}
        CardClassification c = Suit.CLUBS;
        switch (c) {
            case Suit.CLUBS -> {
                System.out.println("It's clubs");
            }
            case Suit.DIAMONDS -> {
                System.out.println("It's diamonds");
            }
            case Suit.HEARTS -> {
                System.out.println("It's hearts");
            }
            case Suit.SPADES -> {
                System.out.println("It's spades");
            }
            case Tarot t -> {
                System.out.println("It's a tarot");
            }
            default -> throw new IllegalStateException("Unexpected value: " + c);
        }

    }

优化枚举常量case标签

  1、对于继承枚举，只允许具体的枚举名称
  2.对于指定具体的枚举类型，可以不用具体的枚举表达式

    public void test6(){
        interface Currency {}
        enum Coin implements Currency { HEADS, TAILS }
        Currency c = Coin.HEADS;
        Coin cc = Coin.HEADS;

        switch (cc) {
            case HEADS -> {
                System.out.println("Heads");
            }
            case Coin.TAILS -> {    // Unnecessary qualification but allowed
                System.out.println("Tails");
            }
        }

        switch (c) {
            case Coin.HEADS -> {
                System.out.println("Heads");
            }
            case TAILS -> {         // Error - TAILS must be qualified
                System.out.println("Tails");
            }
            default -> {
                System.out.println("Some currency");
            }
        }
    }

虚拟线程

虚拟线程是轻量级线程，可以显著减少编写、维护和观察高吞吐量并发应用程序的工作量

目标

• 使以简单的每个请求一个线程风格编写的服务器应用程序能够扩展到接近最佳的硬件利用率。
• 允许使用java.lang.Thread API的现有代码以最小的更改采用虚拟线程。
• 使用现有JDK工具对虚拟线程进行简单的故障排除、调试和分析。

官网地址：https://openjdk.org/projects/jdk/21/