yyds，JDK 25 终结 import，可以像 Python 一样简单粗暴了

不知道大家第一次写Java程序时，是否有过这样的困惑？为什么String不用导入就能直接用，但List就必须写import java.util.List;？用星号*导入某个包下所有类（比如import java.util.*;）会不会有性能损耗？Stream类到底在java.util.stream还是java.util.function包下？

这些看似基础的导入问题，不仅困扰着Java新手，连不少资深开发者在切换场景时也会频频卡顿。更有网友直言羡慕Python中"开箱即用"的模块机制------不用在代码头部堆砌大量导入语句，就能直接使用核心功能。为了解决这个痛点，JEP 511（Module Import Declarations）提案应运而生，并在JDK 25中正式落地。这个特性让Java拥有了真正的模块级导入能力，只需一行import module java.base;，就能直接使用54个核心包中的数千个类。

一、先搞懂：Java导入机制的"前世今生"

在聊JDK 25的新特性前，我们得先弄明白：Java的导入机制为什么会让人"头疼"？这一切要从Java的包结构设计说起。

1.1 传统导入的两种方式与痛点

Java传统的导入方式分为"精确导入"和"通配符导入"两种，二者各有局限：

• 精确导入 ：比如import java.util.List;，仅导入指定类。优点是明确清晰，IDE能精准提示；缺点是当需要使用多个包的类时，代码头部会被大量导入语句占据，显得臃肿。

• 通配符导入 ：比如import java.util.*;，导入指定包下所有类。优点是减少导入语句数量；但缺点也很明显------无法直观知道使用了哪些类，多个包存在同名类时会出现冲突（比如java.util.Date和java.sql.Date），还会让新手误以为"星号会导入子包的类"（实际不会，比如java.util.*不会导入java.util.stream下的类）。

1.2 为什么String不用导入？

回到开头的问题：String属于java.lang包，而Java编译器会默认导入java.lang.*，所以不需要手动导入。但像List（java.util包）、HashMap（java.util包）这些不属于java.lang的类，就必须手动导入。

这个"默认导入"的设计，本质是为了简化核心类的使用，但也让不少新手对"导入规则"产生了认知偏差。

1.3 通配符导入的性能谣言？

很多人担心"用星号导入会影响程序性能"，其实这是个谣言。Java的导入机制仅作用于编译期------编译器会根据导入语句找到对应的类并生成全限定名，最终的字节码中使用的都是类的全限定名（比如java.util.List），与导入方式无关。无论是精确导入还是通配符导入，生成的字节码和运行时性能完全一致。

通配符导入的真正问题是"代码可读性和维护性"，而非性能。

二、JDK 25救场：模块级导入是什么？

JEP 511提出的"模块级导入"，核心是打破传统"包级导入"的限制，直接基于Java 9引入的"模块系统"进行导入。简单来说，就是通过导入一个模块，直接使用该模块下所有导出包的类。

2.1 核心原理：模块与导出包

Java 9及以后的JDK被拆分为多个模块（比如java.base、java.sql、java.xml等），每个模块会在module-info.java中声明"导出的包"（用exports关键字）。其他模块只能使用被导出的包中的类。

以最核心的java.base模块为例，它导出了java.lang、java.util、java.io、java.math等54个基础包------这些包基本涵盖了Java开发的日常需求。JDK 25的模块级导入，就是直接导入整个模块，从而获得该模块下所有导出包的使用权限。

2.2 语法：一行代码搞定核心导入

模块级导入的语法非常简洁，格式为：

import module 模块名;

比如导入核心的java.base模块，只需一行：

import module java.base;

这一行代码的效果，相当于导入了java.base模块下所有54个导出包的类------无论是java.lang.String、java.util.List，还是java.io.File、java.util.stream.Stream，都能直接使用，无需再写单独的包级导入语句。

2.3 与传统导入的对比：代码瞬间"瘦身"

我们用一个简单的案例对比传统导入和模块级导入的差异。假设要写一个程序，实现"读取文件内容并按行排序"，传统写法的导入语句会非常多：

// 传统导入：需要逐个导入用到的包
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

public class FileSortDemo {
    public static void main(String[] args) throws IOException {
        List<String> lines = new ArrayList<>();
        try (BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                lines.add(line);
            }
        }
        // 使用Stream排序
        List<String> sortedLines = lines.stream()
                .sorted()
                .collect(Collectors.toList());
        System.out.println(sortedLines);
    }
}

而使用JDK 25的模块级导入后，代码会变得异常简洁：

// 模块级导入：一行搞定所有核心包
import module java.base;

public class FileSortDemo {
    public static void main(String[] args) throws IOException {
        List<String> lines = new ArrayList<>();
        try (BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                lines.add(line);
            }
        }
        List<String> sortedLines = lines.stream()
                .sorted()
                .collect(Collectors.toList());
        System.out.println(sortedLines);
    }
}

可以看到，导入语句从6行缩减为1行，代码可读性大幅提升，同时避免了漏导包的问题。

三、进阶使用：模块级导入的场景与技巧

模块级导入并非"万能"，它有特定的使用场景和注意事项。合理使用才能发挥其最大价值。

3.1 核心使用场景

• 快速开发与原型验证：在写Demo、工具类或原型代码时，不需要关注具体的包结构，一行模块导入就能快速上手，提升开发效率。

• 新手入门：减少新手对"包和导入"的认知负担，让他们更专注于核心语法逻辑，而非纠结"类在哪个包下"。

• 通用业务开发 ：日常开发中，java.base模块的54个包基本能覆盖80%以上的需求，模块级导入足以满足开发需求。

3.2 多模块导入：按需组合

如果需要使用java.base之外的模块（比如数据库相关的java.sql模块），只需追加模块导入语句即可。例如：

// 导入核心模块和数据库模块
import module java.base;
import module java.sql;

public class JdbcDemo {
    public static void main(String[] args) throws Exception {
        // 使用java.sql包下的类，无需单独导入
        Class.forName("com.mysql.cj.jdbc.Driver");
        try (java.sql.Connection conn = java.sql.DriverManager.getConnection(
                "jdbc:mysql://localhost:3306/test", "root", "password")) {
            java.sql.Statement stmt = conn.createStatement();
            java.sql.ResultSet rs = stmt.executeQuery("SELECT * FROM user");
            while (rs.next()) {
                System.out.println(rs.getString("username"));
            }
        }
    }
}

这里导入了java.sql模块后，Connection、Statement等类都能直接使用。

3.3 解决类名冲突：模块级导入的优先级

当多个模块的导出包中存在同名类时，模块级导入会如何处理？答案是"精确导入优先于模块级导入"，我们可以通过精确导入来指定使用哪个类。

例如，java.util.Date和java.sql.Date是两个同名类，都分别在java.base和java.sql模块中。如果同时导入这两个模块，直接使用Date会报错，此时只需添加精确导入即可解决：

import module java.base;
import module java.sql;
// 精确导入指定使用java.util.Date
import java.util.Date;

public class DateDemo {
    public static void main(String[] args) {
        Date utilDate = new Date(); // 正常使用java.util.Date
        java.sql.Date sqlDate = new java.sql.Date(System.currentTimeMillis()); // 用全限定名区分
    }
}

这种"模块级导入+精确导入"的组合方式，既保留了模块导入的简洁性，又解决了类名冲突问题。

3.4 自定义模块的导入：非JDK模块也能用

模块级导入不仅适用于JDK自带的模块，也适用于我们自定义的模块。假设我们有一个自定义模块com.example.utils，其module-info.java如下：

module com.example.utils {
    // 导出工具包
    exports com.example.utils.string;
    exports com.example.utils.collection;
}

在另一个模块中，要使用这个自定义模块的类，只需导入该模块即可：

// 导入自定义模块
import module com.example.utils;

public class CustomModuleDemo {
    public static void main(String[] args) {
        // 直接使用自定义模块导出包中的类
        StringUtils.trim("  hello  ");
        CollectionUtils.isEmpty(new ArrayList<>());
    }
}

这对于大型项目的模块间调用非常友好，无需记忆每个工具类的具体包路径。

四、避坑指南：模块级导入的注意事项

虽然模块级导入很方便，但也有一些需要注意的"坑"，提前了解能避免踩雷。

4.1 仅能导入"导出的包"

模块级导入只能使用目标模块明确导出 的包中的类。如果某个模块的包没有用exports声明，即使导入了模块，也无法使用该包的类。

例如，JDK的java.base模块没有导出sun.misc包（这是内部包），所以即使导入了java.base模块，也无法直接使用sun.misc.Unsafe类------这和传统导入的规则一致，本质是保护模块的内部实现。

4.2 不建议在复杂场景过度使用

在大型框架开发、开源项目或需要严格控制依赖的场景中，不建议过度依赖模块级导入。因为这类场景需要清晰的依赖关系，精确导入能让代码的依赖更透明，便于后续的维护和重构。

简单来说：日常开发用模块级导入提效，复杂项目用精确导入保清晰。

4.3 IDE支持是前提

目前，IntelliJ IDEA、Eclipse等主流IDE已针对JDK 25的模块级导入特性提供了支持，但需要将项目的JDK版本切换到JDK 25及以上，并在IDE设置中启用相关特性。如果使用旧版本IDE，可能会出现语法报错（即使代码能正常编译运行）。

五、总结：Java导入机制的进化意义

从java.lang的默认导入，到通配符导入，再到JDK 25的模块级导入，Java的导入机制一直在朝着"简洁、高效"的方向进化。JEP 511带来的模块级导入，本质上是Java模块系统的进一步落地------它不仅解决了传统导入的臃肿问题，更让开发者从"关注包"转向"关注模块"，这与现代编程语言的设计理念（如Python的模块、Go的包）接轨。

对于开发者而言，这个特性的价值在于：

• 新手：降低入门门槛，不用再死记硬背类的包路径；

• 熟手：减少重复劳动，让代码更简洁，专注核心业务逻辑；

• 团队：统一导入规范，减少因导入方式引发的代码冲突。

如果你已经升级到JDK 25，不妨在下次开发中试试import module java.base;，体验一下"一行导入千个类"的便捷。当然，也别忘了根据项目场景灵活搭配精确导入，让代码既简洁又清晰。

最后，你觉得模块级导入能彻底解决Java的导入痛点吗？欢迎在评论区分享你的使用体验！

资料

• openjdk.org/jeps/511
• www.oracle.com/news/announ...