JDK 新特性

自 1996 年发布以来，Java（JDK/Java SE）经历了多个主要版本，下面是一些关键版本的列表（其中 LTS 表示长期支持版本）：

JDK 1.0 (1996 年) AWT 窗口新特性
Java 的第一个稳定版本。

// 导入必要的 AWT 和事件处理相关的类
import java.awt.*;
import java.awt.event.*;

// 定义一个名为 JDK1Demo 的类，继承自 Frame 类
public class JDK1Demo extends Frame {

    // 构造器：展示面向对象的设计
    public JDK1Demo() {
        // 调用父类 Frame 的构造器，设置窗口标题为 "JDK 1.0 Demo"
        super("JDK 1.0 Demo");

        // 设置窗口大小为 400x300 像素
        setSize(400, 300);

        // 为窗口添加关闭事件（事件模型的基本应用）
        addWindowListener(new WindowAdapter() {
            // 重写 windowClosing 方法，当用户点击窗口关闭按钮时触发
            public void windowClosing(WindowEvent e) {
                // 调用 System.exit(0)，优雅地退出程序
                System.exit(0);
            }
        });
    }

    // 重写 paint 方法，用于绘制简单文本
    public void paint(Graphics g) {
        // 使用 Graphics 对象在窗口上绘制字符串
        // 在坐标 (150, 150) 处绘制文本 "Hello, JDK 1.0!"
        g.drawString("Hello, JDK 1.0!", 150, 150);
    }

    /**
     * 主方法：程序入口点
     * 展示标准输出、异常处理以及 AWT 窗口创建
     */
    public static void main(String[] args) {
        // 展示标准输出（JDK 1.0 的 I/O 库）
        // 打印一条消息，表明程序启动
        System.out.println("启动 JDK 1.0 Demo 程序...");

        // 演示简单的异常处理
        try {
            int x = 10;
            int y = 0; // 故意除以 0 产生异常
            int z = x / y; // 触发 ArithmeticException 异常
        } catch (ArithmeticException e) {
            // 捕获异常并打印异常信息
            System.out.println("捕获异常: " + e.getMessage());
        }

        // 创建并显示 AWT 窗口（JDK 1.0 引入的 AWT API）
        // 实例化 JDK1Demo 对象
        JDK1Demo demo = new JDK1Demo();
        // 设置窗口可见性为 true，显示窗口
        demo.setVisible(true);
    }
}

JDK 1.1 (1997 年)
引入了内嵌类、反射、RMI、JDBC 等新功能。

// 定义一个包含内嵌类和反射演示的类
public class InnerClassAndReflectionDemo {

    // 内嵌类：在 JDK 1.1 中引入，可以在一个类内部定义类
    // 内嵌类是外部类的一部分，可以访问外部类的所有成员（包括私有成员）
    class Inner {
        // 定义一个私有的字符串变量，存储内嵌类的消息
        private String message = "Hello from Inner Class!";

        // 定义一个公共方法，用于打印消息
        public void sayHello() {
            System.out.println(message);
        }
    }

    // 主方法：程序入口点
    public static void main(String[] args) {
        // 创建外部类的实例
        InnerClassAndReflectionDemo demo = new InnerClassAndReflectionDemo();

        // 创建内嵌类实例
        // 注意：内嵌类的实例必须依赖于外部类的实例来创建
        InnerClassAndReflectionDemo.Inner inner = demo.new Inner();

        // 调用内嵌类的方法，打印消息
        inner.sayHello();

        // 使用反射获取内嵌类的信息
        try {
            // 获取内嵌类的 Class 对象
            // getClass() 方法返回运行时对象的类信息
            Class<?> clazz = inner.getClass();

            // 打印内嵌类的名称
            // clazz.getName() 返回类的全限定名（包括包名和类名）
            System.out.println("内嵌类名称：" + clazz.getName());

            // 打印内嵌类中声明的所有方法
            System.out.println("方法列表：");
            for (java.lang.reflect.Method m : clazz.getDeclaredMethods()) {
                // m.getName() 返回方法的名称
                System.out.println("  " + m.getName());
            }
        } catch (Exception e) {
            // 捕获并处理可能的异常
            // 如果反射操作失败，会打印堆栈跟踪信息
            e.printStackTrace();
        }
    }
}

J2SE 1.2 (1998 年)
Java 2 平台诞生，推出了全新的集合框架和 Swing 图形库。

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.util.List;

public class J2SE12Demo {
    public static void main(String[] args) {
        // —— 集合框架示例 ——
        // 创建一个 ArrayList 来存储水果名称（J2SE 1.2 引入了全新的 Collection API）
        List<String> fruits = new ArrayList<>();
        // 向集合中添加元素
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // 使用 Collections 工具类对集合进行排序
        Collections.sort(fruits);

        // 输出排序后的集合内容
        System.out.println("Sorted Fruits:");
        for (String fruit : fruits) {
            // 遍历集合并打印每个水果名称
            System.out.println(fruit);
        }

        // —— Swing 图形库示例 ——
        // 使用 SwingUtilities.invokeLater 方法确保 GUI 创建在事件调度线程上运行
        // 这是 Swing 的最佳实践，保证线程安全
        SwingUtilities.invokeLater(() -> createAndShowGUI());
    }

    /**
     * 创建并显示图形用户界面（GUI）。
     */
    private static void createAndShowGUI() {
        // 创建一个 JFrame 窗口实例
        JFrame frame = new JFrame("J2SE 1.2 Swing Demo");
        // 设置窗口关闭操作：当用户点击窗口关闭按钮时退出程序
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // 设置窗口大小为 300x200 像素
        frame.setSize(300, 200);

        // 添加一个居中的标签到窗口中心区域
        JLabel label = new JLabel("Hello from Swing!", SwingConstants.CENTER);
        // 将标签添加到窗口的 BorderLayout.CENTER 区域
        frame.add(label, BorderLayout.CENTER);

        // 创建一个按钮，并设置其文本为 "Click Me"
        JButton button = new JButton("Click Me");
        // 为按钮注册一个事件监听器，当按钮被点击时触发事件处理逻辑
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 当按钮被点击时，弹出一个消息对话框
                JOptionPane.showMessageDialog(frame, "Button clicked!");
            }
        });
        // 将按钮添加到窗口的 BorderLayout.SOUTH 区域
        frame.add(button, BorderLayout.SOUTH);

        // 设置窗口可见
        frame.setVisible(true);
    }
}

J2SE 1.3 (2000 年)
引入了 HotSpot JVM 等改进。

public class HotSpotDemo {

    /**
     * 计算斐波那契数列的第 n 项
     * 
     * 说明：
     *  - 该方法使用循环而非递归计算斐波那契数列，既避免了递归带来的性能问题，
     *    也能通过反复调用形成“热点代码”，触发 HotSpot JIT 编译优化。
     *  - HotSpot JVM 会监控这个方法的调用次数，当其被频繁调用时，
     *    会将字节码编译成本机机器码，从而大幅提升执行效率。
     *
     * @param n 要计算的斐波那契数列项数
     * @return 斐波那契数列的第 n 项
     */
    public static long fibonacci(int n) {
        if (n <= 1) return n;  // 基本情况：当 n 为 0 或 1 时，直接返回 n
        
        // 使用两个变量 a 和 b 分别表示前两项
        long a = 0, b = 1, sum = 0;
        // 从第 2 项开始循环计算，直到第 n 项
        for (int i = 2; i <= n; i++) {
            sum = a + b;  // 当前项等于前两项之和
            a = b;        // 更新 a 为上一项
            b = sum;      // 更新 b 为当前项
        }
        return b;  // 返回计算结果，即斐波那契数列的第 n 项
    }
    
    public static void main(String[] args) {
        // J2SE 1.3 引入了 HotSpot JVM，
        // HotSpot 通过监控方法的调用频率，将频繁调用的“热点代码”
        // 编译为本机代码（JIT 编译），大幅提升了程序的执行性能。
        // 为了触发 JIT 编译，我们在下面的循环中多次调用 fibonacci() 方法。

        int n = 45;           // 选择一个较大的 n 值，以增加计算量
        int iterations = 20;    // 多次调用以使方法成为热点，从而触发 JIT 编译
        long startTime = System.currentTimeMillis();  // 记录开始时间
        
        long result = 0;
        // 重复多次调用 fibonacci() 方法，模拟“热点代码”
        for (int i = 0; i < iterations; i++) {
            result = fibonacci(n);
        }
        
        long endTime = System.currentTimeMillis();    // 记录结束时间
        
        // 输出计算结果和总执行时间
        System.out.println("Fibonacci(" + n + ") = " + result);
        System.out.println("Total time for " + iterations + " iterations: " + (endTime - startTime) + " ms");
        
        /*
         * 详细说明：
         * 1. 在 J2SE 1.3 之前的 JVM 中，代码通常都是逐行解释执行，性能较低。
         * 2. J2SE 1.3 引入了 HotSpot JVM，该虚拟机在程序运行期间会监控每个方法的调用次数，
         *    当某个方法被频繁调用（成为“热点代码”）时，HotSpot 会自动将其编译成本机代码，
         *    这样后续对该方法的调用就能直接执行本机代码，从而显著提升执行速度。
         * 3. 本示例中，fibonacci() 方法在循环中被调用多次，
         *    就会触发 HotSpot 的 JIT 编译，将该方法优化为高效的本机代码执行。
         * 4. 这种运行时的动态编译技术正是 J2SE 1.3 引入 HotSpot JVM 带来的重要改进，
         *    使得 Java 应用程序在性能上得到了大幅提升。
         */
    }
}
import org.openjdk.jmh.annotations.*;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
//表示所有测试线程共享同一个状态实例，避免多线程竞争干扰测试结果适用于测试全局共享资源（如静态变量、单例对象）的性能影响
@State(Scope.Benchmark)
//指定测试模式为“平均每次操作耗时”，单位为纳秒（由@OutputTimeUnit定义）。
//​其他模式：Throughput（吞吐量）、SampleTime（采样时间分布）、SingleShotTime（冷启动时间）等
@BenchmarkMode(Mode.AverageTime)
//设置测试结果的时间单位，此处为纳秒，便于观察细微性能差异
@OutputTimeUnit(TimeUnit.NANOSECONDS)
//​预热（@Warmup）​：执行5轮，每轮1秒。目的是让JVM完成JIT编译优化、缓存预热，消除冷启动误差
@Warmup(iterations = 20, time = 1, timeUnit = TimeUnit.SECONDS)
//​测量（@Measurement）​：执行10轮，每轮1秒。正式采集性能数据阶段，结果基于此计算
@Measurement(iterations = 10, time = 1, timeUnit = TimeUnit.SECONDS)
//启动2个独立的JVM进程运行测试，隔离环境干扰（如类加载、JIT优化差异）。
//​重要性：避免单进程测试中JVM优化策略对多次测试结果的影响
@Fork(value = 2)
public class HotSpotDemo {
//​作用：参数化测试，此处定义n=40用于斐波那契计算。支持多参数（如{"10", "20", "40"}），对比不同输入下的性能
    @Param({"40"}) // 定义基准测试的参数值
    private int n;
//作用：标记待测试的方法（fibonacci()）。JMH会对其自动生成性能测试代码，并多次调用以采集数据。
    @Benchmark
    public long fibonacci() {
        long startTime = System.currentTimeMillis();  // 记录开始时间
        if (n <= 1) return n; // 基本情况：当 n 为 0 或 1 时，直接返回 n
        // 使用两个变量 a 和 b 分别表示前两项
        long a = 0, b = 1, sum = 0;

        // 从第 2 项开始循环计算，直到第 n 项
        for (int i = 2; i <= n; i++) {
            sum = a + b; // 当前项等于前两项之和
            a = b;       // 更新 a 为上一项
            b = sum;     // 更新 b 为当前项
        }
        long endTime = System.currentTimeMillis();    // 记录结束时间
        // 输出计算结果和总执行时间

        return b; // 返回计算结果，即斐波那契数列的第 n 项
    }
    public static void main(String[] args) throws IOException {

        org.openjdk.jmh.Main.main(args);


    }
}

J2SE 1.4 (2002 年)
增加了正则表达式、NIO、断言等语言和 API 改进。

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
import java.nio.file.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class J2SE14Demo {
    public static void main(String[] args) {
        // ---------------------------
        // 演示断言（assertions）
        // ---------------------------
        // 断言是一个简单的调试工具，用来检查程序运行时是否满足某个条件。
        // 如果断言条件为 false，则会抛出 AssertionError。
        // 注意：要让断言生效，启动 JVM 时需要加上 -ea 参数（enable assertions）。
        int number = 10;
        // 断言 number 必须大于 0，否则会抛出 AssertionError，并输出错误信息
        assert number > 0 : "number 必须大于 0";
        System.out.println("断言检查通过，number = " + number);

        // ---------------------------
        // 演示正则表达式 API
        // ---------------------------
        // J2SE 1.4 引入了 java.util.regex 包，用于支持正则表达式操作。
        // 这里定义一个简单的正则表达式，匹配电子邮件地址格式。
        String emailRegex = "^[A-Za-z0-9+_.-]+@(.+)$";
        Pattern emailPattern = Pattern.compile(emailRegex);
        String email = "example@test.com";
        // 通过 Pattern 对象创建 Matcher 对象，用于对字符串进行匹配操作
        Matcher matcher = emailPattern.matcher(email);
        if (matcher.matches()) {
            System.out.println(email + " 是一个合法的电子邮件地址。");
        } else {
            System.out.println(email + " 不是一个合法的电子邮件地址。");
        }

        // ---------------------------
        // 演示 NIO API（New I/O）
        // ---------------------------
        // J2SE 1.4 引入了 NIO（New I/O）库，用于改进文件和数据的输入/输出操作。
        // 下面示例使用 Files 类读取整个文件内容，然后使用 FileChannel 及 ByteBuffer 进行低级别的读取。

        // 示例1：使用 Files.readAllBytes 读取文件内容（需指定编码）
        Path filePath = Paths.get("sample.txt"); // 假设 sample.txt 文件存在于当前目录
        try {
            // Files.readAllBytes 会将文件全部读取为字节数组
            byte[] fileBytes = Files.readAllBytes(filePath);
            // 将字节数组转换为字符串，指定 UTF-8 编码
            String fileContent = new String(fileBytes, Charset.forName("UTF-8"));
            System.out.println("使用 Files.readAllBytes 读取的文件内容：");
            System.out.println(fileContent);
        } catch (IOException e) {
            System.err.println("读取文件时发生异常: " + e.getMessage());
        }

        // 示例2：使用 NIO 的 FileChannel 和 ByteBuffer 读取文件内容
        try {
            // 打开文件通道，指定为只读模式
            FileChannel channel = FileChannel.open(filePath, StandardOpenOption.READ);
            // 分配一个容量为 1024 字节的 ByteBuffer
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            System.out.println("使用 FileChannel 和 ByteBuffer 读取文件内容：");
            // 循环读取文件数据，直到文件末尾
            while (channel.read(buffer) > 0) {
                buffer.flip(); // 切换 ByteBuffer 到读取模式
                // 使用指定编码将 ByteBuffer 中的字节解码为字符串
                String data = Charset.forName("UTF-8").decode(buffer).toString();
                System.out.print(data);
                buffer.clear(); // 清空 ByteBuffer 为下次读取做准备
            }
            channel.close(); // 关闭文件通道
        } catch (IOException e) {
            System.err.println("使用 NIO 读取文件时发生异常: " + e.getMessage());
        }
    }
}

J2SE 5.0 (Tiger, 2004 年)
实际上内部版本号为 1.5，引入了泛型、枚举、注解、自动装箱/拆箱、增强的 for 循环等现代化特性。

// 自定义注解：在 JDK 5.0 中引入了注解机制。
// 这里定义了一个简单的注解 @MyAnnotation，它保留在运行时。
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.List;

@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
    String value();
}

// 定义枚举类型：JDK 5.0 正式引入了枚举类型。
// 下面定义了一个表示星期的枚举类型 Day。
enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY;
}

public class TigerDemo {

    // 使用自定义注解标注方法：注解是 JDK 5.0 的新特性之一。
    @MyAnnotation("示例方法：展示增强 for 循环遍历枚举集合")
    public void displayDays(List<Day> days) {
        // 增强的 for 循环（foreach）：使得遍历集合更加简洁易读。
        for (Day day : days) {
            System.out.println("Day: " + day);
        }
    }

    public static void main(String[] args) {
        TigerDemo demo = new TigerDemo();

        // 使用泛型创建 List 对象，存储枚举类型 Day
        // 泛型提供了编译时的类型检查，提高了代码的安全性
        java.util.List<Day> weekDays = new java.util.ArrayList<Day>();
        weekDays.add(Day.MONDAY);
        weekDays.add(Day.TUESDAY);
        weekDays.add(Day.WEDNESDAY);
        weekDays.add(Day.THURSDAY);
        weekDays.add(Day.FRIDAY);

        // 调用使用注解标注的方法展示增强 for 循环的效果
        demo.displayDays(weekDays);

        // 自动装箱/拆箱示例：
        // 自动装箱：将基本数据类型自动转换为对应的包装类型
        // 自动拆箱：将包装类型自动转换为对应的基本数据类型
        Integer a = 100;  // 自动装箱：int 100 -> Integer 对象
        Integer b = 200;  // 自动装箱
        int sum = a + b;  // 自动拆箱：Integer 转 int 进行加法操作
        System.out.println("Sum = " + sum);

        // 泛型示例：使用泛型创建一个存储 String 的集合，避免类型转换错误
        java.util.List<String> list = new java.util.ArrayList<String>();
        list.add("Hello");
        list.add("Tiger");

        // 增强的 for 循环遍历泛型集合
        for (String s : list) {
            System.out.println("String: " + s);
        }

        // 通过反射读取方法上定义的注解信息
        try {
            // 获取 TigerDemo 类中名为 displayDays 的方法
            java.lang.reflect.Method method = TigerDemo.class.getMethod("displayDays", java.util.List.class);
            // 检查该方法是否有 @MyAnnotation 注解
            if (method.isAnnotationPresent(MyAnnotation.class)) {
                MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
                System.out.println("Method displayDays() has annotation with value: " + annotation.value());
            }
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
}
            <!-- JMH Core -->
            <dependency>
                <groupId>org.openjdk.jmh</groupId>
                <artifactId>jmh-core</artifactId>
                <version>1.36</version> <!-- 确保使用最新版本 -->
            </dependency>

            <!-- JMH Annotations -->
            <dependency>
                <groupId>org.openjdk.jmh</groupId>
                <artifactId>jmh-generator-annprocess</artifactId>
                <version>1.36</version> <!-- 版本需与 jmh-core 一致 -->
                <scope>provided</scope>
            </dependency>

Java SE 6 (Mustang, 2006 年)
对性能、脚本支持和 GUI 等进行了大量优化。

//===========================js脚本=========================

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class ScriptEngineDemo {
    public static void main(String[] args) throws ScriptException {
        // 获取脚本引擎管理器（新特性：JSR 223 标准化脚本支持）[9,10](@ref)
        ScriptEngineManager manager = new ScriptEngineManager();
        // 获取 JavaScript 引擎（默认支持 Rhino 引擎）[1,11](@ref)
        ScriptEngine engine = manager.getEngineByName("javascript");

        // 执行 JavaScript 脚本（可在 Java 中直接调用脚本语言）
        engine.eval("var result = Math.pow(2, 10);");
        Object result = engine.get("result");
        System.out.println("JavaScript 计算结果: " + result); // 输出 1024.0
    }
}
        <dependency>
            <groupId>org.openjdk.nashorn</groupId>
            <artifactId>nashorn-core</artifactId>
            <version>15.4</version>
        </dependency>

//============================python脚本====================

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class PythonScriptEngineDemo {
    public static void main(String[] args) throws ScriptException {
        // 获取脚本引擎管理器
        ScriptEngineManager manager = new ScriptEngineManager();
        // 获取 Python 引擎（需要 Jython 支持）
        ScriptEngine engine = manager.getEngineByName("python");

        if (engine == null) {
            System.out.println("未找到 Python 脚本引擎，请确保已正确配置 Jython！");
            return;
        }

        // 执行 Python 脚本
        engine.eval("result = 2 ** 10");
        Object result = engine.get("result");
        System.out.println("Python 计算结果: " + result); // 输出 1024
    }
}
          <!-- Jython 依赖 -->
            <dependency>
                <groupId>org.python</groupId>
                <artifactId>jython-standalone</artifactId>
                <version>2.7.3</version> <!-- 使用最新稳定版本 -->
            </dependency>

//=======================添加到系统托盘===============
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class SystemTrayDemo {
    public static void main(String[] args) {
        // 检查系统托盘支持（新特性：SystemTray 和 TrayIcon 类）[1,2](@ref)
        if (!SystemTray.isSupported()) {
            System.out.println("系统托盘不支持");
            return;
        }

        // 创建托盘图标并绑定弹出菜单
        TrayIcon trayIcon = new TrayIcon(new ImageIcon("icon.png").getImage());
        SystemTray tray = SystemTray.getSystemTray();

        PopupMenu menu = new PopupMenu();
        MenuItem exitItem = new MenuItem("退出");
        exitItem.addActionListener(e -> System.exit(0));
        menu.add(exitItem);
        trayIcon.setPopupMenu(menu);

        // 添加托盘图标到系统托盘（支持 Windows/Linux 原生集成）[2,12](@ref)
        try {
            tray.add(trayIcon);
        } catch (AWTException e) {
            e.printStackTrace();
        }
    }
}
//================================动态java类=======================

import javax.tools.*;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URI;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class CompilerAPIDemo {
    public static void main(String[] args) {
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        String code = "public class DynamicClass { public static void hello() { System.out.println(\"动态编译成功！\"); }}";

        // 使用自定义类加载器
        MemoryClassLoader classLoader = new MemoryClassLoader();

        // 配置文件管理器
        StandardJavaFileManager stdFileManager = compiler.getStandardFileManager(null, null, null);
        JavaFileManager fileManager = new ForwardingJavaFileManager<JavaFileManager>(stdFileManager) {
            @Override
            public JavaFileObject getJavaFileForOutput(Location location,
                                                       String className,
                                                       JavaFileObject.Kind kind,
                                                       FileObject sibling) throws IOException {
                // 仅处理CLASS_OUTPUT位置的类文件
                if (location == StandardLocation.CLASS_OUTPUT) {
                    MemoryJavaFileObject file = new MemoryJavaFileObject(className, kind);
                    classLoader.addClass(className, file);
                    return file;
                }
                return super.getJavaFileForOutput(location, className, kind, sibling);
            }
        };

        // 创建源代码文件对象
        JavaFileObject srcFile = new SimpleJavaFileObject(URI.create("string:///DynamicClass.java"), JavaFileObject.Kind.SOURCE) {
            @Override
            public CharSequence getCharContent(boolean ignore) {
                return code;
            }
        };

        // 执行编译任务
        Boolean result = compiler.getTask(null, fileManager, null, null, null, Collections.singletonList(srcFile)).call();

        if (result != null && result) {
            try {
                // 加载并执行动态类
                Class<?> cls = classLoader.loadClass("DynamicClass");
                cls.getMethod("hello").invoke(null);
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            System.out.println("编译失败");
        }
    }
}

// 增强的内存文件对象（记录完整类名）
class MemoryJavaFileObject extends SimpleJavaFileObject {
    private final String className;
    private final ByteArrayOutputStream bos = new ByteArrayOutputStream();

    public MemoryJavaFileObject(String className, Kind kind) {
        super(URI.create("memory:///" + className.replace('.', '/') + kind.extension), kind);
        this.className = className;
    }

    @Override
    public OutputStream openOutputStream() {
        return bos;
    }

    public byte[] getBytes() {
        return bos.toByteArray();
    }

    public String getClassName() {
        return className;
    }
}

// 改进的类加载器实现
class MemoryClassLoader extends ClassLoader {
    private final Map<String, MemoryJavaFileObject> classMap = new HashMap<>();

    public void addClass(String className, MemoryJavaFileObject file) {
        classMap.put(className, file);
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        MemoryJavaFileObject file = classMap.get(name);
        if (file != null) {
            byte[] bytes = file.getBytes();
            return defineClass(name, bytes, 0, bytes.length);
        }
        return super.findClass(name);
    }
//========================================阈值警告=========================

import javax.management.*;
import java.lang.management.ManagementFactory;

public class JMXMonitoringDemo {
    public static void main(String[] args) throws Exception {
        MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
        ObjectName name = new ObjectName("com.example:type=Monitor");

        // 使用正确命名的 MBean 接口
        MonitorImpl monitor = new MonitorImpl();
        StandardMBean mbean = new StandardMBean(monitor, MonitorMBean.class);
        mbs.registerMBean(mbean, name);

        // 值测试触发阈
        monitor.setValue(150);
    }

    // 正确命名的 MBean 接口
    public interface MonitorMBean {
        int getValue();
        void setValue(int value);
    }

    // 实现类在同一包中
    public static class MonitorImpl implements MonitorMBean {
        private int value = 0;
        @Override public int getValue() {
            return value;
        }
        @Override public void setValue(int value) {
            if (value > 100) {
                System.out.println("触发阈值警告");
            }
            this.value = value;
        }
    }
}
//=========================webf服务=============================
import com.sun.net.httpserver.HttpServer;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpExchange;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;

public class SimpleHttpServer {
    public static void main(String[] args) throws IOException {
        // 创建一个 HttpServer 实例，监听端口 8000
        HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);
        // 创建一个上下文，并指定处理器
        server.createContext("/test", new MyHandler());
        // 启动服务器
        server.setExecutor(null); // 使用默认的执行器
        server.start();
        System.out.println("Server started on port 8000");
    }

    // 定义一个处理器，用于处理客户端请求
    static class MyHandler implements HttpHandler {
        @Override
        public void handle(HttpExchange exchange) throws IOException {
            String response = "This is the response";
            exchange.sendResponseHeaders(200, response.length());
            OutputStream os = exchange.getResponseBody();
            os.write(response.getBytes());
            os.close();
        }
    }
}

Java SE 7 (Dolphin, 2011 年)
引入了字符串 switch、二进制字面量、try-with-resources、钻石操作符等新语法和 API 改进。

public class StringSwitchDemo {
    public static void main(String[] args) {
        String day = "MONDAY";

        switch (day) {
            case "MONDAY":
                System.out.println("周一：开启搬砖模式");
                break;
            case "FRIDAY":
                System.out.println("周五：等待周末");
                break;
            default:
                System.out.println("其他日期");
        }
    }
}

//===================二进制====================
public class BinaryLiteralDemo {
    public static void main(String[] args) {
        // 二进制表示
        int binaryVal = 0b1010;     // 等价于十进制的 10
        byte byteMask = 0b00101101; // 用于位掩码操作
        
        System.out.println("二进制 1010 → 十进制: " + binaryVal);
        System.out.println("字节掩码: " + Integer.toBinaryString(byteMask));
        
        // 位运算示例
        int result = binaryVal & byteMask;
        System.out.println("位与运算结果: " + Integer.toBinaryString(result));
    }
}
=======================读取文本===================
import java.io.*;

public class TryWithResourcesDemo {
    public static void main(String[] args) {
        // 自动关闭文件流（Java 7 前需手动关闭）
        try (FileInputStream fis = new FileInputStream("C:\\aait.txt");
             BufferedReader br = new BufferedReader(new InputStreamReader(fis))) {

            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
==================================泛型==================
import java.util.*;

public class DiamondOperatorDemo {
    public static void main(String[] args) {
        // Java 7 前需重复声明泛型类型
        List<String> oldList = new ArrayList<String>();

        // Java 7 后通过 <> 自动推断类型
        List<String> newList = new ArrayList<>();  // 编译器推断为 ArrayList<String>

        Map<String, List<Integer>> complexMap = new HashMap<>(); // 嵌套泛型同样支持
    }
}
========================数字可读性====================
public class UnderscoreInNumbers {
    public static void main(String[] args) {
        long creditCardNumber = 1234_5678_9012_3456L;  // 提高可读性
        int million = 1_000_000;                        // 等同于 1000000

        System.out.println("信用卡号: " + creditCardNumber);
        System.out.println("百万级数值: " + million);
    }
}

Java SE 8 (2014 年)
带来了 Lambda 表达式、Stream API、默认方法、Optional 类、新的日期时间 API 等变革性特性。

=======================Lambda 表达式==========================
public class Lambda {

    // 定义一个字符串列表
    List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

    public void a() {

        Collections.sort(names, (a, b) -> a.length() - b.length());

        System.out.println("使用 Lambda 表达式排序后的结果: " + names);
    }

    public static void main(String[] args) {
        // 创建 Lambda 类实例并调用方法 a()
        new Lambda().a();
    }
}
==============================stream====================
public class stream{



    public void a() {
        List<Employee> employees = Arrays.asList(
                new Employee("Alice", 28, 8000),
                new Employee("Bob", 35, 12000),
                new Employee("Charlie", 22, 6000)
        );

// 筛选薪资>7000的员工并按年龄排序
        List<Employee> result = employees.stream()
                .filter(es -> es.getSalary() > 7000)     // 中间操作：过滤
                .sorted(Comparator.comparingInt(Employee::getAge)) // 中间操作：排序
                .collect(Collectors.toList());             // 终端操作：收集结果

        System.out.println(result); // 输出：[Bob(35), Alice(28)]
    }

    public static void main(String[] args) {
        // 创建 Lambda 类实例并调用方法 a()
        new stream().a();
    }
}
===============================Stream API=========================
List<String> words = Arrays.asList("Java", "Python", "C++", "JavaScript");

// 过滤、映射、收集结果（网页9示例）
List<String> filtered = words.stream()
    .filter(s -> s.startsWith("J"))   // 过滤以 J 开头的字符串
    .map(String::toUpperCase)         // 转为大写
    .collect(Collectors.toList());     // 收集为 List
System.out.println(filtered); // 输出 [JAVA, JAVASCRIPT]

// 归约操作（网页11示例）
int sum = Arrays.asList(1, 2, 3, 4).stream().reduce(0, Integer::sum);
System.out.println(sum); // 输出 10
================================接口默认方法与静态方法=================
// 定义接口（网页12示例）
interface Moveable {
    default void move() {
        System.out.println("默认移动方式");
    }
    static void staticMethod() {
        System.out.println("接口静态方法");
    }
}

// 实现类（网页13示例）
class Car implements Moveable {
    public static void main(String[] args) {
        Car car = new Car();
        car.move();              // 调用默认方法，输出 "默认移动方式"
        Moveable.staticMethod(); // 调用静态方法，输出 "接口静态方法"
    }
}
==============================Optional 类=================
// 避免空指针（网页15示例）
String name = null;
Optional<String> optName = Optional.ofNullable(name);
String result = optName.orElse("默认值"); // 若为 null 则返回 "默认值"
System.out.println(result); 

// 链式操作（网页16示例）
Optional.of("hello")
    .map(s -> s.toUpperCase())
    .ifPresent(System.out::println); // 输出 "HELLO"

==========================新的日期时间 API=======================
// 获取当前日期和时间（网页19示例）
        LocalDate today = LocalDate.now();
        LocalDateTime now = LocalDateTime.now();
        System.out.println("当前日期: " + today); // 如 2025-03-31
        System.out.println("当前时间: " + now);   // 如 2025-03-31T15:30:45.123

// 日期计算（网页20示例）
        LocalDate nextWeek = today.plusDays(7);
        Period period = Period.between(today, nextWeek);
        System.out.println("间隔天数: " + period.getDays()); // 输出 7

// 格式化（网页19示例）
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy");
        String formatted = today.format(formatter);
        System.out.println("格式化日期: " + formatted); // 如 31/03/2025

Java SE 9 (2017 年)
重点推出了模块系统（Project Jigsaw）以及 JShell 等功能。

 ========================核心机制==============
module com.example.payment {
    requires java.sql;          // 强制依赖
    requires static lombok;    // 编译时可选依赖
    exports com.example.api;    // 公开 API
    opens com.example.internal; // 开放反射访问权限
}
================JShell（交互式 REPL 工具）==============
(base) PS C:\ALL\Code\JAVA\study> jshell
|  欢迎使用 JShell -- 版本 17
|  要大致了解该版本, 请键入: /help intro
jshell> int x = 10;
x ==> 10

jshell> x * 2
$2 ==> 20

jshell> System.out.println("Hello, World!");
Hello, World!
jshell> List.of("Java", "Python").stream().filter(s -> s.startsWith("J")).collect(Collectors.toList())
$3 ==> [Java]


====================不可变集合创建==========================
        List<String> list = List.of("A", "B");  // 不可修改
        Map<String, Integer> map = Map.of("Key1", 1, "Key2", 2);
        System.out.println(list);
==========高性能网络请求：替代过时的 HttpURLConnection，支持异步和 WebSocket==
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://d-mr.cn"))
                .build();

        client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .thenApply(HttpResponse::body)
                .thenAccept(System.out::println)
                .join(); // 等待异步任务完成
    }
=============接口私有方法==============
interface Logger {
    default void log(String message) {
        formatMessage(message);
    }
    private void formatMessage(String msg) {
        System.out.println("[INFO] " + msg);
    }
}
================Stream API 增强=============
        List<Integer> nums = List.of(2, 4, 6, 8, 9);
        List<Integer> evenBeforeOdd = nums.stream()
                .takeWhile(n -> n % 2 == 0)
                .collect(Collectors.toList()); // [2, 4, 6, 8]
        System.out.println(evenBeforeOdd);

===========模块化迁移的挑战与解决方案========
​//第三方库兼容性：非模块化 JAR 自动转换为模块（命名基于文件名，如 guava-31.0.jar → //guava）。
​//反射框架适配：需在 module-info.java 中显式开放包权限
opens com.example.entities to hibernate.core;

Java SE 10 (2018 年)
引入了局部变量类型推断（var）和应用类数据共享。供多个 JVM 进程复用，减少类加载和解析开销

局部变量类型推断（var 关键字）​
var num = 10;          // 推断为 int
var list = new ArrayList<String>();  // 推断为 ArrayList<String>

​链式表达式简化：
在流处理中，可减少冗余的类型声明：
java
var squaredList = numbers.stream()
                         .map(n -> n * n)
                         .collect(Collectors.toList());  // 推断为 List<Integer>
``` [3,6](@ref)

​增强 for 循环：
java
for (var item : list) { ... }  // item 类型由 list 元素推断
``` [4](@ref)

List<String> copy = List.copyOf(originalList);  // 原集合修改不影响副本[4](@ref)

Java SE 11 (2018 年, LTS)
作为长期支持版本，增加了 HTTP 客户端 API、单文件运行等功能。

============HTTP/2客户端API（标准化）===========
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder().uri(URI.create("https://d-mr.cn")).build();
client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
      .thenApply(HttpResponse::body)
      .thenAccept(System.out::println);  // 异步处理响应
================单文件源代码直接运行===========
java HelloWorld.java  # 直接运行，自动编译并执行
============语言与API增强============
List<String> immutableList = List.copyOf(existingList);  // 深拷贝生成不可变集合
===============​Lambda参数类型推断支持var================
Predicate<String> predicate = (var s) -> s.length() > 5;  // 显式类型推断
====================模块化与安全增强=============
module com.example.app {
    requires java.base;
    exports com.example.api;
}
==============​TLS 1.3支持===========
提升加密通信性能与安全性，减少握手延迟（如HTTPS连接速度提升40%）

Java SE 12 (2019 年)
预览了 Switch 表达式等新语法改进，同时引入了部分 JVM 优化。

===消除 Fall-Through 风险
使用箭头语法 -> 替代冒号 :，默认不穿透执行，避免因漏写 break 导致的逻辑错误==
// 传统写法（需显式 break）
switch (day) {
    case MONDAY: 
        System.out.println("工作日");
        break;
    case SATURDAY, SUNDAY: 
        System.out.println("休息日");
        break;
}

// Java 12 箭头语法（自动阻断穿透）
switch (day) {
    case MONDAY -> System.out.println("工作日");
    case SATURDAY, SUNDAY -> System.out.println("休息日");
}
======支持表达式返回值==========
String type = switch (day) {
    case MONDAY, TUESDAY -> "Weekday";
    case SATURDAY        -> "Weekend";
    default              -> "Unknown";
};

==========多值匹配与代码块支持=======
String result = switch (num) {
    case 0, 1 -> "Binary Digit";
    case 2 -> {
        System.out.println("Processing 2");
        yield "Even Prime";
    }
    default -> "Other";
};

========Collectors 新增 teeing() 方法取平均值===========
Map<String, Double> stats = Stream.of(1, 2, 3)
    .collect(Collectors.teeing(
        Collectors.summingInt(Integer::intValue),
        Collectors.counting(),
        (sum, count) -> Map.of("avg", sum / count.doubleValue())
    ));

Java SE 13 (2019 年)
对文本块和动态 CDS 归档做出改进。

=======文本块（Text Blocks，预览特性）========
//Java 13 首次引入文本块语法，通过三引号 """ 定义多行字符串，解决传统字符串转义和拼接的复杂性，尤其适合处理HTML、SQL、JSON等结构化文本。
//自动换行处理
String html = """
              <html>
                  <body>
                      <p>Hello, World</p>
                  </body>
              </html>
              """;
//等价于传统写法
String html = "<html>\n    <body>\n        <p>Hello, World</p>\n    </body>\n</html>\n";
//智能缩进处理：文本块自动对齐左侧缩进，末尾三引号的位置决定最终格式。例如网页7中的SQL语句：
String sql = """
             SELECT id, name, email
             FROM customers
             WHERE id > 4
             ORDER BY email DESC
             """;
//​转义简化：内嵌双引号无需转义，直接书写：
String json = """
              {
                  "name": "张三",
                  "age": 25
              }
              """;
//其他协同改进
​Switch表达式增强：作为文本块之外的预览特性，支持通过yield返回值，简化多分支逻辑（需配合--enable-preview启用）：
int value = switch (input) {
    case "A" -> 1;
    case "B" -> 2;
    default  -> {
        yield -1;
    }
};

Java SE 14 (2020 年)
正式推出了 Switch 表达式、以及 instanceof 模式匹配和 Records 的预览功能。

==============Switch 表达式（正式特性）==========
// 传统写法（需显式 break）
switch (day) {
    case MONDAY: 
        System.out.println("工作日");
        break;
    case SATURDAY, SUNDAY: 
        System.out.println("休息日");
        break;
}

// Java 14 箭头语法
String type = switch (day) {
    case MONDAY, FRIDAY -> "Weekday";
    case SATURDAY       -> "Weekend";
    default             -> "Unknown";
};
============支持 yield 返回值==============
int result = switch (num) {
    case 0, 1 -> 0;
    case 2 -> {
        System.out.println("Processing 2");
        yield 2;
    }
    default -> -1;
};
============instanceof 模式匹配（预览特性）​===========
// 传统写法
if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

// Java 14 模式匹配
if (obj instanceof String s) {
    System.out.println(s.length()); // 直接使用变量 s
}

==================作用域限定与逻辑增强======
if (obj instanceof String s && s.length() > 5) {
    // 仅当 obj 是 String 且长度大于5时执行
}
=============Records（预览特性）===============
自动生成 equals()、hashCode() 和 toString() 方法：
public record Point(double x, double y) { }
// 等价于传统类定义
public class Point {
    private final double x;
    private final double y;
    // 构造方法、getter、equals、hashCode、toString自动生成
}
=============验证与扩展================
public record Range(int min, int max) {
    public Range {
        if (min > max) throw new IllegalArgumentException("Invalid range");
    }
}

Java SE 15 (2020 年)
文本块正式化、Sealed 类预览、ZGC 的进一步改进等。

============文本块正式化编译器自动去除多余空白，保留内容对齐=========
String json = """
            {
                "name": "Java 15",
                "version": "15"
            }
            """;
===========支持直接嵌入双引号，无需转义，====
String query = """
              SELECT "id", "name" FROM "users"
              WHERE "city" = 'Shanghai'
              """;
```
===========Sealed 类（预览特性）=========
声明方式：仅允许permits列表中的子类继承

public sealed class Shape permits Circle, Square, Rectangle { }
子类约束：
子类必须声明为final、sealed或non-sealed
public final class Circle extends Shape { }  // 禁止进一步扩展
public non-sealed class Square extends Shape { }  // 允许任意扩展
```  
============instanceof===========
if (obj instanceof String s && s.length() > 5) {
    System.out.println(s.toUpperCase());
}
```
==========Hidden Classes======
MethodHandles.Lookup lookup = MethodHandles.lookup();
Class<?> hiddenClass = lookup.defineHiddenClass(bytecode, true).lookupClass();
```
=============外部内存访问API======
try (MemorySegment segment = MemorySegment.allocateNative(100)) {
    segment.asByteBuffer().putInt(0, 42);  // 直接写入堆外内存
}
```

Java SE 16 (2021 年)
Records、模式匹配 instanceof、Stream.toList()、Vector API 孵化等特性逐步成熟。

==========Records（正式特性）Records 提供了一种简洁定义不可变数据类的方式，自动生成构造器、equals()、hashCode() 和 toString() 方法，大幅减少样板代码==========
public record Point(int x, int y) { }
============模式匹配 instanceof（正式特性）​============
if (obj instanceof String s && s.length() > 5) {
    System.out.println(s.toUpperCase());
}
==========Stream API 增强============
// 传统方式（可变列表）
List<String> list1 = stream.collect(Collectors.toList());
// Java 16新方式（不可变列表）
List<String> list2 = stream.toList();
=============Vector API（孵化特性）=============
var a = FloatVector.fromArray(SPECIES, array1, 0);
var b = FloatVector.fromArray(SPECIES, array2, 0);
var c = a.add(b).intoArray(result, 0);
============​Sealed Classes（预览特性）Sealed Classes（预览特性）​通过sealed和permits限制类的继承范围，增强领域模型的安全性（==========
public sealed class Shape permits Circle, Square { }

Java SE 17 (2021 年, LTS)
Sealed 类正式、移除 Applet API 等，是目前广泛使用的 LTS 版本之一。

===============Sealed 类（正式特性）===========
public sealed class Shape permits Circle, Square, Triangle { }
public final class Circle extends Shape { }  // 禁止进一步继承
public non-sealed class Square extends Shape { }  // 允许任意扩展

Java SE 18 (2022 年)
进一步优化了语言和平台特性，例如 UTF-8 默认字符集、简单 Web 服务器等。

简单 Web 服务器（JEP 408）
jwebserver -p 9000 -d /tmp  # 监听端口9000，服务/tmp目录
编程接口：通过 SimpleFileServer 类定制化服务器：
var server = SimpleFileServer.createFileServer(
    new InetSocketAddress(8080), 
    Path.of("/data"), 
    OutputLevel.VERBOSE
);
server.start();
================JavaDoc 代码片段增强===============
**@snippet 标签**：简化多行代码在文档中的展示，避免 @code 的 pre 标签嵌套问题。
​引用外部代码：直接关联源码文件，保持文档与代码同步
/** 
 * 示例：{@snippet file="Demo.java" region="example"}
 */
===============Vector API 第三轮孵化利用 SIMD 指令加速向量计算，适用于机器学习、图像处理等数值密集型任务============
var a = FloatVector.fromArray(SPECIES, array1, 0);
var b = FloatVector.fromArray(SPECIES, array2, 0);
var c = a.add(b).intoArray(result, 0);

Java SE 19 (2022 年)
引入了虚拟线程（预览）、结构化并发（孵化）和 Record 模式（预览）等新特性。

=============虚拟线程（预览特性）==========

import java.util.concurrent.*;

public class VirtualThreadDemo {
    public static void main(String[] args) {
        // 使用虚拟线程执行器（每个任务一个虚拟线程）
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            // 提交1000个任务（模拟I/O密集型操作）
            for (int i = 0; i < 1000; i++) {
                int taskId = i;
                executor.submit(() -> {
                    Thread.sleep(1000); // 模拟1秒阻塞操作
                    System.out.println("Task " + taskId + " completed by: " 
                        + Thread.currentThread().getName());
                    return taskId;
                });
            }
        } // try-with-resources自动关闭执行器[1,5](@ref)
    }
}
===============结构化并发（孵化特性）==============
import jdk.incubator.concurrent.*;

public class StructuredConcurrencyDemo {
    record Weather(String info) {}
    record User(String name) {}

    public static void main(String[] args) throws Exception {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            // 并行执行两个子任务
            Future<Weather> weatherFuture = scope.fork(() -> fetchWeather());
            Future<User> userFuture = scope.fork(() -> fetchUser());

            scope.join();           // 等待所有子任务完成
            scope.throwIfFailed();  // 任一失败则抛出异常
            
            // 组合结果
            System.out.println("Weather: " + weatherFuture.resultNow() 
                + ", User: " + userFuture.resultNow());
        } // 自动关闭作用域，确保资源释放[6,7](@ref)
    }

    static Weather fetchWeather() throws InterruptedException {
        Thread.sleep(500);
        return new Weather("Sunny");
    }

    static User fetchUser() throws InterruptedException {
        Thread.sleep(800);
        return new User("Grey");
    }
}
===================Record 模式匹配（预览特性）============
public class RecordPatternDemo {
    record Point(int x, int y) {}
    record Line(Point start, Point end) {}

    static void print(Object obj) {
        // 模式匹配解构Record
        if (obj instanceof Point(int x, int y)) {
            System.out.printf("Point坐标: (%d, %d)\n", x, y);
        } 
        // 嵌套模式匹配
        else if (obj instanceof Line(Point(var x1, var y1), Point(var x2, var y2))) {
            System.out.printf("线段端点: (%d,%d)->(%d,%d)\n", x1, y1, x2, y2);
        }
    }

    public static void main(String[] args) {
        print(new Point(3, 4));
        print(new Line(new Point(1,2), new Point(5,6)));
    }
}

Java SE 20 (2023 年)
虚拟线程第二次预览、作用域值孵化、Record 模式第二次预览等。

===虚拟线程（第二次预览）==
// 创建虚拟线程（无需显式管理线程池）
Runnable task = () -> {
    System.out.println("Virtual thread: " + Thread.currentThread());
};

// 方式1：直接启动虚拟线程
Thread.startVirtualThread(task);

// 方式2：通过工厂创建
ThreadFactory factory = Thread.ofVirtual().name("worker-", 0).factory();
factory.newThread(task).start();

// 方式3：通过ExecutorService（推荐生产环境使用）
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> {
        Thread.sleep(1000); // 阻塞操作自动挂起线程
        System.out.println("Async task completed");
    });
}
================作用域值（Scoped Values，孵化阶段）==========
import jdk.incubator.concurrent.ScopedValue;

public class ScopedValueDemo {
    // 声明作用域值
    private static final ScopedValue<String> USER_CONTEXT = ScopedValue.newInstance();

    public static void main(String[] args) {
        ScopedValue.where(USER_CONTEXT, "admin")  // 绑定值到当前作用域
                   .run(() -> processRequest());
    }

    static void processRequest() {
        System.out.println(USER_CONTEXT.get()); // 输出：admin
        
        // 子线程继承作用域值
        Thread.startVirtualThread(() -> {
            System.out.println(USER_CONTEXT.get()); // 同样输出：admin
        });
    }
}
=======================Record 模式匹配（第二次预览）==================
record Point(int x, int y) {}
record Line(Point start, Point end) {}

// 类型匹配 + 嵌套解构
static void processShape(Object shape) {
    switch (shape) {
        case Line(Point(var x1, var y1), Point(var x2, var y2)) -> 
            System.out.printf("线段端点：(%d,%d)-(%d,%d)%n", x1, y1, x2, y2);
            
        case Point(int x, int y) when x == y ->
            System.out.println("坐标点在对角线上");
            
        case null ->
            System.out.println("空对象");
            
        default ->
            System.out.println("未知形状");
    }
}

// 测试代码
public static void main(String[] args) {
    processShape(new Line(new Point(1,1), new Point(5,5))); 
    processShape(new Point(3,3));
    processShape(null);
}
=============新特性========
支持泛型记录的类型推断（var 可省略显式类型声明）
允许在增强型 for 循环中直接解构：
List<Point> points = List.of(new Point(1,2), new Point(3,4));
for (Point(int x, int y) : points) {
    System.out.println(x + "," + y); 
}

Java SE 21 (2023 年, LTS)
虚拟线程正式、字符串模板预览、分代 ZGC、Record 模式正式、Switch 模式匹配正式等。

============虚拟线程（正式版）=======
// 创建百万级虚拟线程的简单实现
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 1_000_000).forEach(i -> 
        executor.submit(() -> {
            Thread.sleep(100); // 模拟 I/O 阻塞
            System.out.println("Task " + i);
        })
    );
} // 自动关闭执行器，确保资源释放
=================字符串模板（预览特性）=============
// 多行 JSON 模板（自动转义特殊字符）
String json = STR."""
    {
        "user": "\{userName}",
        "role": "\{role}",
        "createdAt": "\{LocalDateTime.now().format(DateTimeFormatter.ISO_DATE)}"
    }
""";

// SQL 安全拼接（编译期校验）
QueryTemplate query = SQL."""
    SELECT * FROM \{tableName} 
    WHERE id = \{userId} AND status = \{status}
"""; // 自动生成预编译语句
===============Record 模式（正式版）========
record Point(int x, int y) {}
record Line(Point start, Point end) {}

// 嵌套解构示例
if (shape instanceof Line(Point(int x1, int y1), Point(int x2, y2))) {
    System.out.printf("端点坐标: (%d,%d) -> (%d,%d)", x1, y1, x2, y2);
}

// Switch 表达式中的模式匹配
String describe = switch(obj) {
    case Point(int x, int y) when x == y -> "对角线上的点";
    case Line l -> "线段长度: " + Math.hypot(l.end.x()-l.start.x(), l.end.y()-l.start.y());
    default -> "未知形状";
};
==============Switch 模式匹配==========
sealed interface Shape permits Circle, Square {}
record Circle(double radius) implements Shape {}
record Square(double side) implements Shape {}

// 类型匹配与守卫条件结合
double area = switch(shape) {
    case Circle c -> Math.PI * c.radius() * c.radius();
    case Square s when s.side() > 10 -> s.side() * s.side() * 0.9; // 大尺寸折扣
    case Square s -> s.side() * s.side();
    case null -> throw new IllegalArgumentException("空对象");
};
=====模式匹配的泛型========
if (obj instanceof List<String> list) {
    String first = list.getFirst(); // 无需强制转换
}
=======字符串模板====
String name = "Java";
String message = STR."Hello \{name}!"; // 输出：Hello Java!
=====API库扩展======
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future<String> user = scope.fork(() -> fetchUser());
    Future<Integer> order = scope.fork(() -> fetchOrder());
    scope.join();
    return new Response(user.resultNow(), order.resultNow());
}

Java SE 22 (2024 年)
持续在平台性能、安全性和 API 层面进行优化升级。

以下是 ​Java SE 22（2024年3月发布）​ 的核心升级特性与技术解析，涵盖平台性能、安全性及 API 层面的优化：

一、性能优化
​G1 垃圾回收器区域固定（JEP 423）​

​改进点：在 JNI（Java Native Interface）调用期间，允许 G1 回收未被固定的内存区域，减少因线程阻塞导致的延迟。
​技术细节：通过跟踪包含临界对象的区域计数器，仅固定必要区域，其他区域可正常回收，降低最大暂停时间至亚毫秒级。
​适用场景：高并发且依赖本地库调用的应用（如实时数据处理）。
​分代 ZGC 增强

​堆管理：支持更大堆空间（TB 级），优化年轻代和老年代的分代策略，减少内存碎片。
​参数调优：新增 -XX:ZAllocationSpikeTolerance 控制 GC 触发阈值，提升吞吐量。
二、安全性增强
​字符串模板（JEP 459，第二次预览）​

​防注入设计：通过 STR 和 SQL 模板处理器自动转义特殊字符，防止 SQL 注入和 JSON 解析漏洞。
​多行支持：简化 JSON/XML 生成代码，减少手动拼接错误。
java
String json = STR."""
    { "user": "\{userName}", "createdAt": "\{LocalDate.now()}" }
""";
​外部函数与内存 API（JEP 454，正式发布）​

​替代 JNI：提供类型安全的本地内存访问，避免原生代码调用中的内存泄漏和崩溃风险。
​示例：直接调用 C 库函数（如 radixsort）并管理离堆内存生命周期。
三、API 与工具链升级
​流收集器（JEP 461，预览）​

​功能扩展：支持自定义中间操作（如 gather()），灵活处理无限流数据。
​用例：复杂数据转换（如分页、窗口统计）无需中断流管道。
​类文件 API（JEP 457，预览）​

​标准化操作：提供解析、生成和修改 .class 文件的标准接口，替代 ASM 等第三方库。
​应用场景：动态字节码生成（如 AOP、ORM 框架）。
​未命名变量与模式（JEP 456）​

​代码简化：用 _ 替代未使用的变量或嵌套模式，增强可读性。
java
if (obj instanceof Point(int x, _)) { 
    System.out.println("X坐标: " + x); 
}
四、语言特性革新
​结构化并发（JEP 462，第二次预览）​

​生命周期管理：通过 StructuredTaskScope 统一管理子任务，任一子任务失败自动取消其他任务。
​性能提升：结合虚拟线程实现轻量级任务调度，减少线程泄漏风险。
​隐式类与实例主方法（JEP 463，第二次预览）​

​教学友好：允许省略 public class 和 static void main，降低初学门槛。
java
void main() { 
    System.out.println("Hello, Java 22!"); 
}
​作用域值（JEP 464，第二次预览）​

​线程安全共享：替代 ThreadLocal，通过 ScopedValue 在虚拟线程间传递不可变数据。
五、部署与监控
​启动多文件源码程序（JEP 458）​

​简化运行：直接执行多文件项目（如 java *.java），无需手动编译。
​向量 API（JEP 460，第七次孵化）​

​硬件加速：利用 SIMD 指令优化数值计算（如矩阵运算），性能提升 5-10 倍。

Java SE 23 (2024 年)
进一步扩展和完善语言与平台功能。

===========语言特性增强=======
String json = STR."""
    { "user": "\{userName}", "createdAt": "\{LocalDate.now()}" }
""";  // 自动转义特殊字符，防止注入漏洞
====原始类型模式匹配（Primitive Types in Patterns）​==
if (obj instanceof int x) { /* 直接操作原始类型 */ }  // 支持所有基元类型[2,5](@ref)
===​未命名变量与模式（Unnamed Patterns and Variables）===
if (point instanceof Point(int x, _)) { ... }  // 忽略不需要的字段
-====隐式类与实例主方法===
void main() { 
    System.out.println("Hello Java 23!");  // 简化小型程序编写
}
===========​结构化并发（Structured Concurrency）============
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future<String> user = scope.fork(() -> fetchUser());
    scope.join();  // 确保资源自动清理[2,5,9](@ref)
}=============API 与工具链升级=============
List<Integer> result = numbers.stream()
    .gather(Gatherers.takeWhile(n -> n < 10))  // 自定义终止条件[2](@ref)
    .toList();
==============Markdown 文档注释================
/**
 * ## 示例代码
 * 使用 `STR` 模板生成 JSON。
 */
===============​模块导入声明===========
import module java.base.*;  // 导入所有基础模块包[2](@ref)

Java SE 24 (2025 年)
包含 24 个新特性（如 JEP 404、JEP 450、……JEP 501），进一步提升性能、安全、开发效率等各方面。

新特性编写的完整代码示例，涵盖性能优化、安全增强、并发编程及语言特性改进等核心

一、分代 Shenandoah 垃圾回收器（JEP 404，实验性）
java
// 启动参数示例（需启用实验性功能）
// java -XX:+UnlockExperimentalVMOptions -XX:+UseShenandoahGC -XX:+ShenandoahGCMode=generational ...

public class ShenandoahDemo {
    public static void main(String[] args) {
        // 创建大量短生命周期对象（触发新生代 GC）
        IntStream.range(0, 1_000_000).forEach(i -> new Object());
        System.out.println("分代 Shenandoah 优化内存回收完成 [1,4](@ref)");
    }
}
二、密钥派生函数 API（JEP 478，预览）

import javax.crypto.SecretKey;
import java.security.spec.AlgorithmParameterSpec;
import javax.crypto.spec.HKDFParameterSpec;
import java.security.KeyDerivationFunction;

public class KdfDemo {
    public static void main(String[] args) throws Exception {
        // 初始化 HKDF-SHA256 实例
        KeyDerivationFunction kdf = KeyDerivationFunction.getInstance("HKDF-SHA256");
        byte[] salt = new byte[32](@ref);
        byte[] info = "SessionKey".getBytes();
        
        // 配置参数：从主密钥派生 256 位 AES 密钥
        AlgorithmParameterSpec params = new HKDFParameterSpec(
            "masterKey123".getBytes(), salt, info, 256
        );
        
        SecretKey sessionKey = kdf.deriveKey("AES", params);
        System.out.println("抗量子密钥派生完成：" + sessionKey.getAlgorithm() + " [2,4](@ref)");
    }
}
三、虚拟线程同步优化（JEP 491）

import java.util.concurrent.Executors;

public class VirtualThreadSyncDemo {
    public static void main(String[] args) {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            // 提交 1000 个并发任务（同步操作不锁定平台线程）
            IntStream.range(0, 1000).forEach(i -> 
                executor.submit(() -> {
                    synchronized (VirtualThreadSyncDemo.class) {
                        Thread.sleep(100); // 虚拟线程在此挂起，释放载体线程
                        System.out.println("Task " + i + " completed");
                    }
                })
            );
        } // 自动关闭执行器 [3,5](@ref)
    }
}
四、模块导入声明（JEP 494，预览）

// 一键导入模块所有包（替代逐个导入）
import module java.base.*;  // 包含 java.util, java.io 等基础包 [5,6](@ref)

public class ModuleImportDemo {
    public static void main(String[] args) {
        List<String> list = List.of("Java", "24");
        System.out.println("模块化导入简化代码量: " + list);
    }
}
五、简化主方法（JEP 495，第四次预览）

// 无需 public class 和 static void main 方法
class SimpleMainDemo {
    void main() {
        System.out.println("Hello Java 24! 学习门槛大幅降低 [5,6](@ref)");
    }
}
六、结构化并发（JEP 499，第四次预览）

import jdk.incubator.concurrent.StructuredTaskScope;

public class StructuredConcurrencyDemo {
    public static void main(String[] args) throws Exception {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            // 并行执行两个子任务
            var userTask = scope.fork(() -> fetchUser());
            var orderTask = scope.fork(() -> fetchOrder());
            
            scope.join();
            System.out.println("用户数据: " + userTask.get() + ", 订单数据: " + orderTask.get());
        } // 自动取消未完成任务 [3,6](@ref)
    }

    static String fetchUser() throws InterruptedException {
        Thread.sleep(500);
        return "User123";
    }

    static String fetchOrder() throws InterruptedException {
        Thread.sleep(800);
        return "Order456";
    }
}
七、模式匹配增强（JEP 488，第二次预览）

record Point(int x, int y) {}

public class PatternMatchingDemo {
    public static void main(String[] args) {
        Object obj = new Point(3, 4);
        
        // 结合原始类型守卫和嵌套解构
        if (obj instanceof Point(int x, int y) when x > 0 && y > 0) {
            System.out.println("第一象限坐标: (" + x + "," + y + ") [1,6](@ref)");
        }
    }
}
八、向量 API（JEP 489，第九次孵化）

import jdk.incubator.vector.*;

public class VectorApiDemo {
    public static void main(String[] args) {
        var a = IntVector.fromArray(IntVector.SPECIES_256, new int[]{1,2,3,4,5,6,7,8}, 0);
        var b = IntVector.fromArray(IntVector.SPECIES_256, new int[]{8,7,6,5,4,3,2,1}, 0);
        var c = a.add(b); // SIMD 指令加速计算
        System.out.println("向量运算结果: " + Arrays.toString(c.toArray()) + " [6,7](@ref)");
    }
}
九、类文件 API（JEP 484）

import java.lang.classfile.*;

public class ClassFileApiDemo {
    public static void main(String[] args) {
        // 动态生成字节码（替代 ASM 库）
        byte[] bytecode = ClassFile.of().build(ClassDesc.of("DynamicClass"), classBuilder ->
            classBuilder.withMethod("main", MethodTypeDesc.of(CD_void, CD_String.arrayType()), flags(ACC_PUBLIC, ACC_STATIC), codeBuilder ->
                codeBuilder
                    .getstatic(CD_System, "out", CD_PrintStream)
                    .ldc("动态生成类示例")
                    .invokevirtual(CD_PrintStream, "println", MethodTypeDesc.of(CD_void, CD_String))
                    .return_()
            )
        );
        System.out.println("类文件 API 生成字节码长度: " + bytecode.length + " [6,7](@ref)");
    }
}
十、流收集器增强（JEP 485）

import java.util.stream.*;

public class StreamGathererDemo {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1,3,5,7,9,8,6,4);
        
        // 自定义截断条件（遇到偶数停止）
        List<Integer> result = numbers.stream()
            .gather(Gatherers.takeWhile(n -> n % 2 != 0))
            .toList();
        
        System.out.println("流收集器截断结果: " + result + " [5,6](@ref)");
    }
}
十一、安全增强（JEP 486，禁用安全管理器）

public class SecurityManagerDemo {
    public static void main(String[] args) {
        // 尝试启用安全管理器会抛出异常
        try {
            System.setSecurityManager(new SecurityManager());
        } catch (UnsupportedOperationException e) {
            System.out.println("安全管理器已永久禁用 [4,5](@ref)");
        }
    }
}

Java SE 25
预计将于 2025 年 9 月发布，未来版本会继续沿着六个月一版的更新周期发展。