Hutool 入门指南：快速掌握这个Java开发利器
在Java开发的世界里，我们常常需要处理字符串、日期、文件、集合、JSON、HTTP请求等各种常见任务。虽然Java标准库提供了一些基础API，但有时候使用起来会显得比较繁琐和冗长。为了提高开发效率，减少重复造轮子，许多优秀的第三方工具库应运而生。其中，Hutool (读音：[hu:tu:l]，类似于“糊涂”) 是近年来备受Java开发者青睐的一个国产开源工具库。
Hutool 就像它的名字一样，提供了一系列“糊涂”但却非常实用的工具，将Java中的很多常用功能封装起来，用更简洁优雅的方式呈现。它涵盖了开发中各个方面的工具类，包括但不限于：类型转换、字符串处理、日期时间、集合操作、文件操作、I/O流、加密解密、HTTP客户端、反射、JSON处理、Excel操作等等。Hutool 的设计目标是让Java开发变得更简单、更高效。
本文将作为一个入门指南，带你一步步了解 Hutool，学会如何在你的项目中使用它，并快速掌握一些最常用的功能，体验它作为“Java开发利器”的强大之处。
为什么选择 Hutool？
在深入学习之前，我们先来看看 Hutool 究竟有什么优势，为什么值得我们投入时间去学习和使用它：
- 功能全面，开箱即用： Hutool 涵盖了日常开发中绝大多数的工具类需求，你无需再引入大量零散的第三方库，一个 Hutool 就能解决很多问题。
- API简洁优雅： Hutool 大量使用了静态方法和链式调用的设计，使得代码更加简洁、易读、易写。告别冗长的API调用，让代码更具表达力。
- 减少依赖，无第三方依赖： Hutool 的核心模块
hutool-core是完全没有第三方依赖的。其他模块（如hutool-json,hutool-http等）可能会引入少量必要的第三方库，但整体依赖管理相对简单。 - 模块化设计： Hutool 采用了模块化设计，你可以根据项目需要只引入特定的模块，而不是整个库，这有助于减小项目体积。
- 活跃的社区和详尽的文档： Hutool 拥有活跃的开发者社区和非常详尽的官方文档（包括中文文档和Javadoc），遇到问题很容易找到解决方案。
- 持续更新和维护： Hutool 作为一个广受欢迎的开源项目，一直在积极更新和维护，不断增加新的功能和优化现有代码。
总而言之，Hutool 能够极大地提升开发效率，减少代码量，让开发者能够更专注于业务逻辑的实现。
前置准备
在开始使用 Hutool 之前，你需要具备以下基础：
- 基本的 Java 编程知识。
- 一个Java开发环境 (JDK)。
- 一个集成开发环境 (IDE)，如 IntelliJ IDEA, Eclipse 等。
- 一个项目构建工具，如 Maven 或 Gradle。
本文将主要使用 Maven 作为构建工具进行示例。
如何在项目中使用 Hutool
使用 Hutool 最简单的方式是通过 Maven 或 Gradle 将其作为依赖添加到你的项目中。
Maven 依赖
在你的 pom.xml 文件中，找到 <dependencies> 标签，添加 Hutool 的核心模块依赖：
xml
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.25</version> <!-- 请替换为中央仓库中的最新版本 -->
</dependency>
这里我们使用了 hutool-all 模块，它包含了 Hutool 的所有子模块。这样做的好处是方便快捷，一次性引入所有功能。但如果你的项目对依赖管理有严格要求，希望只引入需要的功能，你可以改为引入特定的模块，例如：
- 核心模块 (
hutool-core)：包含了字符串、日期、集合、文件、反射等基础工具。 - JSON模块 (
hutool-json)：用于JSON的处理。 - HTTP模块 (
hutool-http)：用于HTTP客户端操作。 - …等等
比如，如果你只需要核心功能和 JSON 功能，可以这样引入：
“`xml
“`
注意： 这里的版本号 5.8.25 仅为示例，请务必查阅 Maven Central 或 Hutool 官方文档获取最新的稳定版本号。
添加完依赖后，保存 pom.xml 文件，Maven 会自动下载所需的 Hutool 库。
Gradle 依赖
如果你使用 Gradle，在你的 build.gradle 文件中，找到 dependencies 块，添加如下代码：
gradle
implementation 'cn.hutool:hutool-all:5.8.25' // 请替换为中央仓库中的最新版本
同样，你也可以只引入特定的模块。
Hutool 核心功能概览与实战
Hutool 的强大之处在于它提供了大量实用的工具类，几乎覆盖了Java开发的方方面面。下面我们将详细介绍一些最常用、最能体现 Hutool 优势的核心功能模块，并通过代码示例来展示它们的用法。
1. 字符串工具 – StrUtil (hutool-core)
字符串处理是日常开发中最常见的任务之一。Java 内置的 String 类提供了一些基本方法，但对于判空、去空格、分割、格式化等常见操作，Hutool 的 StrUtil 提供了更加便捷的方法。
-
判断字符串是否为空或空白：
“`java
import cn.hutool.core.util.StrUtil;public class StrUtilExample {
public static void main(String[] args) {
String str1 = null;
String str2 = “”;
String str3 = ” “;
String str4 = “hello”;// 判断是否为 null 或 "" System.out.println("str1 is empty: " + StrUtil.isEmpty(str1)); // true System.out.println("str2 is empty: " + StrUtil.isEmpty(str2)); // true System.out.println("str3 is empty: " + StrUtil.isEmpty(str3)); // false System.out.println("str4 is empty: " + StrUtil.isEmpty(str4)); // false System.out.println("---"); // 判断是否为 null, "", 或只有空白字符 System.out.println("str1 is blank: " + StrUtil.isBlank(str1)); // true System.out.println("str2 is blank: " + StrUtil.isBlank(str2)); // true System.out.println("str3 is blank: " + StrUtil.isBlank(str3)); // true System.out.println("str4 is blank: " + StrUtil.isBlank(str4)); // false }}
``StrUtil.isEmpty()相当于str == null || str.length() == 0，而StrUtil.isBlank()则更进一步判断是否为null` 或只包含空白字符（空格、Tab、换行等），这在实际开发中非常实用。 -
去除字符串两端的空白字符：
“`java
import cn.hutool.core.util.StrUtil;public class StrUtilExample2 {
public static void main(String[] args) {
String str = ” Hello Hutool! “;
String trimmedStr = StrUtil.trim(str); // 也可以用 trimStart/trimEnd 去除头部或尾部
System.out.println(“Original: ‘” + str + “‘”);
System.out.println(“Trimmed: ‘” + trimmedStr + “‘”); // ‘Hello Hutool!’// 判空后去除 System.out.println("Trim or Empty: '" + StrUtil.trimToEmpty(null) + "'"); // '' System.out.println("Trim or Null: " + StrUtil.trimToNull(" ")); // null }}
“` -
字符串分割：
“`java
import cn.hutool.core.util.StrUtil;
import java.util.List;public class StrUtilExample3 {
public static void main(String[] args) {
String str = “apple,banana,orange”;
// 分割并去除两端空白
Listlist = StrUtil.splitTrim(str, ‘,’);
System.out.println(list); // [apple, banana, orange]String str2 = "a,,b, c "; // 分割并去除空元素 List<String> list2 = StrUtil.split(str2, ',', true, true); // 分隔符，是否去除空白，是否忽略空元素 System.out.println(list2); // [a, b, c] }}
“` -
字符串格式化： Hutool 提供了类似于 SLF4J 的占位符格式化方式
{}。“`java
import cn.hutool.core.util.StrUtil;public class StrUtilExample4 {
public static void main(String[] args) {
String template = “Hello {}, welcome to {}!”;
String formatted = StrUtil.format(template, “Hutool”, “Java World”);
System.out.println(formatted); // Hello Hutool, welcome to Java World!
}
}
“`
StrUtil 中还有大量其他实用的方法，如 contains()、startWith()、endWith()、reverse()、upperCase()、lowerCase() 等，都比原生方法更加便利或提供了额外的选项（如忽略大小写）。
2. 日期时间工具 – DateUtil (hutool-core)
Java 的日期时间处理在 Java 8 引入 java.time 包之前一直比较麻烦。Hutool 的 DateUtil 在此基础上做了进一步封装，提供了更易用的 API。
-
获取当前时间：
“`java
import cn.hutool.core.date.DateUtil;
import java.util.Date;public class DateUtilExample {
public static void main(String[] args) {
Date now = DateUtil.date(); // 获取当前时间 Date 对象
System.out.println(“Current Date (Date object): ” + now);String nowStr = DateUtil.now(); // 获取当前时间字符串，格式：yyyy-MM-dd HH:mm:ss System.out.println("Current Time (String): " + nowStr); String todayStr = DateUtil.today(); // 获取当前日期字符串，格式：yyyy-MM-dd System.out.println("Today's Date (String): " + todayStr); }}
“` -
字符串转换为日期对象： Hutool 可以智能识别多种日期格式。
“`java
import cn.hutool.core.date.DateUtil;
import java.util.Date;public class DateUtilExample2 {
public static void main(String[] args) {
String dateStr1 = “2023-10-27”;
Date date1 = DateUtil.parse(dateStr1);
System.out.println(“Parsed Date 1: ” + date1);String dateStr2 = "2023-10-27 10:30:00"; Date date2 = DateUtil.parse(dateStr2); System.out.println("Parsed Date 2: " + date2); String dateStr3 = "2023/10/27 10:30:00.123"; Date date3 = DateUtil.parse(dateStr3); System.out.println("Parsed Date 3: " + date3); // 指定格式解析 String dateStr4 = "2023年10月27日"; Date date4 = DateUtil.parse(dateStr4, "yyyy年MM月dd日"); System.out.println("Parsed Date 4: " + date4); }}
“` -
日期对象转换为字符串：
“`java
import cn.hutool.core.date.DateUtil;
import java.util.Date;public class DateUtilExample3 {
public static void main(String[] args) {
Date date = new Date();// 默认格式化 yyyy-MM-dd HH:mm:ss String format1 = DateUtil.format(date, "yyyy-MM-dd HH:mm:ss"); System.out.println("Formatted 1: " + format1); // 自定义格式化 String format2 = DateUtil.format(date, "yyyy年MM月dd日 E HH:mm:ss"); // E表示星期几 System.out.println("Formatted 2: " + format2); // 一些预设格式 String format3 = DateUtil.formatDateTime(date); // yyyy-MM-dd HH:mm:ss System.out.println("Formatted 3 (DateTime): " + format3); String format4 = DateUtil.formatDate(date); // yyyy-MM-dd System.out.println("Formatted 4 (Date): " + format4); String format5 = DateUtil.formatTime(date); // HH:mm:ss System.out.println("Formatted 5 (Time): " + format5); }}
“` -
日期计算： 增加或减少年、月、日、时、分、秒等。
“`java
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.date.DatePattern;
import java.util.Date;public class DateUtilExample4 {
public static void main(String[] args) {
String dateStr = “2023-10-27 10:30:00”;
Date date = DateUtil.parse(dateStr);// 增加1天 Date newDate1 = DateUtil.offsetDay(date, 1); System.out.println("After 1 day: " + DateUtil.format(newDate1, DatePattern.NORM_DATETIME_PATTERN)); // 2023-10-28 10:30:00 // 增加2小时 Date newDate2 = DateUtil.offsetHour(date, 2); System.out.println("After 2 hours: " + DateUtil.format(newDate2, DatePattern.NORM_DATETIME_PATTERN)); // 2023-10-27 12:30:00 // 减少30分钟 Date newDate3 = DateUtil.offsetMinute(date, -30); System.out.println("Before 30 minutes: " + DateUtil.format(newDate3, DatePattern.NORM_DATETIME_PATTERN)); // 2023-10-27 10:00:00 }}
“` -
计算时间间隔：
“`java
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.date.BetweenFormatter;
import java.util.Date;public class DateUtilExample5 {
public static void main(String[] args) {
String dateStr1 = “2023-10-27 10:00:00”;
String dateStr2 = “2023-10-28 11:30:50”;
Date date1 = DateUtil.parse(dateStr1);
Date date2 = DateUtil.parse(dateStr2);// 计算相差毫秒数 long betweenMs = DateUtil.betweenMs(date1, date2); System.out.println("Milliseconds difference: " + betweenMs); // 计算相差天数 long betweenDays = DateUtil.betweenDays(date1, date2); System.out.println("Days difference: " + betweenDays); // 1 // 格式化输出时间间隔 String betweenTime = DateUtil.formatBetween(date1, date2, BetweenFormatter.Level.MINUTE); System.out.println("Time between: " + betweenTime); // 1天1小时30分 }}
``DateUtil` 还提供了很多其他功能，如获取年龄、判断星座生肖、判断是否闰年等，都非常方便。
3. 文件工具 – FileUtil (hutool-core)
文件和目录操作是另一个常见的需求。Java 原生 File 类功能相对有限，NIO.2 虽然强大但使用起来略复杂。FileUtil 提供了简洁易用的文件操作方法。
-
创建文件和目录：
“`java
import cn.hutool.core.io.FileUtil;
import java.io.File;public class FileUtilExample {
public static void main(String[] args) {
// 在当前项目目录下创建文件
File file = FileUtil.touch(“test.txt”);
System.out.println(“Created file: ” + file.getAbsolutePath());// 创建多级目录 File dir = FileUtil.mkdir("path/to/new/directory"); System.out.println("Created directory: " + dir.getAbsolutePath()); // 在指定目录下创建文件 File fileInDir = FileUtil.touch(dir, "another.txt"); System.out.println("Created file in dir: " + fileInDir.getAbsolutePath()); }}
``touch()方法会创建文件及其父目录（如果不存在），mkdir()` 会创建目录及其父目录。 -
读写文件：
“`java
import cn.hutool.core.io.FileUtil;
import java.util.List;public class FileUtilExample2 {
public static void main(String[] args) {
String content = “Hello, Hutool FileUtil!\nThis is a test line.”;
String filePath = “test_write.txt”;// 写文件 (覆盖模式) FileUtil.writeUtf8String(content, filePath); System.out.println("Content written to " + filePath); // 读文件 (按行读取) List<String> lines = FileUtil.readUtf8Lines(filePath); System.out.println("Content read from " + filePath + ":"); for (String line : lines) { System.out.println(line); } // 追加内容 FileUtil.appendUtf8String("\nAppend new line.", filePath); System.out.println("Content appended to " + filePath); // 再次读取确认 String fullContent = FileUtil.readUtf8String(filePath); System.out.println("Full content after append:\n" + fullContent); }}
``FileUtil` 提供了多种读写方法，支持不同的编码（如 UTF-8）、读写方式（按行、按块、输入输出流等）。 -
复制、移动、删除文件/目录：
“`java
import cn.hutool.core.io.FileUtil;
import java.io.File;public class FileUtilExample3 {
public static void main(String[] args) {
File srcFile = FileUtil.touch(“src.txt”);
FileUtil.writeUtf8String(“Source content”, srcFile);// 复制文件 File destFile = FileUtil.copy(srcFile, FileUtil.file("dest.txt"), true); // true表示覆盖目标文件 System.out.println("Copied " + srcFile.getName() + " to " + destFile.getName()); // 创建一个目录用于测试移动 File moveDir = FileUtil.mkdir("move_target"); // 移动文件 File movedFile = FileUtil.move(destFile, moveDir, true); // true表示覆盖目标位置同名文件 System.out.println("Moved " + destFile.getName() + " to " + movedFile.getAbsolutePath()); // 删除文件 boolean deletedSrc = FileUtil.del(srcFile); System.out.println("Deleted " + srcFile.getName() + ": " + deletedSrc); // 删除目录及其下所有文件 boolean deletedDir = FileUtil.del(moveDir); System.out.println("Deleted directory " + moveDir.getName() + ": " + deletedDir); }}
“` -
获取文件信息：
“`java
import cn.hutool.core.io.FileUtil;
import java.io.File;public class FileUtilExample4 {
public static void main(String[] args) {
File file = FileUtil.touch(“info_test.txt”);
FileUtil.writeUtf8String(“Some content here.”, file);System.out.println("File name: " + file.getName()); System.out.println("Is file: " + file.isFile()); System.out.println("Is directory: " + file.isDirectory()); System.out.println("Absolute path: " + file.getAbsolutePath()); System.out.println("File size (bytes): " + FileUtil.size(file)); System.out.println("File extension: " + FileUtil.extName(file)); // txt System.out.println("Parent directory: " + FileUtil.getParent(file, 1)); // 上一级目录 }}
``FileUtil` 还提供了遍历目录、获取文件名（不带扩展名）、判断文件类型等实用方法。
4. 集合工具 – CollUtil, ListUtil, MapUtil (hutool-core)
Hutool 为 Java 集合框架提供了大量增强功能，简化了集合的创建、判空、遍历、转换、操作等。
-
判断集合是否为空：
CollUtil是处理所有Collection类型的工具类。“`java
import cn.hutool.core.collection.CollUtil;
import java.util.ArrayList;
import java.util.List;public class CollUtilExample {
public static void main(String[] args) {
Listlist1 = null;
Listlist2 = new ArrayList<>();
Listlist3 = CollUtil.newArrayList(“a”, “b”); System.out.println("list1 is empty: " + CollUtil.isEmpty(list1)); // true System.out.println("list2 is empty: " + CollUtil.isEmpty(list2)); // true System.out.println("list3 is empty: " + CollUtil.isEmpty(list3)); // false System.out.println("list1 is not empty: " + CollUtil.isNotEmpty(list1)); // false System.out.println("list3 is not empty: " + CollUtil.isNotEmpty(list3)); // true }}
``MapUtil
同样，也提供了isEmpty()和isNotEmpty()` 方法。 -
快速创建集合： Hutool 提供了一系列
newXXX方法，简化集合的创建。“`java
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.map.MapUtil;
import java.util.List;
import java.util.Map;public class CollUtilExample2 {
public static void main(String[] args) {
Listlist = CollUtil.newArrayList(“a”, “b”, “c”);
System.out.println(“New List: ” + list); // [a, b, c]// 使用数组创建列表 List<Integer> intList = CollUtil.toList(1, 2, 3, 4); System.out.println("New List from array: " + intList); // [1, 2, 3, 4] Map<String, Integer> map = MapUtil.newHashMap(); map.put("key1", 100); map.put("key2", 200); System.out.println("New Map: " + map); // {key1=100, key2=200} // 快速创建 Map Map<String, String> map2 = MapUtil.of("k1", "v1", "k2", "v2"); System.out.println("Quick Map: " + map2); // {k1=v1, k2=v2} }}
“` -
集合操作： 合并、交集、差集等。
“`java
import cn.hutool.core.collection.CollUtil;
import java.util.List;public class CollUtilExample3 {
public static void main(String[] args) {
Listlist1 = CollUtil.newArrayList(“a”, “b”, “c”, “c”);
Listlist2 = CollUtil.newArrayList(“c”, “d”, “e”); // 合并 (保留重复元素) List<String> union = CollUtil.union(list1, list2); System.out.println("Union: " + union); // [a, b, c, c, c, d, e] // 交集 (保留相同元素) List<String> intersection = CollUtil.intersection(list1, list2); System.out.println("Intersection: " + intersection); // [c] // 差集 (list1中有，list2中没有) List<String> disjunction = CollUtil.disjunction(list1, list2); System.out.println("Disjunction (list1 - list2): " + disjunction); // [a, b, c] }}
“` -
列表特有操作 –
ListUtil：“`java
import cn.hutool.core.collection.ListUtil;
import java.util.List;public class ListUtilExample {
public static void main(String[] args) {
Listlist = ListUtil.of(“a”, “b”, “c”, “d”, “e”); // 获取子列表 (包头不包尾) List<String> subList = ListUtil.sub(list, 1, 4); System.out.println("Sub List: " + subList); // [b, c, d] // 列表分区 (每2个元素分一组) List<List<String>> partition = ListUtil.partition(list, 2); System.out.println("Partition: " + partition); // [[a, b], [c, d], [e]] // 列表反转 ListUtil.reverse(list); // 注意：这是in-place操作，会修改原列表 System.out.println("Reversed List: " + list); // [e, d, c, b, a] // 复制列表 (不会修改原列表) List<String> copiedList = ListUtil.copy(list); System.out.println("Copied List: " + copiedList); }}
“`
5. Bean 工具 – BeanUtil (hutool-core)
在Java开发中，我们经常需要在不同的 Bean (Java对象) 之间拷贝属性，或者将 Map 转换为 Bean，将 Bean 转换为 Map 等。BeanUtil 极大地简化了这些操作。
-
属性拷贝：
“`java
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.CopyOptions;public class BeanUtilExample {
public static class SourceBean { private String name; private int age; private String address; // 源对象有但目标对象没有 // Getters and Setters public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } } public static class TargetBean { private String name; private int age; private String phone; // 目标对象有但源对象没有 // Getters and Setters public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getPhone() { return phone; } public void setPhone(String phone) { this.phone = phone; } @Override public String toString() { return "TargetBean{" + "name='" + name + '\'' + ", age=" + age + ", phone='" + phone + '\'' + '}'; } } public static void main(String[] args) { SourceBean source = new SourceBean(); source.setName("Alice"); source.setAge(30); source.setAddress("Some Street"); TargetBean target = new TargetBean(); target.setPhone("123456789"); // 目标对象已有的属性不会被覆盖，除非设置 CopyOptions // 默认拷贝同名属性，忽略源对象或目标对象中不存在的属性 BeanUtil.copyProperties(source, target); System.out.println("After copy: " + target); // TargetBean{name='Alice', age=30, phone='123456789'} // 使用 CopyOptions 配置，例如覆盖非空属性，忽略某个属性 TargetBean target2 = new TargetBean(); target2.setPhone("987654321"); // 这个值会被覆盖，因为源对象的age是基本类型，非空 CopyOptions copyOptions = CopyOptions.create() .setIgnoreNullValue(false) // 是否忽略空值，false表示不忽略，即源为null时会覆盖目标值 .setIgnoreProperties("age"); // 忽略拷贝age属性 BeanUtil.copyProperties(source, target2, copyOptions); System.out.println("After copy with options: " + target2); // TargetBean{name='Alice', age=0, phone='123456789'} -- age被忽略，phone被覆盖 }}
``BeanUtil.copyProperties()是最常用的方法，它可以方便地在两个对象之间按名称拷贝属性。通过CopyOptions` 可以进行更精细的控制，如是否忽略空值、是否忽略某些属性、是否转换类型等。 -
Map 转 Bean / Bean 转 Map：
“`java
import cn.hutool.core.bean.BeanUtil;
import java.util.Map;public class BeanUtilExample2 {
public static class MyBean { private String code; private String message; public String getCode() { return code; } public void setCode(String code) { this.code = code; } public String getMessage() { return message; } public void setMessage(String message) { this.message = message; } @Override public String toString() { return "MyBean{" + "code='" + code + '\'' + ", message='" + message + '\'' + '}'; } } public static void main(String[] args) { // Map 转 Bean Map<String, Object> map = MapUtil.newHashMap(); map.put("code", "200"); map.put("message", "Success"); MyBean bean = BeanUtil.toBean(map, MyBean.class, false); // false表示不忽略大小写 System.out.println("Map to Bean: " + bean); // MyBean{code='200', message='Success'} // Bean 转 Map Map<String, Object> beanMap = BeanUtil.beanToMap(bean); System.out.println("Bean to Map: " + beanMap); // {code=200, message=Success} }}
“`
这在处理配置、接口参数、数据库结果集等场景下非常有用。
6. JSON 工具 – JSONUtil (hutool-json)
处理 JSON 数据是现代应用中必不可少的部分。Hutool 的 hutool-json 模块提供了方便的 JSON 转换工具，底层可以适配 Fastjson、Jackson、Gson 等主流 JSON 库。
-
对象转 JSON 字符串：
“`java
import cn.hutool.json.JSONUtil;
import java.util.HashMap;
import java.util.Map;public class JsonUtilExample {
public static void main(String[] args) {
Map
map.put(“name”, “Hutool”);
map.put(“age”, 5);
map.put(“active”, true);// Map 转 JSON 字符串 String jsonStr = JSONUtil.toJsonStr(map); System.out.println("Map to JSON: " + jsonStr); // {"name":"Hutool","age":5,"active":true} // Bean 转 JSON 字符串 (假设有一个 MyBean 类) MyBean bean = new MyBean(); bean.setCode("001"); bean.setMessage("Hello JSON"); String beanJsonStr = JSONUtil.toJsonStr(bean); System.out.println("Bean to JSON: " + beanJsonStr); // {"code":"001","message":"Hello JSON"} } public static class MyBean { private String code; private String message; public String getCode() { return code; } public void setCode(String code) { this.code = code; } public String getMessage() { return message; } public void setMessage(String message) { this.message = message; } }}
“` -
JSON 字符串转对象/Map：
“`java
import cn.hutool.json.JSONUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONArray;
import java.util.List;
import java.util.Map;public class JsonUtilExample2 {
public static void main(String[] args) {
String jsonObjectStr = “{\”name\”:\”Hutool\”,\”age\”:5,\”active\”:true}”;// JSON 对象字符串转 JSONObject JSONObject jsonObject = JSONUtil.parseObj(jsonObjectStr); System.out.println("Parsed JSONObject: " + jsonObject); // {"name":"Hutool","age":5,"active":true} System.out.println("Get name: " + jsonObject.getStr("name")); // Hutool System.out.println("Get age: " + jsonObject.getInt("age")); // 5 // JSON 对象字符串转 Bean MyBean bean = JSONUtil.toBean(jsonObjectStr, MyBean.class); System.out.println("JSON to Bean: " + bean); // MyBean{code='null', message='null'} <-- 注意：如果key名称和bean属性名不一致，需要配置或确保key一致 // 示例2：key一致的Bean String beanJsonStr = "{\"code\":\"200\",\"message\":\"Success\"}"; MyBean bean2 = JSONUtil.toBean(beanJsonStr, MyBean.class); System.out.println("JSON to Bean 2: " + bean2); // MyBean{code='200', message='Success'} // JSON 数组字符串转 JSONArray / List String jsonArrayStr = "[{\"code\":\"001\",\"message\":\"Msg1\"}, {\"code\":\"002\",\"message\":\"Msg2\"}]"; JSONArray jsonArray = JSONUtil.parseArray(jsonArrayStr); System.out.println("Parsed JSONArray: " + jsonArray); List<MyBean> beanList = JSONUtil.toList(jsonArray, MyBean.class); System.out.println("JSON Array to List<Bean>: " + beanList); // [MyBean{code='001', message='Msg1'}, MyBean{code='002', message='Msg2'}] // JSON 对象字符串转 Map Map<String, Object> map = JSONUtil.toBean(jsonObjectStr, Map.class); System.out.println("JSON to Map: " + map); // {name=Hutool, age=5, active=true} } public static class MyBean { private String code; private String message; public String getCode() { return code; } public void setCode(String code) { this.code = code; } public String getMessage() { return message; } public void setMessage(String message) { this.message = message; } @Override public String toString() { return "MyBean{" + "code='" + code + '\'' + ", message='" + message + '\'' + '}'; } }}
“`
JSONUtil 提供了丰富的 parseXXX 和 toXXX 方法，支持各种类型之间的转换，非常灵活。
7. HTTP 客户端 – HttpUtil (hutool-http)
在后端开发中，调用外部 HTTP 接口是家常便饭。Hutool 的 hutool-http 模块提供了一个简洁易用的 HTTP 客户端工具。
-
发送 GET 请求：
“`java
import cn.hutool.http.HttpUtil;public class HttpUtilExample {
public static void main(String[] args) {
String url = “https://www.baidu.com”;
String result = HttpUtil.get(url);
System.out.println(“GET request result from ” + url + “:”);
System.out.println(result.substring(0, 200) + “…”); // 打印部分结果
}
}
``HttpUtil.get()` 方法非常简单，直接传入 URL 即可。 -
发送 POST 请求：
“`java
import cn.hutool.http.HttpUtil;
import java.util.HashMap;
import java.util.Map;public class HttpUtilExample2 {
public static void main(String[] args) {
String url = “https://httpbin.org/post”; // 一个测试 POST 请求的网站Map<String, Object> paramMap = new HashMap<>(); paramMap.put("name", "Hutool"); paramMap.put("age", 6); // 发送 POST 请求带参数 String result = HttpUtil.post(url, paramMap); System.out.println("POST request result from " + url + ":"); System.out.println(result); }}
``HttpUtil.post()` 可以直接传入 Map 作为请求参数，Hutool 会自动处理表单提交。 -
更复杂的请求 (链式调用)： 对于需要设置请求头、超时时间、代理等更复杂的场景，可以使用
HttpRequest对象进行链式调用。“`java
import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpUtil;
import java.util.HashMap;
import java.util.Map;public class HttpUtilExample3 {
public static void main(String[] args) {
String url = “https://httpbin.org/get”; // 测试 GET 请求的网站
Map
paramMap.put(“param1”, “value1”);
paramMap.put(“param2”, “value2”);String result = HttpRequest.get(url) .header("User-Agent", "Hutool HTTP Client") // 设置请求头 .form(paramMap) // 设置请求参数 (GET请求参数会拼接到URL后) .timeout(2000) // 设置超时时间，单位毫秒 .execute() // 执行请求 .body(); // 获取响应体 System.out.println("Complex GET request result:"); System.out.println(result); }}
``HttpRequest对象支持设置各种属性，如header(),cookie(),body(),timeout(),setProxy()` 等，功能非常强大且易用。
8. 安全工具 – SecureUtil (hutool-crypto)
hutool-crypto 模块提供了常见的加密、解密、哈希等安全相关工具。
-
MD5 哈希：
“`java
import cn.hutool.crypto.SecureUtil;public class SecureUtilExample {
public static void main(String[] args) {
String content = “Hello, Hutool SecureUtil!”;// 计算 MD5 值 String md5 = SecureUtil.md5(content); System.out.println("MD5 of '" + content + "': " + md5); // 例如: e5e18411a072870b8c7150d8c8b84995 }}
“` -
Base64 编解码：
“`java
import cn.hutool.core.codec.Base64;
import cn.hutool.core.util.CharsetUtil;public class SecureUtilExample2 {
public static void main(String[] args) {
String content = “This is a Base64 test.”;// Base64 编码 String encoded = Base64.encode(content, CharsetUtil.UTF_8); System.out.println("Base64 Encoded: " + encoded); // VGhpcyBpcyBhIEJhc2U2NCB0ZXN0Lg== // Base64 解码 String decoded = Base64.decodeStr(encoded, CharsetUtil.UTF_8); System.out.println("Base64 Decoded: " + decoded); // This is a Base64 test. }}
``hutool-core
注意：Base64 的编解码方法在模块的cn.hutool.core.codec.Base64类中。SecureUtil` 主要提供哈希、对称加密、非对称加密等功能。
SecureUtil 还支持 SHA1、SHA256 等哈希算法，以及 AES、RSA 等对称/非对称加密算法，使用方式也都非常简洁。
9. ID 生成器 – IdUtil (hutool-core)
生成唯一标识符是很多应用的需求，如订单号、用户ID等。IdUtil 提供了 UUID 和雪花算法 (Snowflake) ID 生成器。
-
生成 UUID：
“`java
import cn.hutool.core.util.IdUtil;public class IdUtilExample {
public static void main(String[] args) {
// 生成一个不带分隔符的 UUID
String simpleUUID = IdUtil.simpleUUID();
System.out.println(“Simple UUID: ” + simpleUUID); // 例如: 8e3b4f0e3c6d4e7b8f9a0123456789ab// 生成一个标准的 UUID (带分隔符) String fastUUID = IdUtil.fastUUID(); System.out.println("Fast UUID: " + fastUUID); // 例如: 8e3b4f0e-3c6d-4e7b-8f9a-0123456789ab }}
“` -
生成雪花算法 ID (Snowflake)： 雪花算法生成的 ID 是一个长整型数字，具有时间顺序性，适用于分布式系统。
“`java
import cn.hutool.core.util.IdUtil;public class IdUtilExample2 {
public static void main(String[] args) {
// 默认创建 SnowFlake 对象，使用默认的工作机器ID和数据中心ID
// 在分布式环境中，你需要为每个节点配置不同的工作机器ID和数据中心ID
// 例如：IdUtil.createSnowflake(workerId, datacenterId);
long id1 = IdUtil.getSnowflakeNextId();
long id2 = IdUtil.getSnowflakeNextId();System.out.println("Snowflake ID 1: " + id1); // 例如: 1719308248169922560 System.out.println("Snowflake ID 2: " + id2); // 例如: 1719308248169922561 (通常会递增) }}
``workerId
在生产环境中，使用雪花算法需要合理配置和datacenterId`，以确保全局唯一性。Hutool 提供了创建 SnowFlake 实例的方法。
10. 反射工具 – ReflectUtil (hutool-core)
Java 反射 API 功能强大，但使用起来比较麻烦，需要处理各种异常。ReflectUtil 提供了简化的反射操作。
-
调用方法：
“`java
import cn.hutool.core.util.ReflectUtil;public class ReflectUtilExample {
public static class MyService { public String sayHello(String name) { return "Hello, " + name + "!"; } private void privateMethod() { System.out.println("This is a private method."); } } public static void main(String[] args) { MyService service = new MyService(); // 调用 public 方法 Object result = ReflectUtil.invoke(service, "sayHello", "World"); System.out.println("Invoke public method result: " + result); // Hello, World! // 调用 private 方法 ReflectUtil.invoke(service, "privateMethod"); // 私有方法也能直接调用，无需设置 accessible(true) }}
``ReflectUtil.invoke()方法可以方便地调用对象的指定方法，甚至可以调用私有方法，无需手动设置setAccessible(true)`。 -
获取/设置字段值：
“`java
import cn.hutool.core.util.ReflectUtil;public class ReflectUtilExample2 {
public static class MyObject { private String privateField = "initial value"; public String getPrivateField() { return privateField; } } public static void main(String[] args) { MyObject obj = new MyObject(); // 获取私有字段的值 Object value = ReflectUtil.getFieldValue(obj, "privateField"); System.out.println("Initial private field value: " + value); // initial value // 设置私有字段的值 ReflectUtil.setFieldValue(obj, "privateField", "new value"); System.out.println("New private field value: " + obj.getPrivateField()); // new value }}
``ReflectUtil.getFieldValue()和ReflectUtil.setFieldValue()` 简化了访问私有字段的操作。
ReflectUtil 还提供了获取类所有方法/字段、获取父类/接口等功能。
探索更多 Hutool 功能
上面介绍的只是 Hutool 中最常用的一些模块和功能。Hutool 还有一个庞大的工具集，包括：
- 类型转换 (
Convert)： 各种类型之间的相互转换，如字符串转数字、日期、集合等。 - 验证码生成 (
CaptchaUtil)： 方便地生成图形验证码。 - 二维码生成 (
QrCodeUtil)： 生成二维码图片。 - Excel 操作 (
ExcelUtil)： 读取和写入 Excel 文件。 - FTP 工具 (
Ftp)： FTP 客户端操作。 - 定时任务 (
CronUtil)： 基于 Quartz 的轻量级定时任务。 - AOP 工具 (
AopUtil)： 简单的面向切面编程实现。 - 线程池工具 (
ThreadUtil)： 简化的线程池创建和使用。 - 资源工具 (
ResourceUtil)： 读取类路径或文件系统中的资源。 - …等等
要想深入了解 Hutool 的全部功能，最好的方式是查阅 Hutool 官方文档 和 Hutool Javadoc。官方文档非常详细，提供了每个工具类的使用说明和示例。
使用 Hutool 的最佳实践
虽然 Hutool 功能强大且易用，但如同任何工具一样，合理地使用才能发挥其最大价值：
- 按需引入模块： 如果你对项目体积有要求，尽量只引入你需要的模块，而不是
hutool-all。 - 优先使用 Hutool 的方法： 对于 Hutool 已经封装好的常用操作（如判空、字符串截取、日期格式化等），优先使用 Hutool 提供的方法，因为它们通常更简洁，并且考虑了一些边界情况。
- 查阅文档和 Javadoc： 遇到不清楚的用法或想知道某个工具类有哪些功能时，及时查阅官方文档和 Javadoc 是最有效的方法。
- 注意版本兼容性： 在升级 Hutool 版本时，关注版本的更新日志，了解是否有 API 的变更。
- 不要过度依赖： Hutool 是一个工具库，旨在简化开发，但不是银弹。对于复杂的业务逻辑，仍然需要自己精心设计和实现。不要为了使用 Hutool 而将简单的原生 Java 代码复杂化。
总结
Hutool 作为一个全面而简洁的 Java 工具库，极大地提升了开发效率，减少了重复代码，让 Java 开发变得更加愉悦。本文详细介绍了 Hutool 的核心理念、如何在项目中使用它，并着重演示了 StrUtil, DateUtil, FileUtil, CollUtil/ListUtil/MapUtil, BeanUtil, JSONUtil, HttpUtil, SecureUtil, IdUtil, ReflectUtil 等常用模块的功能和用法。
通过掌握 Hutool，你可以在日常开发中更加得心应手，用更少的代码完成更多的功能。它就像一个装满了各种趁手工具的工具箱，随时准备帮助你解决问题。
现在，你已经具备了 Hutool 的入门知识。最好的学习方式是动手实践，尝试在你的项目中引入 Hutool，并将其应用到实际开发中。随着使用经验的积累，你会越来越体会到这个“Java开发利器”的强大魅力。
希望这篇入门指南对你有所帮助！开始你的 Hutool 之旅吧！