JDK 常用工具类系统分类与实战示例

关注

原创最新推荐文章于 2026-06-03 15:05:40 发布 1.2k 阅读 AI 写同款· GEO 优化 ›

Java中String类在JDK 8与JDK 11,JDK 17的底层实现变迁 JDK 8中，`String`对象基于`char[]`数组存储，每个字符占2个字节，支持完整的Unicode编码。到了JDK 11，为了优化内存使用，对于仅包含ASCII或类似单字节编码字符的字符串，`String`类改用`byte[]`数组存储，并引入了`coder`属性标识编码类型，节省了内存。而在JDK 17中，进一步引入了`hashIsZero`字段来优化哈希码的计算与存储，使得哈希码可以在创建时立即计算并标记是否为零，从而提升性能。阅读详情

作为一名 Java 后端开发程序员，熟练掌握 JDK 自带的工具类，是提升代码质量、效率与健壮性的关键。这些工具类经过严格测试、性能优化、线程安全设计，远胜于“手写轮子”。

下面我将 JDK 常用工具类按功能分类，精选高频、高价值的类，结合真实业务场景给出完整、可运行、带详细中文注释的示例，助你彻底掌握其在生产环境中的最佳实践。

✅ JDK 常用工具类系统分类与实战示例

一、集合操作工具类（`java.util` 包）

1. `Collections` —— 集合的静态工具方法（排序、查找、不可变封装）

作用：提供对 List、Set、Map 的通用操作，避免手动循环。

import java.util.*;

public class CollectionsExample {

    public static void main(String[] args) {
        List<String> names = Arrays.asList("张三", "李四", "王五", "赵六");

        // ✅ sort：对列表排序（自然顺序）
        Collections.sort(names);
        System.out.println("排序后：" + names); // [张三, 李四, 王五, 赵六]

        // ✅ reverse：反转列表
        Collections.reverse(names);
        System.out.println("反转后：" + names); // [赵六, 王五, 李四, 张三]

        // ✅ shuffle：随机打乱（用于抽奖、推荐排序）
        Collections.shuffle(names, new Random(100)); // 固定种子，便于测试
        System.out.println("随机打乱：" + names);

        // ✅ binarySearch：二分查找（要求已排序！）
        Collections.sort(names); // 必须先排序
        int index = Collections.binarySearch(names, "王五");
        System.out.println("王五索引：" + index); // 输出：2

        // ✅ max/min：查找最大/最小元素（需可比较）
        String maxName = Collections.max(names);
        String minName = Collections.min(names);
        System.out.println("最大：" + maxName + "，最小：" + minName);

        // ✅ unmodifiableXXX：创建不可变集合（防止外部修改，线程安全）
        List<String> immutableList = Collections.unmodifiableList(new ArrayList<>(names));
        // immutableList.add("新用户"); // ❌ 运行时报：UnsupportedOperationException

        // ✅ singleton：创建仅含一个元素的集合（常用于返回默认值）
        Set<String> singleUser = Collections.singleton("admin");
        System.out.println("单用户集合：" + singleUser); // [admin]

        // ✅ emptyXXX：返回空集合（避免返回 null）
        List<String> empty = Collections.emptyList();
        if (empty.isEmpty()) {
            System.out.println("✅ 返回空集合而非 null，安全可靠");
        }
    }
}

📌 应用场景：

API 返回不可变集合（防篡改）
单元测试中构造测试数据
避免 null 返回，使用 emptyList()、emptySet() 提升健壮性

2. `Arrays` —— 数组操作工具（排序、查找、转换）

作用：对数组进行高效操作，支持 toString()、equals()、copyOf()。

import java.util.Arrays;

public class ArraysExample {

    public static void main(String[] args) {
        int[] scores = {85, 92, 76, 98, 63};

        // ✅ sort：排序数组（原地修改）
        Arrays.sort(scores);
        System.out.println("排序后分数：" + Arrays.toString(scores)); // [63, 76, 85, 92, 98]

        // ✅ binarySearch：二分查找（必须排序！）
        int index = Arrays.binarySearch(scores, 92);
        System.out.println("92 的索引：" + index); // 输出：3

        // ✅ equals：比较两个数组内容是否相等（不是引用！）
        int[] scores2 = {63, 76, 85, 92, 98};
        boolean isEqual = Arrays.equals(scores, scores2);
        System.out.println("数组内容相等：" + isEqual); // true

        // ✅ toString：将数组转为可读字符串（替代手动拼接）
        System.out.println("数组内容：" + Arrays.toString(scores)); // [63, 76, 85, 92, 98]

        // ✅ fill：填充数组（如初始化默认值）
        int[] status = new int[5];
        Arrays.fill(status, 0); // 全部设为 0（未处理）
        System.out.println("初始化状态：" + Arrays.toString(status)); // [0, 0, 0, 0, 0]

        // ✅ copyOf：复制数组（扩展或截断）
        int[] extended = Arrays.copyOf(scores, 8); // 扩展到8个元素，后3个为0
        System.out.println("扩展后：" + Arrays.toString(extended)); // [63, 76, 85, 92, 98, 0, 0, 0]

        // ✅ asList：数组转 List（注意：返回的是固定大小的 List）
        List<Integer> list = Arrays.asList(1, 2, 3); // ⚠️ 不可 add/remove
        // list.add(4); // ❌ 抛出 UnsupportedOperationException
        // ✅ 正确做法：包装成可变集合
        List<Integer> mutableList = new ArrayList<>(Arrays.asList(1, 2, 3));
        mutableList.add(4);
        System.out.println("可变列表：" + mutableList); // [1, 2, 3, 4]
    }
}

📌 应用场景：

从数据库查询结果转为数组后排序
配置项初始化（如白名单数组）
避免 null 数组，使用 Arrays.asList() 快速构造测试数据

二、日期与时间工具类（`java.time` 包 —— JDK 8+ 推荐）

替代过时的 Date、SimpleDateFormat，线程安全、API 清晰。

1. `LocalDateTime` / `LocalDate` / `LocalTime`

import java.time.*;
import java.time.format.DateTimeFormatter;

public class DateTimeExample {

    public static void main(String[] args) {
        // ✅ LocalDateTime：日期+时间（无时区）
        LocalDateTime now = LocalDateTime.now();
        System.out.println("当前时间：" + now); // 2025-10-12T10:30:45.123

        // ✅ LocalDate：仅日期（如生日、合同日期）
        LocalDate birthDate = LocalDate.of(1990, 5, 15);
        System.out.println("出生日期：" + birthDate);

        // ✅ LocalTime：仅时间（如营业时间）
        LocalTime openTime = LocalTime.of(9, 0); // 09:00
        System.out.println("开门时间：" + openTime);

        // ✅ plus / minus：日期时间加减
        LocalDateTime oneWeekLater = now.plusWeeks(1);
        System.out.println("一周后：" + oneWeekLater);

        // ✅ between：计算时间差（天数）
        long daysBetween = ChronoUnit.DAYS.between(birthDate, LocalDate.now());
        System.out.println("年龄（天）：" + daysBetween);

        // ✅ format：格式化输出（线程安全！）
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formatted = now.format(formatter);
        System.out.println("格式化时间：" + formatted); // 2025-10-12 10:30:45

        // ✅ parse：字符串转日期时间
        LocalDateTime parsed = LocalDateTime.parse("2025-10-12T10:30:45", formatter);
        System.out.println("解析结果：" + parsed);
    }
}

2. `Duration` / `Period` —— 时间间隔计算

import java.time.Duration;
import java.time.Period;
import java.time.LocalDateTime;

public class DurationPeriodExample {

    public static void main(String[] args) {
        LocalDateTime start = LocalDateTime.now();
        try {
            Thread.sleep(2000); // 模拟耗时操作
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        LocalDateTime end = LocalDateTime.now();

        // ✅ Duration：计算两个时间点的差值（秒、毫秒）
        Duration duration = Duration.between(start, end);
        System.out.println("操作耗时：" + duration.toMillis() + " 毫秒");
        System.out.println("操作耗时：" + duration.getSeconds() + " 秒");

        // ✅ Period：计算两个日期的差值（年、月、日）
        LocalDate startDate = LocalDate.of(2024, 1, 15);
        LocalDate endDate = LocalDate.of(2025, 3, 20);
        Period period = Period.between(startDate, endDate);
        System.out.println("项目周期：" + period.getYears() + "年 " + period.getMonths() + "月 " + period.getDays() + "天");
        // 输出：1年 2月 5天
    }
}

📌 应用场景：

记录接口响应耗时（监控系统）
计算用户年龄、会员有效期
日志时间戳格式化（避免 SimpleDateFormat 线程不安全问题）
✅ 强烈推荐：所有新项目使用 java.time，禁用 Date 和 SimpleDateFormat

三、字符串处理工具类（`java.util` & `java.lang.String`）

1. `StringJoiner` —— 高效拼接带分隔符的字符串

替代 StringBuilder + 手动拼接逗号，语法更清晰。

import java.util.StringJoiner;

public class StringJoinerExample {

    public static void main(String[] args) {
        // ✅ 创建 StringJoiner，指定分隔符、前缀、后缀
        StringJoiner joiner = new StringJoiner(", ", "[", "]");

        // ✅ 添加多个元素
        joiner.add("苹果");
        joiner.add("香蕉");
        joiner.add("橙子");
        joiner.add("葡萄");

        String result = joiner.toString();
        System.out.println("水果列表：" + result); // [苹果, 香蕉, 橙子, 葡萄]

        // ✅ 与 Stream 结合使用（推荐）
        List<String> fruits = Arrays.asList("苹果", "香蕉", "橙子");
        String joined = fruits.stream()
                              .collect(Collectors.joining(", ", "[", "]"));
        System.out.println("Stream拼接：" + joined); // [苹果, 香蕉, 橙子]

        // ✅ 实际应用：构建 SQL IN 子句
        List<Long> userIds = Arrays.asList(101L, 102L, 103L);
        String inClause = "WHERE user_id IN (" + String.join(",", userIds.stream().map(String::valueOf).toArray(String[]::new)) + ")";
        System.out.println("SQL 条件：" + inClause); // WHERE user_id IN (101,102,103)
    }
}

2. `String.format()` —— 格式化输出（替代拼接）

public class StringFormatExample {

    public static void main(String[] args) {
        String name = "张三";
        int age = 28;
        double salary = 15000.50;

        // ✅ 格式化输出（类似 printf），清晰、可读、支持国际化
        String message = String.format("员工 %s，%d 岁，月薪 %.2f 元", name, age, salary);
        System.out.println(message); // 员工 张三，28 岁，月薪 15000.50 元

        // ✅ 多行日志格式化
        String log = String.format(
            "【%s】用户 %s（ID: %d）于 %s 登录系统，IP: %s",
            java.time.LocalDateTime.now().format(java.time.format.DateTimeFormatter.ofPattern("HH:mm:ss")),
            name,
            1001,
            "2025-10-12",
            "192.168.1.100"
        );
        System.out.println(log);
    }
}

📌 应用场景：

日志记录、API 响应格式化
邮件模板、短信内容生成
避免 + 拼接导致的性能问题和可读性差

3、正则表达式工具：`java.util.regex.Pattern` 和 `Matcher`

作用：高性能字符串匹配、提取、替换（比 String.contains()、split() 更强大）。

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexExample {

    public static void main(String[] args) {
        String text = "联系邮箱：zhangsan@example.com，电话：138-0013-8000，网址：https://www.example.com";

        // ✅ 提取邮箱：使用 Pattern 编译正则（复用，性能高）
        Pattern emailPattern = Pattern.compile("\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b");
        Matcher emailMatcher = emailPattern.matcher(text);

        System.out.println("🔍 提取邮箱：");
        while (emailMatcher.find()) {
            System.out.println("→ " + emailMatcher.group()); // 输出：zhangsan@example.com
        }

        // ✅ 提取手机号（支持多种格式）
        Pattern phonePattern = Pattern.compile("\\d{3}-\\d{4}-\\d{4}|\\d{11}");
        Matcher phoneMatcher = phonePattern.matcher(text);

        System.out.println("📞 提取手机号：");
        while (phoneMatcher.find()) {
            System.out.println("→ " + phoneMatcher.group()); // 输出：138-0013-8000
        }

        // ✅ 替换敏感信息（脱敏）
        String masked = text.replaceAll("\\d{3}-\\d{4}-\\d{4}", "***-****-****");
        System.out.println("脱敏后：" + masked);
        // 输出：联系邮箱：zhangsan@example.com，电话：***-****-****，网址：https://www.example.com

        // ✅ 验证邮箱格式（登录表单校验）
        String email = "test@domain.com";
        boolean isValid = Pattern.matches("\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b", email);
        System.out.println("邮箱是否有效：" + isValid); // true

        // ✅ 实际应用场景：日志解析、表单校验、敏感词过滤、数据清洗
    }
}

📌 使用场景：

用户输入校验（邮箱、手机号、身份证）
日志中提取 IP、URL、错误码
敏感信息脱敏（银行卡号、身份证号）
✅ 最佳实践：将 Pattern 编译为静态常量，避免每次创建（线程安全、高效）

private static final Pattern EMAIL_PATTERN = Pattern.compile(
    "\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b"
);

4、基础编码工具：`java.util.Base64`

作用：将二进制数据编码为 ASCII 字符串（用于传输、存储），替代过时的 sun.misc.BASE64Encoder。

import java.util.Base64;

public class Base64Example {

    public static void main(String[] args) throws Exception {
        String original = "Hello, Java Base64! 你好，世界！";

        // ✅ 编码：字符串 → Base64
        String encoded = Base64.getEncoder().encodeToString(original.getBytes("UTF-8"));
        System.out.println("Base64 编码：" + encoded);
        // 输出：SGVsbG8sIEphdmEgQmFzZTY0ISA556uL5L2g5L2c5L2T！

        // ✅ 解码：Base64 → 原始字符串
        byte[] decodedBytes = Base64.getDecoder().decode(encoded);
        String decoded = new String(decodedBytes, "UTF-8");
        System.out.println("Base64 解码：" + decoded); // Hello, Java Base64! 你好，世界！

        // ✅ 实际应用场景：
        // 1. HTTP Basic Auth：用户名密码编码
        String credentials = "admin:password123";
        String authHeader = "Basic " + Base64.getEncoder().encodeToString(credentials.getBytes("UTF-8"));
        System.out.println("Authorization 头：" + authHeader);
        // 输出：Basic YWRtaW46cGFzc3dvcmQxMjM=

        // 2. 图片/文件转 Base64 嵌入 HTML 或 JSON
        // 3. JWT Token 的 payload 编码

        // ✅ ✅ ✅ 推荐：所有新项目使用 `java.util.Base64`，禁用 sun.misc 包（非标准，可能被移除）
    }
}

📌 使用场景：

HTTP 请求头认证（Basic Auth）
图片、PDF 等二进制数据嵌入 JSON 响应
JWT、Token 传输
✅ JDK 8+ 标准化，性能高、线程安全

五、数学与随机工具类

1. `Math` —— 数学运算（幂、对数、取整、绝对值）

public class MathExample {

    public static void main(String[] args) {
        // ✅ abs：绝对值
        System.out.println("绝对值：" + Math.abs(-10.5)); // 10.5

        // ✅ max / min：取最大/最小值
        System.out.println("最大值：" + Math.max(10, 20)); // 20

        // ✅ pow：幂运算
        System.out.println("2^8：" + Math.pow(2, 8)); // 256.0

        // ✅ sqrt：平方根
        System.out.println("√144：" + Math.sqrt(144)); // 12.0

        // ✅ ceil / floor：向上/向下取整
        System.out.println("ceil(3.2)：" + Math.ceil(3.2)); // 4.0
        System.out.println("floor(3.8)：" + Math.floor(3.8)); // 3.0

        // ✅ round：四舍五入
        System.out.println("round(3.5)：" + Math.round(3.5)); // 4

        // ✅ random：生成 0.0 ~ 1.0 的随机数
        double random = Math.random();
        System.out.println("随机数：" + random);

        // ✅ 生成 1~100 的随机整数
        int randomInt = (int) (Math.random() * 100) + 1;
        System.out.println("1~100 随机数：" + randomInt);
    }
}

2. `Random` / `SecureRandom` —— 随机数生成

import java.security.SecureRandom;
import java.util.Random;

public class RandomExample {

    public static void main(String[] args) {
        Random random = new Random();

        // ✅ 生成随机整数（0 ~ 99）
        int randInt = random.nextInt(100);
        System.out.println("随机整数：" + randInt);

        // ✅ 生成随机布尔值
        boolean flag = random.nextBoolean();
        System.out.println("随机布尔：" + flag);

        // ✅ SecureRandom：加密安全随机数（用于 token、密钥、验证码）
        SecureRandom secureRandom = new SecureRandom();
        byte[] token = new byte[16];
        secureRandom.nextBytes(token);
        String securityToken = java.util.Base64.getEncoder().encodeToString(token);
        System.out.println("安全 Token：" + securityToken); // 如：aB3xK9pLmN2qR8vYtZ5w==
    }
}

四、安全的随机数生成器：`java.security.SecureRandom`（再次强调！）

作用：密码学安全的随机数生成器，防预测、防攻击，用于令牌、密钥、验证码。

import java.security.SecureRandom;

public class SecureRandomExample {

    public static void main(String[] args) {
        SecureRandom secureRandom = new SecureRandom();

        // ✅ 生成 16 字节随机字节（用于 AES 密钥、JWT 签名密钥）
        byte[] key = new byte[16];
        secureRandom.nextBytes(key);
        String secretKey = java.util.Base64.getEncoder().encodeToString(key);
        System.out.println("🔐 生成的安全密钥：" + secretKey);

        // ✅ 生成 6 位数字验证码（短信/邮箱验证）
        int verificationCode = secureRandom.nextInt(900000) + 100000; // 100000 ~ 999999
        System.out.println("📱 验证码：" + verificationCode);

        // ✅ 生成 UUID（安全版本）
        String uuid = java.util.UUID.randomUUID().toString();
        System.out.println("🔗 安全 UUID：" + uuid);

        // ✅ 生成 32 位随机字符串（用于临时登录令牌）
        StringBuilder token = new StringBuilder();
        String chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
        for (int i = 0; i < 32; i++) {
            token.append(chars.charAt(secureRandom.nextInt(chars.length())));
        }
        System.out.println("🔑 临时登录令牌：" + token.toString());

        // ✅ 实际应用场景：
        // - JWT 签名密钥
        // - API Key / Client Secret
        // - 重置密码 Token
        // - 会话 ID（Session ID）
        // ✅ ❗ **生产环境必须使用 SecureRandom！禁止使用 Random！**
    }
}

📌 安全规范：

任何用于身份认证、加密、防重放攻击的随机值，必须使用 SecureRandom
java.util.Random 是伪随机，可被预测，在金融、支付、登录系统中是严重安全漏洞

📌 应用场景：

生成订单号、验证码、临时密码
模拟测试数据
✅ 生产环境生成安全令牌，必须使用 SecureRandom，避免 Random 被预测

二、安全的系统属性与环境变量访问：`java.lang.System.getProperty()` / `getenv()`

作用：读取 JVM 启动参数和操作系统环境变量，但必须做空值检查和类型转换。

public class SystemPropertiesExample {

    public static void main(String[] args) {
        // ✅ 获取 JVM 系统属性（启动参数）
        String javaVersion = System.getProperty("java.version");
        String javaHome = System.getProperty("java.home");
        String osName = System.getProperty("os.name");
        String userDir = System.getProperty("user.dir"); // 当前工作目录

        System.out.println("Java 版本：" + javaVersion);
        System.out.println("Java 安装路径：" + javaHome);
        System.out.println("操作系统：" + osName);
        System.out.println("工作目录：" + userDir);

        // ✅ 获取环境变量（生产环境配置）
        String dbUrl = System.getenv("DB_URL");
        String dbUser = System.getenv("DB_USERNAME");
        String dbPassword = System.getenv("DB_PASSWORD");

        // ✅ 安全处理：永远不要直接使用，必须判空
        if (dbUrl == null || dbUrl.isBlank()) {
            throw new IllegalStateException("❌ 环境变量 DB_URL 未设置，请检查部署配置");
        }
        if (dbPassword == null) {
            System.err.println("⚠️ DB_PASSWORD 未设置，使用默认值（仅限测试）");
            dbPassword = "test123";
        }

        System.out.println("数据库连接：" + dbUrl + " 用户：" + dbUser);

        // ✅ 实际应用：Spring Boot 的 application.yml 中的 ${DB_URL} 就是基于此机制
        // ✅ 生产环境规范：所有敏感配置（密码、密钥）必须通过环境变量注入，禁止写入代码或配置文件！

        // ✅ 获取自定义 JVM 参数（启动时加：-Dapp.mode=prod）
        String appMode = System.getProperty("app.mode", "dev"); // ✅ 提供默认值
        System.out.println("应用模式：" + appMode);

        // ✅ 避免使用 System.setProperty() 修改系统属性（线程不安全，影响全局）
    }
}

📌 使用场景：

读取数据库 URL、API 密钥、端口号（必须用环境变量）
判断运行环境（dev/test/prod）
✅ 安全规范：绝不在代码中硬编码密码、密钥、证书路径，全部通过 -D 或 export 注入

六、文件与 I/O 工具类（`java.nio.file` —— JDK 7+）

`Files` —— 文件操作（读写、复制、删除、遍历）

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.List;

public class FilesExample {

    public static void main(String[] args) throws IOException {
        Path source = Paths.get("src/main/resources/input.txt");
        Path target = Paths.get("src/main/resources/output.txt");

        // ✅ write：写入文件（自动创建目录）
        String content = "Hello, Java NIO!\n这是第一行。\n这是第二行。";
        Files.write(target, content.getBytes("UTF-8")); // ✅ 自动创建文件

        // ✅ readAllLines：读取所有行
        List<String> lines = Files.readAllLines(target);
        System.out.println("读取行数：" + lines.size());
        for (String line : lines) {
            System.out.println("→ " + line);
        }

        // ✅ copy：复制文件
        Files.copy(target, Paths.get("src/main/resources/copy.txt"), StandardCopyOption.REPLACE_EXISTING);

        // ✅ exists / isFile / isDirectory：判断文件属性
        System.out.println("文件是否存在：" + Files.exists(target));
        System.out.println("是否为文件：" + Files.isRegularFile(target));

        // ✅ delete：删除文件
        Files.deleteIfExists(Paths.get("src/main/resources/copy.txt")); // 安全删除，不存在不报错

        // ✅ walkFileTree：递归遍历目录（如清理临时文件）
        Path dir = Paths.get("src/main/resources");
        Files.walkFileTree(dir, new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                if (file.toString().endsWith(".tmp")) {
                    System.out.println("删除临时文件：" + file);
                    Files.delete(file);
                }
                return FileVisitResult.CONTINUE;
            }
        });
    }
}

📌 应用场景：

日志文件清理
配置文件读取
批量导入导出文件
✅ 推荐：所有文件操作使用 java.nio.file.Files，替代过时的 java.io.File

我们继续深入挖掘 JDK 中那些真正支撑企业级系统稳定运行的底层工具类。你提到的 Files、Paths 和 Objects 正是其中的“黄金三剑客”——它们在文件操作、路径安全、对象健壮性这三个最易出错的领域，提供了工业级的解决方案。

下面我将为你系统性、深度展开这两个主题：

✅ java.nio.file.Files 与 java.nio.file.Paths：现代文件 I/O 的终极规范
✅ java.util.Objects：对象安全操作的完整实战手册（含 10 种生产场景）

每个示例都基于真实后端开发场景，附带详细中文注释、异常处理、最佳实践和避坑指南，确保你写出的代码不仅正确，而且安全、可维护、经得起生产压测。

✅ 一、现代文件与路径操作：`Files` 与 `Paths`（JDK 7+）

为什么必须用 Files 和 Paths？
java.io.File 是 1996 年的设计，不支持 Unicode 路径、无异常细粒度控制、无法处理符号链接、线程不安全。
java.nio.file 是 2011 年重新设计的现代、安全、功能完整的文件系统 API，所有新项目必须使用它。

🌟 实战示例：文件系统操作的完整生产级实践

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.stream.Stream;

public class FilesPathsExample {

    // ✅ 路径常量：避免硬编码，提升可移植性
    private static final Path LOG_DIR = Paths.get("logs");
    private static final Path TEMP_DIR = Paths.get("temp");
    private static final Path CONFIG_FILE = Paths.get("config/app.properties");
    private static final DateTimeFormatter FILENAME_FORMAT = DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss");

    public static void main(String[] args) throws IOException {
        // ==================== 1. 路径构建：Paths.get() 是唯一推荐方式 ====================
        // ✅ 正确：使用 Paths.get() 构建路径（自动处理分隔符，跨平台）
        Path logFile = LOG_DIR.resolve("app_" + LocalDateTime.now().format(FILENAME_FORMAT) + ".log");
        System.out.println("日志文件路径：" + logFile); // logs/app_20251012_113045.log

        // ❌ 错误：不要用 String 拼接！Windows 用 \，Linux 用 /，极易出错
        // String badPath = "logs" + File.separator + "app.log"; // 不推荐！
        // String worsePath = "logs/app.log"; // ❌ 硬编码，不跨平台！

        // ✅ 从相对路径转绝对路径（用于日志、临时文件）
        Path absoluteLog = logFile.toAbsolutePath();
        System.out.println("绝对路径：" + absoluteLog);

        // ==================== 2. 目录创建：安全、递归、幂等 ====================
        // ✅ createDirectories：递归创建所有父目录，已存在不报错（幂等）
        Files.createDirectories(LOG_DIR);
        Files.createDirectories(TEMP_DIR);
        System.out.println("✅ 日志目录和临时目录已创建（若不存在）");

        // ==================== 3. 文件写入：自动创建文件，指定编码 ====================
        String logContent = "【" + LocalDateTime.now() + "】用户登录成功，IP: 192.168.1.100\n";
        // ✅ write：自动创建文件，UTF-8 编码，安全写入
        Files.write(logFile, logContent.getBytes("UTF-8"), StandardOpenOption.CREATE, StandardOpenOption.APPEND);
        System.out.println("✅ 日志已追加写入：" + logFile);

        // ==================== 4. 文件读取：按行读取大文件（避免 OOM） ====================
        // ✅ readAllLines：适合小文件（<100MB）
        List<String> lines = Files.readAllLines(CONFIG_FILE);
        System.out.println("配置文件行数：" + lines.size());
        for (String line : lines) {
            if (line.trim().startsWith("db.url")) {
                String dbUrl = line.substring(line.indexOf("=") + 1).trim();
                System.out.println("数据库地址：" + dbUrl);
            }
        }

        // ✅ lines()：流式读取大文件（推荐用于日志分析、CSV 处理）
        try (Stream<String> stream = Files.lines(logFile)) {
            long errorCount = stream.filter(line -> line.contains("ERROR"))
                                   .count();
            System.out.println("日志中错误数量：" + errorCount);
        } // ✅ 自动关闭流，避免句柄泄漏

        // ==================== 5. 文件复制与移动：安全、支持覆盖 ====================
        Path backupFile = LOG_DIR.resolve("app_backup.log");
        // ✅ copy：支持覆盖、保留属性
        Files.copy(logFile, backupFile, StandardCopyOption.REPLACE_EXISTING);
        System.out.println("✅ 日志已备份至：" + backupFile);

        // ✅ move：原子性移动（重命名），适合“写入完成”后切换文件
        Path finalLog = LOG_DIR.resolve("app_final.log");
        Files.move(backupFile, finalLog, StandardCopyOption.REPLACE_EXISTING);
        System.out.println("✅ 备份已重命名为最终日志：" + finalLog);

        // ==================== 6. 文件属性：获取权限、大小、时间 ====================
        BasicFileAttributes attrs = Files.readAttributes(logFile, BasicFileAttributes.class);
        System.out.println("文件大小：" + attrs.size() + " 字节");
        System.out.println("创建时间：" + attrs.creationTime());
        System.out.println("最后修改时间：" + attrs.lastModifiedTime());
        System.out.println("是否为目录：" + attrs.isDirectory());

        // ==================== 7. 删除文件/目录：安全、递归、容错 ====================
        // ✅ deleteIfExists：不存在不报错（推荐写法）
        Files.deleteIfExists(TEMP_DIR.resolve("temp_file.tmp"));
        System.out.println("✅ 临时文件已尝试删除（不存在也不报错）");

        // ✅ deleteRecursively：递归删除整个目录（如清理临时目录）
        Path tempDir = Paths.get("temp");
        if (Files.exists(tempDir)) {
            Files.walkFileTree(tempDir, new SimpleFileVisitor<Path>() {
                @Override
                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                    Files.delete(file); // 删除文件
                    return FileVisitResult.CONTINUE;
                }

                @Override
                public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
                    Files.delete(dir); // 删除空目录
                    return FileVisitResult.CONTINUE;
                }
            });
            System.out.println("✅ 临时目录 temp 已被彻底清理");
        }

        // ==================== 8. 判断文件是否存在、是否为符号链接 ====================
        Path symlink = Paths.get("config_link");
        if (Files.exists(symlink) && Files.isSymbolicLink(symlink)) {
            Path target = Files.readSymbolicLink(symlink);
            System.out.println("符号链接指向：" + target);
        }

        // ==================== 9. 创建临时文件/目录：用于缓存、上传、下载 ====================
        // ✅ createTempFile：自动生成唯一文件名，避免冲突
        Path tempFile = Files.createTempFile("upload_", ".tmp");
        System.out.println("✅ 临时上传文件：" + tempFile);

        // ✅ createTempDirectory：安全创建临时目录
        Path tempUploadDir = Files.createTempDirectory("upload_");
        System.out.println("✅ 临时上传目录：" + tempUploadDir);

        // ✅ 自动清理：生产环境必须在 finally 或 try-with-resources 中删除
        try {
            Files.write(tempFile, "临时数据".getBytes("UTF-8"));
            // ... 业务处理
        } finally {
            Files.deleteIfExists(tempFile); // ✅ 必须清理！
            Files.deleteIfExists(tempUploadDir); // ✅ 必须清理！
        }

        // ==================== 10. 检查文件权限（Linux/Unix 环境） ====================
        // ✅ 仅在类 Unix 系统有意义
        if (System.getProperty("os.name").toLowerCase().contains("nix") ||
            System.getProperty("os.name").toLowerCase().contains("mac")) {
            try {
                boolean canRead = Files.isReadable(logFile);
                boolean canWrite = Files.isWritable(logFile);
                System.out.println("日志文件可读：" + canRead + "，可写：" + canWrite);
            } catch (IOException e) {
                System.err.println("❌ 检查文件权限失败：" + e.getMessage());
            }
        }
    }
}

✅ 生产环境最佳实践总结（Files/Paths）

场景推荐做法禁用做法
路径构建 Paths.get("a", "b", "c") "a/b/c" 字符串拼接
创建目录 Files.createDirectories(path) new File(path).mkdirs()
写入文件 Files.write(path, bytes, CREATE, APPEND) FileOutputStream 手动管理
读取大文件 Files.lines(path) + try-with-resources Files.readAllLines() 读取 GB 级文件
删除文件 Files.deleteIfExists(path) file.delete() 不判断是否存在
删除目录 Files.walkFileTree(...) 递归删除 rmdir 命令（不可靠）
临时文件 Files.createTempFile() 手动命名 temp123.txt
编码始终使用 "UTF-8" 使用默认编码（Charset.defaultCharset()）

场景	推荐做法	禁用做法
路径构建	`Paths.get("a", "b", "c")`	`"a/b/c"` 字符串拼接
创建目录	`Files.createDirectories(path)`	`new File(path).mkdirs()`
写入文件	`Files.write(path, bytes, CREATE, APPEND)`	`FileOutputStream` 手动管理
读取大文件	`Files.lines(path)` + try-with-resources	`Files.readAllLines()` 读取 GB 级文件
删除文件	`Files.deleteIfExists(path)`	`file.delete()` 不判断是否存在
删除目录	`Files.walkFileTree(...)` 递归删除	`rmdir` 命令（不可靠）
临时文件	`Files.createTempFile()`	手动命名 `temp123.txt`
编码	始终使用 `"UTF-8"`	使用默认编码（`Charset.defaultCharset()`）

📌 致命警告：

不要用 File！它在 Windows 上不支持 Unicode 文件名，且无异常分类。
所有文件操作必须使用 try-with-resources 或 finally 清理，避免句柄泄漏（尤其在 Linux 服务器上）。
临时文件必须主动删除，否则会占用磁盘空间，导致服务宕机。

✅ 二、对象安全操作：`java.util.Objects` —— 10 种生产级使用场景详解

Objects 是 Java 7 引入的防御性编程神器，它让你的代码不再被 NullPointerException 攻击，是团队代码质量的底线。

🌟 实战示例：`Objects` 的 10 种高价值用法（完整注释）

import java.util.*;
import java.util.Objects;

public class ObjectsSafetyExample {

    // ✅ 场景 1：构造器参数校验 —— 快速失败，明确错误信息
    public class UserService {
        private final String username;
        private final String email;

        public UserService(String username, String email) {
            // ✅ Objects.requireNonNull：参数不能为空，且提供清晰错误信息
            this.username = Objects.requireNonNull(username, "用户名不能为空");
            this.email = Objects.requireNonNull(email, "邮箱不能为空");

            // ✅ 额外校验：邮箱格式（可结合正则）
            if (!email.contains("@")) {
                throw new IllegalArgumentException("邮箱格式无效：" + email);
            }
        }

        public String getUsername() { return username; }
        public String getEmail() { return email; }
    }

    // ✅ 场景 2：重写 equals() —— 安全比较，避免 null 指针
    public class Product {
        private final String name;
        private final Double price;

        public Product(String name, Double price) {
            this.name = name;
            this.price = price;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Product)) return false;
            Product product = (Product) o;
            // ✅ Objects.equals：null 安全比较，推荐写法
            return Objects.equals(name, product.name) &&
                   Objects.equals(price, product.price);
        }

        @Override
        public int hashCode() {
            // ✅ Objects.hash：自动生成安全的 hashCode（自动处理 null）
            return Objects.hash(name, price);
        }
    }

    // ✅ 场景 3：对象属性打印 —— 避免 "null" 字符串污染日志
    public class Order {
        private String orderId;
        private String customerName;
        private String shippingAddress;

        public Order(String orderId, String customerName, String shippingAddress) {
            this.orderId = orderId;
            this.customerName = customerName;
            this.shippingAddress = shippingAddress;
        }

        @Override
        public String toString() {
            return "Order{" +
                    "orderId='" + Objects.toString(orderId, "未分配") + '\'' +
                    ", customerName='" + Objects.toString(customerName, "匿名用户") + '\'' +
                    ", shippingAddress='" + Objects.toString(shippingAddress, "未填写") + '\'' +
                    '}';
        }
    }

    // ✅ 场景 4：集合元素安全访问 —— 防止空指针
    public class OrderService {
        public String getCustomerNameFromOrder(Order order) {
            // ✅ Objects.nonNull：判断非空（与 requireNonNull 配合）
            if (Objects.nonNull(order) && Objects.nonNull(order.getCustomerName())) {
                return order.getCustomerName();
            }
            return "未知客户";
        }

        // ✅ 使用 Optional + Objects.nonNull（现代写法）
        public Optional<String> findCustomerName(Order order) {
            return Objects.nonNull(order) ? Optional.ofNullable(order.getCustomerName()) : Optional.empty();
        }
    }

    // ✅ 场景 5：Map 键值安全处理 —— 避免 NPE 在业务逻辑中传播
    public class ConfigManager {
        private final Map<String, String> config = new HashMap<>();

        public String getConfig(String key) {
            // ✅ Objects.requireNonNullElse：若为 null，返回默认值
            return Objects.requireNonNullElse(config.get(key), "default_value");
        }

        public String getConfigWithFallback(String key, String fallback) {
            // ✅ Objects.requireNonNullElseGet：延迟计算默认值（性能优化）
            return Objects.requireNonNullElseGet(config.get(key), () -> {
                System.out.println("⚠️ 配置 " + key + " 未设置，使用默认值");
                return fallback;
            });
        }
    }

    // ✅ 场景 6：方法返回值校验 —— 防止 null 从方法中逃逸
    public class DataProvider {
        public List<String> getActiveUsers() {
            // ✅ Objects.requireNonNull：确保返回值不为 null
            List<String> users = fetchUsersFromDB(); // 可能返回 null
            return Objects.requireNonNull(users, "获取用户列表失败，返回 null");
        }

        private List<String> fetchUsersFromDB() {
            // 模拟数据库查询失败
            return null; // 本应抛异常，但为演示
        }
    }

    // ✅ 场景 7：断言调试（仅开发环境）
    public class DebugHelper {
        public void validateUser(User user) {
            // ✅ Objects.requireNonNull：开发阶段快速失败，生产环境可关闭
            Objects.requireNonNull(user, "用户对象必须存在（调试断言）");
            // 生产环境应使用 @NonNull 注解 + Lombok 或静态分析工具
        }
    }

    // ✅ 场景 8：比较两个对象是否相等（非 null 安全）
    public class ComparatorHelper {
        public boolean areEqual(Object a, Object b) {
            // ✅ Objects.equals：推荐的相等判断，完全安全
            return Objects.equals(a, b);
        }

        public void test() {
            System.out.println(Objects.equals(null, null)); // true
            System.out.println(Objects.equals("abc", "abc")); // true
            System.out.println(Objects.equals("abc", null)); // false
            System.out.println(Objects.equals(null, "def")); // false
        }
    }

    // ✅ 场景 9：字符串安全拼接（结合 Objects.toString）
    public class LogFormatter {
        public String formatLog(String level, String message, Object... args) {
            StringBuilder sb = new StringBuilder();
            sb.append("[").append(level).append("] ");
            sb.append(message);
            if (args != null && args.length > 0) {
                sb.append(" | 参数：");
                for (Object arg : args) {
                    sb.append(Objects.toString(arg, "<null>")).append(", ");
                }
                sb.setLength(sb.length() - 2); // 删除最后的 ", "
            }
            return sb.toString();
        }
    }

    // ✅ 场景 10：链式调用中的安全保护（避免层层 null 判断）
    public class UserContext {
        private String userId;
        private String tenantId;

        public String getUserId() { return userId; }
        public String getTenantId() { return tenantId; }

        public static class Service {
            public String getTenantInfo(UserContext ctx) {
                // ✅ 传统写法：层层 if (ctx != null && ctx.getUserId() != null)
                // ❌ 冗长、易错、难维护

                // ✅ Objects.nonNull + Optional 链式写法（现代风格）
                return Optional.ofNullable(ctx)
                        .map(UserContext::getTenantId)
                        .filter(tenantId -> !tenantId.isBlank())
                        .orElse("DEFAULT_TENANT");
            }
        }
    }

    // ==================== 主方法：测试所有场景 ====================
    public static void main(String[] args) {
        // ✅ 场景 1：构造器校验
        try {
            new UserService(null, "test@example.com"); // 抛出：用户名不能为空
        } catch (IllegalArgumentException e) {
            System.out.println("✅ 构造器校验触发：" + e.getMessage());
        }

        // ✅ 场景 2：equals/hashCode
        Product p1 = new Product("iPhone", 999.99);
        Product p2 = new Product("iPhone", 999.99);
        Product p3 = new Product(null, null);

        System.out.println("p1 == p2：" + p1.equals(p2)); // true
        System.out.println("p1.hashCode() == p2.hashCode()：" + (p1.hashCode() == p2.hashCode())); // true
        System.out.println("p3 toString：" + p3); // Product{name='null', price='null'} → 但 hashCode 仍安全

        // ✅ 场景 3：toString 安全
        Order order = new Order(null, null, null);
        System.out.println("订单信息：" + order);
        // 输出：Order{orderId='未分配', customerName='匿名用户', shippingAddress='未填写'}

        // ✅ 场景 4：安全访问
        OrderService os = new OrderService();
        System.out.println("客户名称：" + os.getCustomerNameFromOrder(null)); // 未知客户

        // ✅ 场景 5：Map 默认值
        ConfigManager cm = new ConfigManager();
        cm.config.put("db.url", "jdbc:mysql://localhost");
        System.out.println("数据库 URL：" + cm.getConfig("db.url")); // jdbc:mysql://localhost
        System.out.println("未配置项：" + cm.getConfig("nonexist")); // default_value
        System.out.println("带提示的默认值：" + cm.getConfigWithFallback("missing", "fallback_value"));

        // ✅ 场景 6：返回值校验
        DataProvider dp = new DataProvider();
        try {
            dp.getActiveUsers(); // 抛出：获取用户列表失败，返回 null
        } catch (NullPointerException e) {
            System.out.println("✅ 返回值校验触发：" + e.getMessage());
        }

        // ✅ 场景 7：调试断言
        DebugHelper dh = new DebugHelper();
        try {
            dh.validateUser(null); // 抛出：用户对象必须存在（调试断言）
        } catch (NullPointerException e) {
            System.out.println("✅ 调试断言触发：" + e.getMessage());
        }

        // ✅ 场景 8：相等判断
        ComparatorHelper ch = new ComparatorHelper();
        ch.test();

        // ✅ 场景 9：日志拼接
        LogFormatter lf = new LogFormatter();
        System.out.println(lf.formatLog("INFO", "用户登录", "张三", 28, true)); // [INFO] 用户登录 | 参数：张三, 28, true
        System.out.println(lf.formatLog("WARN", "权限不足", null)); // [WARN] 权限不足 | 参数：<null>

        // ✅ 场景 10：链式安全
        UserContext context = new UserContext();
        context.tenantId = "tenant-001";
        System.out.println("租户信息：" + UserContext.Service.getTenantInfo(context)); // tenant-001

        context.tenantId = null;
        System.out.println("租户信息（null）：" + UserContext.Service.getTenantInfo(context)); // DEFAULT_TENANT
    }
}

✅ Objects 工具类使用黄金法则（生产规范）

场景推荐写法禁用写法
参数校验 Objects.requireNonNull(param, "message") if (param == null) throw ...
equals 比较 Objects.equals(a, b) a.equals(b)（可能 NPE）
hashCode 生成 Objects.hash(fields...) 手动拼接，忽略 null
字符串默认值 Objects.toString(obj, "默认") obj != null ? obj : "默认"
Map 默认值 Objects.requireNonNullElse(map.get(key), "default") map.containsKey(key) ? map.get(key) : ...
返回值保证 return Objects.requireNonNull(result, "结果不能为 null") 直接返回可能为 null 的对象
链式安全 Optional.ofNullable(obj).map(...).orElse(...) 多层 if (obj != null)

场景	推荐写法	禁用写法
参数校验	`Objects.requireNonNull(param, "message")`	`if (param == null) throw ...`
equals 比较	`Objects.equals(a, b)`	`a.equals(b)`（可能 NPE）
hashCode 生成	`Objects.hash(fields...)`	手动拼接，忽略 null
字符串默认值	`Objects.toString(obj, "默认")`	`obj != null ? obj : "默认"`
Map 默认值	`Objects.requireNonNullElse(map.get(key), "default")`	`map.containsKey(key) ? map.get(key) : ...`
返回值保证	`return Objects.requireNonNull(result, "结果不能为 null")`	直接返回可能为 null 的对象
链式安全	`Optional.ofNullable(obj).map(...).orElse(...)`	多层 if (obj != null)

📌 团队强制规范建议：

所有 public 方法参数，必须使用 Objects.requireNonNull 校验
所有 equals()、hashCode()、toString()，必须使用 Objects 工具类
所有日志输出对象，必须用 Objects.toString(obj, "<null>") 包裹
所有配置项获取，必须用 Objects.requireNonNullElse 提供默认值

✅ 最终总结：JDK 工具类的“三座大山”

类别	工具类	作用	生产必用
文件系统	`Files`, `Paths`	安全、跨平台、现代文件 I/O	✅ 绝对必须
对象安全	`Objects`	防空指针、安全比较、默认值	✅ 绝对必须

💡 记住这句话：
“一个没有使用 Objects.requireNonNull 的 Java 项目，是裸奔的；一个没有使用 Files 的 Java 项目，是活在 2005 年的。”

✅ 总结：JDK 工具类使用黄金法则

类别	推荐工具	禁用旧方式	原因
集合操作	`Collections`、`Arrays`	手写循环	更安全、高效、可读
日期时间	`LocalDateTime`、`Duration`	`Date`、`SimpleDateFormat`	线程安全、API 清晰
字符串拼接	`StringJoiner`、`String.join()`	`+` 拼接	性能好、语义明确
并发 Map	`ConcurrentHashMap`	`Hashtable`、`synchronizedMap`	性能提升 10x+
随机数	`SecureRandom`	`Random`（安全场景）	防预测、防攻击
文件操作	`Files`、`Path`	`java.io.File`	更现代、支持 NIO、路径安全
格式化输出	`String.format()`	字符串拼接	易维护、支持国际化