← 返回博客
2026-06-24 14:41:55

Java 版本详解：从小白到选型，一文讲透三十年演进史

Java 版本详解：从小白到选型，一文讲透三十年演进史

2026-06-24 14:41:55 · 标签：Java、JVM、教程、技术选型、编程

引言

Java 大概是编程世界里最"分裂"的语言：它既是最流行的后端语言，也是被吐槽最多的语言；它的生态庞大到学不完，它的版本号多到让人头疼。

新手第一次接触 Java，大概率会遇到一堆长得差不多的缩写——JDK、JRE、JVM、SE、EE、ME。然后去 Oracle 官网下载，发现还有一个 OpenJDK，还有一个名为 Temurin 的东西，还有 GraalVM、Corretto、Zulu……版本号从 8 到 26，中间还有 LTS 和非 LTS 之分。

这篇文章目标明确：把 Java 的版本、概念、历史、选型一次性讲清楚。 不绕弯子，不堆废话。

一、Java 是什么：三句话讲清本质

第一句：Java 是一门编译成字节码、运行在虚拟机上的面向对象语言。你用 .java 写源码，javac 编译成 .class 字节码，JVM 执行字节码。一句"Write Once, Run Anywhere"就是它 1995 年横空出世时的核心卖点。

第二句：Java 真正统治世界靠的不是语法，是生态。Spring、MyBatis、Hadoop、Kafka、Elasticsearch、Tomcat、Netty——过去三十年企业级软件的基础设施几乎都是 Java 写的。你可以不写 Java，但你很难不用 Java 写的工具。

第三句：Java 的维护者已经从 Sun 变成了 Oracle，但 OpenJDK 才是实际的标准实现。绝大多数人用的"Java"都是 OpenJDK 的某个发行版，而不是 Oracle JDK。

二、那些让人困惑的缩写：一张图全部理清

新手面对 JDK、JRE、JVM、Java SE、Java EE、Jakarta EE 这些词时，90% 的人都会懵。下面用最简单的方式讲清楚。

2.1 JVM、JRE、JDK 的包含关系

+---------------------------------------------+
|                   JDK                        |
|  (Java Development Kit — 开发工具包)          |
|                                              |
|  +----------------------------------------+  |
|  |              JRE                        |  |
|  |  (Java Runtime Environment — 运行环境)   |  |
|  |                                         |  |
|  |  +-----------------------------------+  |  |
|  |  |            JVM                    |  |  |
|  |  |  (Java Virtual Machine — 虚拟机)  |  |  |
|  |  |  字节码解释/编译、内存管理、GC     |  |  |
|  |  +-----------------------------------+  |  |
|  |                                         |  |
|  |  核心类库 (rt.jar / java.base 等)      |  |
|  |  运行时工具 (java 命令等)              |  |
|  +----------------------------------------+  |
|                                              |
|  开发工具 (javac, jar, javadoc, jshell...)  |
|  调试工具 (jstack, jmap, jconsole...)       |
+---------------------------------------------+

一句话总结：

缩写全称通俗理解谁需要
JVMJava Virtual Machine执行字节码的"发动机"任何运行 Java 程序的人
JREJava Runtime EnvironmentJVM + 核心类库，能"跑"程序但不能"写"只需要运行 Java 程序的用户
JDKJava Development KitJRE + 开发工具，能"写"也能"跑"开发者

从 Java 11 开始，Oracle 不再单独发布 JRE。现在的 JDK 自带 jlink 工具，可以自己裁剪出最小运行时。

2.2 Java SE、Java EE、Jakarta EE

这三个词最容易混淆：

名称定位通俗理解
Java SE (Standard Edition)标准版，Java 的核心你学 Java 时用的就是 SE——语法、集合、IO、并发、JDBC
Java EE (Enterprise Edition)企业版，在 SE 之上的扩展规范Servlet、JPA、JMS、EJB 等企业级 API 的规范定义
Jakarta EEJava EE 改名后的产物2017 年 Oracle 把 Java EE 捐给 Eclipse 基金会，因商标问题改名为 Jakarta EE

关键理解：Java EE 不是一套软件，而是一套规范。Tomcat、Jetty、WildFly、GlassFish、WebLogic 这些是规范的具体实现。Spring 框架本身不是 Java EE 的实现，但大量使用了 Java EE 定义的 API（如 Servlet）。

现在的 Jakarta EE 10（2022 年发布）已经全面移除 javax. 包名，改为 jakarta.。这意味着老项目升级时会遇到大量导包路径变更。

2.3 OpenJDK vs Oracle JDK vs 各种发行版

        OpenJDK (开源参考实现)
        |
        +-- Oracle JDK (Oracle 的商业发行版，有付费支持)
        |
        +-- Eclipse Temurin (Adoptium 项目，社区维护，免费)
        |
        +-- Amazon Corretto (AWS 维护，免费，有长期支持承诺)
        |
        +-- Azul Zulu (Azul 公司维护，免费/付费均有)
        |
        +-- Alibaba Dragonwell (阿里维护，有中文支持)
        |
        +-- GraalVM (Oracle 的高性能多语言运行时，支持 Native Image)
        |
        +-- 其他 (Red Hat, SAP, IBM, Microsoft 各有发行版)

选哪个？对个人开发者和绝大多数企业来说，Eclipse Temurin 是首选——免费、社区活跃、背靠 Eclipse 基金会。公司在 AWS 上的话用 Corretto 更方便。需要极致启动速度或低内存占用的场景，直接上 GraalVM。

三、发展简史：五个时代看懂 Java 三十年

3.1 第一阶段：Sun 时代（1995-2010）—— 奠定格局

1995 年，James Gosling 在 Sun Microsystems 发布了 Java 1.0。当时的口号是"Write Once, Run Anywhere"，瞄准的是跨平台的桌面应用和浏览器 Applet（后者现在已经死透了）。

1998 年发布的 Java 1.2 是一个分水岭——引入了 Collections 框架和 Swing GUI 库，同时将平台划分为 J2SE、J2EE、J2ME 三大版本。这是 Java 平台化的起点。

2004 年的 Java 5（内部版本号 1.5）是 Java 历史上最重要的版本之一——泛型、注解、枚举、自动装箱、增强 for 循环、可变参数全部在这一版加入。这些特性至今仍是 Java 语法的骨架。

2006 年 Java 6 发布，Sun 同时宣布 Java 开源，OpenJDK 诞生。但这也是 Sun 最后的辉煌——公司在财务困境中挣扎，最终于 2010 年被 Oracle 以 74 亿美元收购。

3.2 第二阶段：Oracle 接手与停滞期（2010-2014）

Oracle 接手后，Java 7 经过漫长的开发终于在 2011 年发布，带来了 try-with-resources、diamond operator、Fork/Join 框架和 NIO.2。但随后 Java 的发展陷入停滞——Java 8 延迟了近两年才在 2014 年发布。

不过这个等待是值得的。Java 8 是 Java 历史上最重要的版本，没有之一。 Lambda 表达式、Stream API、Optional、新的日期时间 API——这些特性彻底改变了 Java 的编程范式，让它从一门"啰嗦的面向对象语言"迈向"支持函数式编程的现代语言"。

3.3 第三阶段：加速与模块化（2017-2018）—— 6 个月发布周期

2017 年，Oracle 宣布 Java 改为每 6 个月发布一个新版本，同时引入 LTS（长期支持）概念。Java 9 带来模块化系统（Project Jigsaw），Java 10 带来 var 类型推断，Java 11 作为 LTS 版本带来 HTTP Client API。

这个节奏让很多企业不适应——"我刚升级到 11，17 都出来了？"但从语言演进角度看，小步快跑确实让 Java 焕发了第二春。

3.4 第四阶段：语法糖大爆发（2019-2023）

Java 12 到 Java 21 这五年，是 Java 语法现代化最快的时期。Switch 表达式、文本块、Record 类、Sealed 类、Pattern Matching 一个个落地。Java 曾经被讥讽的"啰嗦"正在被系统性解决。

2023 年 9 月的 Java 21 LTS 是第二个里程碑级的版本。Virtual Threads（虚拟线程）正式 GA——几行代码就能写出百万级并发，不需要回调地狱，不需要 RxJava 或 Reactor。这是 Java 并发模型三十年来最大的变革。

3.5 第五阶段：持续演进（2024-至今）

Java 22 到 26 延续了 6 个月节奏。Stream Gatherers、Scoped Values、Structured Concurrency、Vector API 相继成熟。Java 25（2025 年 9 月） 是继 21 之后的最新 LTS 版本，也是当前生产环境的主力推荐版本。

四、关键版本特性详解

下面按重要程度逐版拆解。LTS 版本详细展开，非 LTS 版本列核心特性。

4.1 Java 8（LTS，2014 年 3 月） —— 改变一切

仍在广泛使用。 即使到了 2026 年，Java 8 在企业中的存量仍然巨大。但新项目不应再选 8。

核心新特性：

Lambda 表达式与函数式接口

// Java 8 之前
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello");
    }
}).start();

// Java 8
new Thread(() -> System.out.println("Hello")).start();

Stream API —— 声明式处理集合，链式操作：

List<String> names = users.stream()
    .filter(u -> u.getAge() > 18)
    .map(User::getName)
    .sorted()
    .collect(Collectors.toList());

Optional —— 消灭 NullPointerException 的优雅方案：

Optional<User> user = userRepo.findById(id);
String name = user.map(User::getName).orElse("Unknown");

新的日期时间 API (java.time) —— 终于有了好用的时间库：

LocalDate today = LocalDate.now();
LocalDateTime now = LocalDateTime.now();
Duration between = Duration.between(start, end);

默认方法 (default method) —— 接口可以有默认实现，解决了接口演进的历史难题。

CompletableFuture —— 异步编程的组合式 API。

4.2 Java 9（2017 年 9 月） —— 模块化

模块系统 (Project Jigsaw)—— module-info.java 定义模块边界，JDK 自身也被拆分为多个模块。

// module-info.java
module com.myapp {
    requires java.sql;
    exports com.myapp.api;
}

JShell —— Java 终于有了交互式 REPL。

不可变集合工厂方法：

List<String> list = List.of("a", "b", "c");
Map<String, Integer> map = Map.of("k1", 1, "k2", 2);

私有接口方法，G1 成为默认 GC。

4.3 Java 10（2018 年 3 月） —— var

局部变量类型推断：

// 之前
Map<String, List<User>> map = new HashMap<>();
// 之后
var map = new HashMap<String, List<User>>();

仅限局部变量，不能用于字段、方法参数、返回值。

4.4 Java 11（LTS，2018 年 9 月） —— 现代化起点

HTTP Client（标准）—— 终于有了内置的现代 HTTP 客户端，替代老旧的 HttpURLConnection：

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com"))
    .GET()
    .build();
HttpResponse<String> response = client.send(request, BodyHandlers.ofString());

直接运行单个源文件：

java HelloWorld.java    # 不需要 javac

String 新增方法：isBlank(), lines(), strip(), repeat()

4.5 Java 12-16（2019-2021） —— 语法糖密集落地

版本关键特性
12Switch 表达式（预览）、Shenandoah GC
13文本块（预览）、ZGC 增强
14Record（预览）、Pattern Matching instanceof、Helpful NPE
15文本块正式、Sealed Classes（预览）、ZGC 生产可用
16Record 正式、Pattern Matching instanceof 正式

文本块（13 预览，15 正式）：

String json = """
    {
        "name": "Java",
        "version": 21
    }
    """;

Record（14 预览，16 正式）—— 消灭样板代码：

// 之前：几十行 getter/setter/equals/hashCode/toString
public class Point {
    private final int x;
    private final int y;
    // ... 一大堆代码
}

// 之后：一行
public record Point(int x, int y) {}

Pattern Matching instanceof（14 预览，16 正式）：

if (obj instanceof String s && s.length() > 5) {
    System.out.println(s.toUpperCase());  // s 已经在作用域内
}

4.6 Java 17（LTS，2021 年 9 月） —— 新的基线

这是继 Java 11 之后最重要的 LTS 版本，也是 Spring Boot 3 / Spring Framework 6 的最低要求版本。

Sealed Classes（密封类）—— 控制继承层次：

public sealed class Shape
    permits Circle, Rectangle, Triangle {}

public final class Circle extends Shape { }
public final class Rectangle extends Shape { }
public final class Triangle extends Shape { }
// 其他类不能 extends Shape

Pattern Matching for Switch（预览）。

增强的伪随机数生成器 API。

4.7 Java 18-20（2022-2023） —— 虚拟线程酝酿

版本关键特性
18UTF-8 默认编码、简易 Web 服务器、@snippet 在 Javadoc 中
19Virtual Threads（预览）、Record Patterns（预览）、Foreign Function API（预览）
20Virtual Threads（第二次预览）、Scoped Values、Record Patterns（第二次预览）

4.8 Java 21（LTS，2023 年 9 月） —— 并发革命

这是 Java 21 世纪第三个十年最重要的版本。 Virtual Threads 正式 GA 标志着 Java 并发模型的根本性变革。

Virtual Threads（虚拟线程）：

// 传统线程池：几百个线程就到头了
ExecutorService pool = Executors.newFixedThreadPool(200);

// 虚拟线程：百万级并发，不在话下
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 1_000_000; i++) {
        executor.submit(() -> {
            // 处理请求
            // 每个虚拟线程阻塞时，底层 OS 线程不阻塞
        });
    }
}

虚拟线程的核心价值：它把"一个请求一个线程"的简单模型带回了高并发场景。你不用再为了性能去学 RxJava、Reactor、Coroutine——用同步代码写异步逻辑，虚拟线程帮你搞定。

Record Patterns：

if (obj instanceof Point(int x, int y)) {
    System.out.println(x + ", " + y);
}

Pattern Matching for Switch：

String result = switch (obj) {
    case Integer i -> "整数: " + i;
    case String s when s.length() > 5 -> "长字符串: " + s;
    case String s -> "短字符串: " + s;
    case null -> "空值";
    default -> "其他";
};

Sequenced Collections —— 有序集合终于有了统一的接口：

SequencedCollection<String> list = new ArrayList<>();
list.addFirst("first");
list.addLast("last");
String first = list.getFirst();

4.9 Java 22-24（2024-2025） —— 持续打磨

版本关键特性
22构造器前语句 (super() 前可执行代码)、字符串模板（二轮预览）、未命名变量 _、FFM API 正式
23Markdown Javadoc、ZGC 默认年轻代 GC、隐式声明类
24Stream Gatherers、Scoped Values 正式、Structured Concurrency（三轮预览）、Vector API

Stream Gatherers（24）—— 自定义中间操作：

// 每 3 个元素分一组: [1,2,3,4,5,6] -> [[1,2,3],[4,5,6]]
stream.gather(Gatherers.windowFixed(3))

Structured Concurrency—— 结构化并发，让多任务协作的异常处理和生命周期管理更清晰。

4.10 Java 25（LTS，2025 年 9 月） —— 当前推荐

Java 25 是截至 2026 年 6 月的最新 LTS 版本，整合了 21 到 24 期间沉淀的所有稳定特性。

核心卖点：

为什么选 25 而不是 21：如果你的基础设施（Spring Boot 3.5+、构建工具、CI/CD）已经适配，25 就是当前最好的选择——它不仅拥有 21 的全部能力，还额外收获了结构化并发、Scoped Values 和 Vector API 这些生产级的性能工具。

4.11 Java 26（2026 年 3 月） —— 最新前沿

Java 26 是当前最新版本（非 LTS），主要包含预览和孵化的前沿特性。适合尝鲜和提前学习，不建议直接上生产。

五、版本选择指南

5.1 一句话结论

新项目 -> Java 25 LTS（当前最佳选择）
如果基础设施未适配 25 -> Java 21 LTS（最低底线）
维护老系统 -> 保持现有版本，但尽快规划升级到 21+
尝鲜/学习 -> Java 26（最新非 LTS）
绝对不要 -> Java 8/11 的新项目（2026 年了）

5.2 场景化建议

场景推荐版本理由
全新项目Java 25最新 LTS，特性最全，生态已适配
Spring Boot 3.x 项目Java 21 或 25Spring Boot 3.x 要求 Java 17+，实际建议 21+
高并发服务Java 21+Virtual Threads 是革命性的
大数据（Hadoop/Spark/Flink）视框架而定大数据框架升级慢，很多还卡在 Java 8/11
Android 开发Java 17Android 的工具链对 17 支持最成熟
维护老系统不变先写测试，再规划升级
学习 JavaJava 25学最新 LTS，不要从 8 开始学

5.3 升级路径建议

Java 8  -> [先升到 11] -> [适配模块化] -> [升到 17] -> [升到 21] -> [升到 25]
                                  |
                              关键一步：17 是 Spring Boot 3 的最低要求
                              建议至少跳到 21（Virtual Threads 值得）

注意要点：

5.4 再强调：别再用 Java 8 了

我知道很多人还在用 Java 8。存量项目我理解——升级有成本。但 2026 年开新项目还用 Java 8，说不过去。

你损失的东西太多了：Virtual Threads（并发性能质的飞跃）、Records（消灭 Pojos）、Pattern Matching、文本块、var、更好的 GC、更低的容器内存占用、持续的安全补丁……

Java 8 的免费安全更新早已停止。继续使用不是保守，是风险。

六、附录：版本速查表

版本代号/名称发布时间LTS标志性特性
1.0Oak1996.01-初版
1.1—1997.02-内部类、JDBC、RMI
1.2Playground1998.12-Collections、Swing、JIT
1.3Kestrel2000.05-HotSpot 默认
1.4Merlin2002.02-NIO、assert、正则
5.0Tiger2004.09-泛型、注解、枚举、foreach
6Mustang2006.12-脚本引擎、JDBC 4.0
7Dolphin2011.07-try-with-resources、NIO.2
8—2014.03LTSLambda、Stream、Optional、新日期 API
9—2017.09-模块系统、JShell
10—2018.03-var
11—2018.09LTSHTTP Client、单文件运行
12—2019.03-Switch 表达式（预览）
13—2019.09-文本块（预览）
14—2020.03-Record（预览）
15—2020.09-文本块、ZGC 生产可用
16—2021.03-Record、Pattern Matching instanceof
17—2021.09LTSSealed Classes、增强 PRNG
18—2022.03-UTF-8 默认、简易 Web Server
19—2022.09-Virtual Threads（预览）
20—2023.03-Virtual Threads（二轮预览）
21—2023.09LTSVirtual Threads、Record Patterns、Pattern Matching for Switch
22—2024.03-FFM API、构造器前语句
23—2024.09-Markdown Javadoc、ZGC 默认
24—2025.03-Stream Gatherers、Scoped Values
25—2025.09LTSStructured Concurrency、Vector API、Scoped Values
26—2026.03-最新前沿特性

结语

Java 变了。曾经那个十年一个版本的"老古董"，现在是六个月一个版本的"快节奏选手"。它吸收了函数式编程的精髓，拥抱了不可变性，用虚拟线程重新定义了并发模型。同时，它依然保持着向后兼容的承诺——三十年前的代码，大概率还能编译。

如果你因为"Java 太啰嗦""Java 太老"而离开了它，现在也许是时候回来看一眼。它已经不是十年前那个 Java 了。

如果你想系统走一遍 Java 最新特性，建议从 Java 21 的 Virtual Threads 入手——这是最直观、收益最大的一项。然后逐步学习 Record、Pattern Matching、Sealed Classes，它们会重塑你写 Java 的方式。

写于 2026 年 6 月 24 日。三十年了，Java 依然在进化。