JDK17的新特性

参考该篇文章    Java 17 新特性概述 | Java 全栈知识体系 (pdai.tech)

文章目录

• 前言
• 一、pandas是什么？
• 二、使用步骤
  • 1.引入库
  • 2.读入数据
• 总结

---

前言

参考上面那篇文章将现阶段会影响到自己使用的记录下来

---

一、pandas是什么？

示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。

二、使用步骤

1.语言特性增强

---

var 关键字

var和js中的var类似，可以自己推断出该变量的类型

var关键字只能用于局部变量，不能用于类的成员变量、方法参数、方法返回类型等。此外，var关键字在声明变量时必须同时进行初始化，因为通过初始化值来推断变量类型

sealed 修饰符

sealed：密封的类(class)和接口(interface)，用来增强Java编程语言，防止其他类或接口实现他们。只允许被指定的类或接口进行扩展和实现。

使用修饰符 sealed ，可以将一个类声明为密封类，密封类使用 permits 列出可以直接扩展他的类。子类的修饰符只能为三种，分别为 final，non-sealed，sealed。子类在三个修饰符之间必须选择一个不然会报错，而且需要定义构造方法。

final	子类声明为 final，表示这个类是最终的，不能再被其他类继承，确保该类没有子类。
non-sealed	子类声明为non-sealed，表示这个类是非密封的，也就是一个普通类，任何类可以继承。
sealed	子类声明为sealed，表示这个类是密封的，与上述相同。

代码如下：

// 之前定义类
public class Person { } //人
 
class Teacher extends Person { }//教师
 
class Worker extends Person { }  //工人
 
class Student extends Person{ } //学生


// 添加sealed修饰符，permits后面跟上只能被继承的子类名称
public sealed class Person permits Teacher, Worker, Student{ } //人
 
// 子类可以被修饰为 final
final class Teacher extends Person { }//教师
 
// 子类可以被修饰为 non-sealed，此时 Worker类就成了普通类，谁都可以继承它
non-sealed class Worker extends Person { }  //工人
// 任何类都可以继承Worker
class AnyClass extends Worker{}
 
//子类可以被修饰为 sealed,同上
sealed class Student extends Person permits MiddleSchoolStudent,GraduateStudent{ } //学生
 
 
final class MiddleSchoolStudent extends Student { }  //中学生
 
final class GraduateStudent extends Student { }  //研究生

---

2.工具库更新

增强的伪随机数生成器

JDK 17之前如何生成随机数？

1.Random 类

典型的使用如下，随机一个int值

// random int
new Random().nextInt();

/**
 * description 获取指定位数的随机数
 *
 * @param length 1
 * @return java.lang.String
 */
public static String getRandomString(int length) {
    String base = "abcdefghijklmnopqrstuvwxyz0123456789";
    Random random = new Random();
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < length; i++) {
        int number = random.nextInt(base.length());
        sb.append(base.charAt(number));
    }
    return sb.toString();
}

2.ThreadLocalRandom 类

提供线程间独立的随机序列。它只有一个实例，多个线程用到这个实例，也会在线程内部各自更新状态。它同时也是 Random 的子类，不过它几乎把所有 Random 的方法又实现了一遍。

/**
 * nextInt(bound) returns 0 <= value < bound; repeated calls produce at
 * least two distinct results
 */
public void testNextIntBounded() {
    // sample bound space across prime number increments
    for (int bound = 2; bound < MAX_INT_BOUND; bound += 524959) {
        int f = ThreadLocalRandom.current().nextInt(bound);
        assertTrue(0 <= f && f < bound);
        int i = 0;
        int j;
        while (i < NCALLS &&
               (j = ThreadLocalRandom.current().nextInt(bound)) == f) {
            assertTrue(0 <= j && j < bound);
            ++i;
        }
        assertTrue(i < NCALLS);
    }
}

3.SplittableRandom 类

非线程安全，但可以 fork 的随机序列实现，适用于拆分子任务的场景。

/**
 * Repeated calls to nextLong produce at least two distinct results
 */
public void testNextLong() {
    SplittableRandom sr = new SplittableRandom();
    long f = sr.nextLong();
    int i = 0;
    while (i < NCALLS && sr.nextLong() == f)
        ++i;
    assertTrue(i < NCALLS);
}

为什么需要增强？

1. 上述几个类实现代码质量和接口抽象不佳
2. 缺少常见的伪随机算法
3. 自定义扩展随机数的算法只能自己去实现，缺少统一的接口

增强后是什么样的？（这个该怎么使用不是很清楚，可以看一下这个链接Java 17 随机数生成器来了一波稳稳的增强 - 编程宝库 (codebaoku.com)http://www.codebaoku.com/it-java/it-java-224224.html）

代码的优化自不必说，我们就看下新增了哪些常见的伪随机算法

如何使用这个呢？可以使用RandomGenerator

RandomGenerator g = RandomGenerator.of("L64X128MixRandom");
System.out.println(g.nextInt());

3.新功能的预览和孵化API

新增switch模式匹配（预览版）

允许针对多个模式测试表达式，每个模式都有特定的操作，以便可以简洁安全地表达复杂的面向数据的查询。

例子：

对枚举类型进行匹配：

enum Season {
    SPRING, SUMMER, AUTUMN, WINTER
}

public class SwitchPatternMatchingExample {
    public static void main(String[] args) {
        Season season = Season.SUMMER;

        String result = switch (season) {
            case SPRING -> "春天";
            case SUMMER -> "夏天";
            case AUTUMN -> "秋天";
            case WINTER -> "冬天";
        };

        System.out.println(result);
    }
}

对集合类型进行匹配：

import java.util.List;

public class SwitchPatternMatchingExample {
    public static void main(String[] args) {
        List<Object> list = List.of(1, "Hello", 3.14);

        for (Object obj : list) {
            String result = switch (obj) {
                case Integer i -> "整数：" + i;
                case String str -> "字符串：" + str;
                case Double d -> "浮点数：" + d;
                default -> "未知类型";
            };

            System.out.println(result);
        }
    }
}

对异常类型进行匹配：

public class SwitchPatternMatchingExample {
    public static void main(String[] args) {
        try {
            // 执行可能抛出异常的代码
        } catch (Exception e) {
            String result = switch (e) {
                case NullPointerException npe -> "空指针异常";
                case IllegalArgumentException iae -> "非法参数异常";
                case IOException ioe -> "IO异常";
                default -> "其他异常";
            };

            System.out.println(result);
        }
    }
}

---

总结