"学长，面试官问JDK 8有什么新特性，我只能憋出个Lambda..."

"我刚入职，项目用的是JDK 17，看到代码里的var、record一脸懵..."

"书上写的J2SE、J2EE，怎么现在都叫Java SE了？"

如果你也有这些困惑，那这篇文章就是为你准备的。

我用了一整天时间，把Java从1996年诞生到今天的发展历程彻底梳理了一遍。看完这篇，你不仅知道每个版本有哪些重要特性，还能明白"为什么企业都用JDK 8"、"新项目该选JDK 17还是JDK 21"这些实际问题。

先说说我的困惑

说实话，刚开始学Java时，看到"JDK 1.8"、"JDK 11"、"JDK 17"这些版本号就头疼。不是说学Java吗？怎么还有这么多版本？它们有什么区别？我该用哪个？

更让我崩溃的是，书上偶尔还会冒出“J2SE”、“J2EE”这种老古董词汇。后来怎么又变成“Java SE”、“Jakarta EE”了？还有人老说“JDK 和 JVM 的关系”……

后来我花了一整天时间查资料、画图，总算把这一团乱麻理清了。今天就把我的学习笔记分享出来，保证你看完这篇，以后再也不迷糊！

Java 家族图谱：JDK、JRE、JVM 到底谁是谁？

咱们先来玩个角色扮演，理清这些核心概念的关系。

Java 语言：家族里的“老祖宗”，定下了家规（语法规则）。
JVM（Java 虚拟机）：家族里的“全能翻译官”，不管是跟 Windows 说英语，还是跟 Mac 说法语，他都能把老祖宗的话翻译得明明白白。
JRE（Java 运行时环境）：“翻译官单人套餐”，只有 JVM 和一些基础工具，够让程序跑起来。
JDK（Java 开发工具包）：“翻译官豪华全家桶”，除了 JRE，还给你配了编译工具、调试工具等，是咱们开发人员的全套装备。

为什么要了解Java历史？

很多初学者觉得"历史有什么用？会敲代码不就行了？"

错！大错特错！

举几个例子：

面试官问："JDK 8有哪些新特性？"你不懂历史怎么回答？
项目要用JDK 17，看到Lambda表达式、Stream API一脸懵，因为不知道这些是JDK 8引入的
同事说"咱们用新版本的Switch表达式"，你完全不知道人家在说啥

懂历史，才能看懂技术的演进逻辑，学新东西也更快！

从一杯咖啡到 Java 帝国

诞生记（1991 - 1996）

1991 年，Sun 公司的詹姆斯·高斯林（James Gosling）带领团队启动了一个叫“Green”的项目，目标是为未来的智能家电（比如微波炉）写一套通用控制系统。

团队给这门新语言起名 Oak（橡树），灵感来源于高斯林办公室窗外的树。可惜，这个名字被别人注册了。后来，大家想起常去喝咖啡的一家店叫“Java”，于是，这个既好听又有代表性的名字就诞生了。这也是为什么 Java 的 Logo 是一杯热气腾腾的咖啡。

1996 年：JDK 1.0 横空出世

1996 年 1 月 23 日，JDK 1.0 正式发布，一句口号响彻全球：

“Write Once, Run Anywhere”（一次编写，到处运行）

这在当时简直是黑科技！同一份代码，不用任何修改，就能在 Windows、Mac、Linux 上跑，全靠 JVM 这个“万能翻译官”。那时候，一个叫 Applet 的东西让 Java 火遍大江南北——因为它能让网页动起来！

核心特性：

Java语言基础语法（类、接口、异常处理）
基础类库（java.lang、java.io、java.util）
Applet（能在浏览器里运行的小程序，当时超火！）
AWT（图形界面工具包）
多线程支持
垃圾回收（GC）

野蛮生长：JDK 1.x 系列的进化（1997 - 2002）

JDK 1.1（1997年）：内功修炼

这个版本奠定了 Java 企业级应用的基石。最重要的更新就是 JDBC，它让 Java 连接数据库变得标准化，没有它，Java 想在企业后端当大哥？门儿都没有。

主要新特性：

JDBC：数据库连接API，让Java能操作数据库
内部类：可以在类里面再定义类，这个设计后来超级常用
RMI：远程方法调用，支持分布式计算
JavaBeans：可重用组件模型
反射API：运行时获取类的信息

JDK 1.2（1998年）：“Java 2”平台诞生

这是一个里程碑式的版本，Sun 公司正式将 Java 平台一分为三：

平台	全称	用途
J2SE	Java 2 Standard Edition	标准版，桌面应用开发的地基
J2EE	Java 2 Enterprise Edition	企业版，服务器端、企业级应用的航空母舰
J2ME	Java 2 Micro Edition	微型版，当年诺基亚、摩托罗拉手机上的游戏和应用

核心新特性：

集合框架：List、Set、Map登场！之前用的Vector、Hashtable终于有替代品了
JIT编译器：即时编译，大幅提升性能（之前是纯解释执行，慢得一批）
Swing：更漂亮的图形界面组件

小贴士：JDK 1.2引入了HotSpot虚拟机，后来成为Java性能优化的里程碑。

JDK 1.3（2000年）和JDK 1.4（2002年）：稳步前行

这两个版本主要是优化和增强：

JDK 1.3：

HotSpot JVM成为默认，性能大幅提升
Java Sound API（音频处理）
JNDI（目录服务访问）

JDK 1.4：

NIO：New I/O，非阻塞I/O，高性能网络编程的基石！
正则表达式：java.util.regex包
日志API：java.util.logging
assert关键字：断言，用于调试

里程碑革命：JDK 5 —— Java 语言的成人礼（2004 年）

如果说前面的版本是打基础，那 JDK 5 就是一次语言层面的核聚变。从它开始，Java 的命名规则也变了，不再叫“JDK 1.5”，而是直接叫“JDK 5”。

这个版本的新特性多到爆炸，我们用代码说话：

核心新特性一览

1. 泛型（Generics）： 告别强制类型转换，拥抱安全

// 泛型前：类型不安全，需要强制转换
List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0); // 需要强制转换，容易出错

// 泛型后：类型安全，代码更清晰
List<String> list = new ArrayList<>();
list.add("hello");
String s = list.get(0); // 不需要强制转换

2. 增强for循环（for-each）： 遍历集合从未如此优雅

// 之前
for (Iterator<String> i = list.iterator(); i.hasNext(); ) {
   
    String s = i.next();
    System.out.println(s);
}

// 现在
for (String s : list) {
   
    System.out.println(s);
}

3. 自动装箱/拆箱： 基本类型和包装类无缝切换

// 自动装箱：int -> Integer
Integer num = 10; // 编译器自动转为 new Integer(10)

// 自动拆箱：Integer -> int
int n = num; // 编译器自动转为 num.intValue()

4. 枚举类型（Enum）： 让常量定义更规范

// 之前：用常量
public static final int SPRING = 1;
public static final int SUMMER = 2;

// 现在：用枚举，更安全、更优雅
public enum Season {
   
    SPRING, SUMMER, AUTUMN, WINTER
}

5. 注解（Annotations）： 给代码打上标签，框架开发的利器

@Override  // 标记重写方法
@Deprecated // 标记过时方法

6. 可变参数

// 可变参数：参数数量可变
public void print(String... args) {
   
    for (String s : args) {
   
        System.out.println(s);
    }
}
print("a", "b", "c"); // 可以传任意个参数

7. 静态导入

import static java.lang.Math.PI;
import static java.lang.Math.sqrt;

// 直接使用，不用写Math.
double area = PI * r * r;
double d = sqrt(9);

8. 并发工具增强

JDK 5还带来了java.util.concurrent包，里面有：

ThreadPoolExecutor（线程池）
ConcurrentHashMap（并发Map）
CountDownLatch、CyclicBarrier（线程同步工具）

记忆口诀：JDK 5新特性记不住？记住"泛强自枚注可静"（泛型、增强for、自动装箱、枚举、注解、可变参数、静态导入）

企业级时代：JDK 6-7，2006-2011

JDK 6（2006年）：稳扎稳打

主要聚焦于性能优化和易用性：

脚本语言支持（JSR 223）：可以在Java里调用JavaScript
JDBC 4.0：自动加载驱动，更方便
G1垃圾回收器（实验性）
JAXB（XML绑定）
Java Compiler API：可以编程方式调用编译器

JDK 7（2011年）：承前启后

JDK 7 原计划有大动作（Lambda 表达式），但因 Sun 公司被 Oracle 收购而推迟。不过，它带来的几个小特性却非常实用：

1. try-with-resources（自动关闭资源）： 妈妈再也不用担心我忘记关流了

// 之前：手动关闭，容易忘记
BufferedReader br = new BufferedReader(new FileReader("file.txt"));
try {
   
    String line = br.readLine();
} finally {
   
    br.close(); // 必须手动关闭
}

// 现在：自动关闭
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
   
    String line = br.readLine();
} // 自动关闭，不用写finally

2. 字符串switch： 终于不用写一堆 if-else 了

// 之前：只能用int、enum做switch
// 现在：字符串也可以！
String day = "MONDAY";
switch (day) {
   
    case "MONDAY":
        System.out.println("周一");
        break;
    case "TUESDAY":
        System.out.println("周二");
        break;
}

3. 菱形操作符（Diamond Operator）： 让代码更简洁

// 之前：泛型要写两边
List<String> list = new ArrayList<String>();

// 现在：右边不用重复写类型
List<String> list = new ArrayList<>();

4. 二进制字面量

int binary = 0b1010;  // 二进制
int underscore = 1_000_000; // 数字可以用下划线分隔

改变一切的 JDK 8：函数式编程的春天（2014 年）

JDK 8是迄今为止影响最深远的版本，没有之一！哪怕你现在用的是JDK 17、JDK 21，你每天写的代码也处处是 JDK 8 的影子。它改变了我们写 Java 代码的思维方式。

1. Lambda表达式：函数式编程时代

让 Java 正式拥抱函数式编程，代码量大幅减少。

// 之前：匿名内部类，啰嗦
Runnable r = new Runnable() {
   
    @Override
    public void run() {
   
        System.out.println("Hello");
    }
};

// 现在：Lambda表达式，简洁
Runnable r = () -> System.out.println("Hello");

// 集合排序对比
list.sort(new Comparator<String>() {
   
    @Override
    public int compare(String a, String b) {
   
        return a.compareTo(b);
    }
});

// Lambda写法
list.sort((a, b) -> a.compareTo(b));

2. Stream API：集合处理的革命

操作集合就像写 SQL 查询语句一样，声明式、链式调用，爽到飞起。

// 之前：一步步处理
List<String> filtered = new ArrayList<>();
for (String s : list) {
   
    if (s.length() > 3) {
   
        filtered.add(s.toUpperCase());
    }
}

// 现在：链式调用，声明式处理
List<String> filtered = list.stream()
    .filter(s -> s.length() > 3)    // 过滤
    .map(String::toUpperCase)       // 转换
    .collect(Collectors.toList());   // 收集结果

3. 接口默认方法

接口里可以写带方法体的方法了！

public interface MyInterface {
   
    // 普通抽象方法
    void doSomething();

    // 默认方法：有默认实现
    default void doSomethingElse() {
   
        System.out.println("默认实现");
    }
}

4. 新的日期时间API

终于告别难用的Date和Calendar了！

// JDK 8之前：Date和Calendar难用死了
Date date = new Date();
Calendar cal = Calendar.getInstance();
cal.add(Calendar.DAY_OF_MONTH, 7);

// JDK 8：新的日期时间API
LocalDate today = LocalDate.now();
LocalDate nextWeek = today.plusDays(7);
LocalDateTime now = LocalDateTime.now();

5. Optional类：减少空指针异常

优雅地解决空指针异常（NullPointerException），告别丑陋的 if (obj != null) 判断。

// JDK 8之前
String name = getName();
if (name != null) {
   
    System.out.println(name.length());
}

// JDK 8之后：用Optional包装
Optional<String> name = Optional.ofNullable(getName());
name.ifPresent(n -> System.out.println(n.length()));

小贴士：JDK 8之所以这么重要，是因为Lambda、Stream、Optional这些特性改变了我们写Java的方式，让代码更简洁、更易读、更函数式。

模块化时代来临：JDK 9 到 JDK 11 的革新（2017 - 2018）

JDK 9（2017年）：模块化系统（Project Jigsaw）

将庞大的 JDK 拆分成一个个模块，让 Java 应用可以按需打包，为云原生时代铺路。

// module-info.java
module com.example.mymodule {
   
    requires java.base;  // 依赖其他模块
    exports com.example.mymodule.api;  // 导出包
}

主要新特性：

模块化系统：把JDK拆成多个模块，可以按需引入
JShell：交互式编程工具，不用写完整类就能执行代码
集合工厂方法：List.of()、Set.of()、Map.of()
私有接口方法：接口里可以有私有方法了

JDK 10（2018年）：var局部变量类型推断

// 之前：类型写在前面
String name = "Java";
ArrayList<String> list = new ArrayList<>();

// JDK 10：var自动推断类型
var name = "Java";
var list = new ArrayList<String>();

JDK 11（2018年）：第二个长期支持版（LTS）

继 JDK 8 之后第一个被企业大规模采用的 LTS 版本。带来了标准化的 HttpClient API 和实验性的低延迟垃圾回收器 ZGC。

主要特性：

HttpClient API：终于有标准化的HTTP客户端了！
直接运行单文件：java Hello.java，不用先编译
ZGC：低延迟垃圾回收器（实验性）
移除Java EE和CORBA模块：甩掉历史包袱

语法糖不断：JDK 12 到 JDK 17 的现代化（2019 - 2021）

预览特性机制

从JDK 12开始，Java引入了 预览特性（Preview Features） 机制：

新特性先以预览版发布，让开发者试用
根据反馈决定是否保留或修改
预览特性默认禁用，需要加--enable-preview参数

关键版本特性速览

JDK 12-13：新式 Switch 表达式

// JDK 13+：新的Switch表达式
int days = switch (month) {
   
    case JAN, MAR, MAY, JUL, AUG, OCT, DEC -> 31;
    case APR, JUN, SEP, NOV -> 30;
    case FEB -> {
   
        if (isLeapYear) yield 29;
        else yield 28;
    }
};

JDK 13-15：Text Blocks（文本块）

// 之前：字符串拼接
String html = "<html>\n" +
              "  <body>\n" +
              "    <p>Hello</p>\n" +
              "  </body>\n" +
              "</html>";

// JDK 15+：文本块（优雅~~~）
String html = """
              <html>
                <body>
                  <p>Hello</p>
                </body>
              </html>
              """;

JDK 14-16：Records（记录类）

// 之前：写一个数据类要一大堆代码
public class Person {
   
    private final String name;
    private final int age;
    public Person(String name, int age) {
   
        this.name = name;
        this.age = age;
    }
    // getter、equals、hashCode、toString...
}

// JDK 16+：用record一键生成
public record Person(String name, int age) {
   }

JDK 15-17：Sealed Classes（密封类）

// 限制类的继承关系
public sealed class Shape permits Circle, Rectangle, Square {
   
}

public final class Circle extends Shape {
   }     // final：不能再继承
public sealed class Rectangle extends Shape {
   }  // sealed：可以继续被继承
public non-sealed class Square extends Shape {
   } // non-sealed：随便继承

JDK 17（2021年）：第三个 LTS 版本，现代 Java 新标配

现代Java的标配！Spring Boot 3.x要求JDK 17+。

正式发布的特性：

Sealed Classes（密封类）
Pattern Matching for instanceof
强力封装JDK内部API
移除Applet

虚拟线程震撼登场：JDK 18 到 JDK 21 的并发革命（2022 - 2023）

JDK 21（2023年）：第四个 LTS 版本，并发编程新时代

JDK 21 的虚拟线程（Virtual Threads） 正式发布，这是一项颠覆性的技术。它可以让你在一个应用中轻松创建和管理上百万个并发线程，且几乎不消耗系统资源。

// 之前：传统线程，创建成本高
Thread thread = new Thread(() -> doWork());
thread.start();

// JDK 21+：虚拟线程，轻量级，可以创建百万个
Thread.startVirtualThread(() -> doWork());

// 或者用构建器
Thread virtualThread = Thread.ofVirtual()
    .name("my-vt")
    .start(() -> doWork());

一句话总结：高并发编程的门槛被 JDK 21 砸平了。

其他重要特性

结构化并发：更安全地管理并发任务
String Templates（预览）：更安全的字符串模板
Sequenced Collections：统一的顺序集合接口

避坑指南

1. 版本号混淆

“JDK 1.8” = “JDK 8” = “Java 8”，这是同一个东西的不同叫法。
别再说什么 J2SE 8 了，那个老黄历从 JDK 5 之后就翻篇了。

2. LTS 版本选择坑

千万别 看到新版本就无脑升到生产环境。
企业项目请认准 LTS 版本：
- JDK 8（已停止免费官方更新）
- JDK 11（支持至 2026 年）
- JDK 17（支持至 2029 年）
- JDK 21（支持至 2031 年，新项目强烈推荐）
Java SE 与 EE 混淆坑：
- Java SE 是地基，核心语法都在这。
- Java EE（现更名为 Jakarta EE）是建立在地基上的大楼，提供 Web 开发、企业服务等规范。
- 学 Java = 先学好 Java SE。

面试官最爱问的版本问题

JDK 8 有哪些核心新特性？

参考回答：

Lambda表达式：支持函数式编程，行为可以作为参数传递。
Stream API：提供流式操作集合的方式，支持链式调用。
接口默认方法：接口可以包含带方法体的默认实现。
新的日期时间API：java.time包，替代Date和Calendar。
Optional类：优雅地规避空指针异常。

为什么 JDK 8 这么重要，影响这么大？

参考回答：
JDK 8是Java历史上最重要的版本，原因有三点：

语法革命：Lambda 和 Stream 改变了我们思考和编写代码的方式。
生态依赖：它统治了企业级应用开发超过十年，无数框架（如 Spring Boot 2.x）都基于它。
思维转变：推动 Java 从纯命令式编程向声明式、函数式编程演进。

一张表总结 Java 版本演进

阶段	版本	核心意义
诞生	JDK 1.0	跨平台理念，Applet时代
成长	JDK 1.2-1.4	集合框架、NIO、JIT编译器
革命	JDK 5	泛型、注解、for-each、自动装箱
企业	JDK 6-7	企业级特性，性能优化
现代	JDK 8	Lambda、Stream、函数式编程
模块化	JDK 9-11	模块系统、HttpClient、var
成熟	JDK 12-17	Switch表达式、Records、密封类
并发	JDK 18-21	虚拟线程、结构化并发

一句话概括：Java从1996年走到今天，每个版本都在进步，JDK 8是转折点，JDK 21是新高点，学Java不懂历史，就像看剧不从头看一样，总会缺了点什么。

与君共勉

好了，Java 这 30 年的家族史咱们今天就盘到这里。从 1996 年的青涩诞生，到 JDK 8 的如日中天，再到 JDK 21 的自我革新，Java 始终在解决开发者痛点的路上不断进化。

有人说技术迭代太快，学了也用不上。但我觉得，了解历史不是为了背版本号、记特性列表，而是为了理解技术的演进逻辑——每一个新特性的出现，都是为了解决过去某个让人抓狂的难题。

Java能走过30年，靠的不是追风口、炒概念，而是一步一个脚印地解决实际问题：

觉得代码啰嗦？引入泛型、for-each
觉得并发难写？引入线程池、并发集合
觉得函数式编程优雅？引入Lambda、Stream
觉得高并发有瓶颈？引入虚拟线程

学Java也是一样，不是为了学而学，而是为了解决问题。

希望这篇文章能帮你理清 Java 版本的脉络，以后无论是面试还是做技术选型，心里都能更有底气。

如果你在学 Java 的过程中还遇到过其他奇葩的版本问题，或者觉得文章有哪里讲得不对、不清楚的地方，欢迎在评论区留言交流！ 你们的每一个问题，都是我下一篇笔记的灵感来源。如果觉得有用，也别忘了点个赞、收个藏，让更多的小伙伴看到。

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

一张图讲完Java 30年发展史，看完彻底搞懂版本演进