Hutool工具包的常用工具类的使用介绍

前言

Hutool 是一个轻量级的 Java 工具类库，提供了非常丰富的工具方法，可以大大减少开发时的重复性工作。它的目标是让 Java 开发更简单、更高效。Hutool 提供了多种常用功能，以下是一些常用工具类的使用介绍：

1. StrUtil - 字符串工具类

StrUtil 提供了大量的字符串处理方法，如字符串的空值判断、去除空格、字符串拼接等。

import cn.hutool.core.util.StrUtil;

public class StrUtilExample {
    public static void main(String[] args) {
        String str = "  Hello Hutool  ";
        
        // 去除两端空白
        String trimmed = StrUtil.trim(str);
        System.out.println(trimmed);  // "Hello Hutool"
        
        // 判断字符串是否为空
        boolean isEmpty = StrUtil.isEmpty(str);
        System.out.println(isEmpty);  // false
        
        // 判断字符串是否为空或只包含空格
        boolean isBlank = StrUtil.isBlank(str);
        System.out.println(isBlank);  // false
        
        // 拼接字符串
        String joined = StrUtil.join("-", "a", "b", "c");
        System.out.println(joined);  // "a-b-c"
    }
}

常用方法：

• trim(String str)：去掉字符串前后的空白字符。
• isEmpty(String str)：判断字符串是否为空（不包括空白字符）。
• isBlank(String str)：判断字符串是否为空或仅包含空白字符。
• join(String separator, Object... elements)：将多个字符串用指定分隔符连接。

2. CollUtil - 集合工具类

CollUtil 提供了集合相关的常用操作，如集合是否为空、集合合并、集合去重等。

import cn.hutool.core.collection.CollUtil;
import java.util.List;

public class CollUtilExample {
    public static void main(String[] args) {
        List<String> list1 = CollUtil.newArrayList("a", "b", "c");
        List<String> list2 = CollUtil.newArrayList("d", "e");
        
        // 合并集合
        List<String> combined = CollUtil.union(list1, list2);
        System.out.println(combined);  // ["a", "b", "c", "d", "e"]
        
        // 去重集合
        List<String> listWithDuplicates = CollUtil.newArrayList("a", "b", "a", "c");
        List<String> uniqueList = CollUtil.removeDuplicate(listWithDuplicates);
        System.out.println(uniqueList);  // ["a", "b", "c"]
        
        // 判断集合是否为空
        boolean isEmpty = CollUtil.isEmpty(list1);
        System.out.println(isEmpty);  // false
    }
}

常用方法：

• union(Collection<T> coll1, Collection<T> coll2)：合并两个集合。
• removeDuplicate(List<T> list)：去重列表中的重复元素。
• isEmpty(Collection<T> coll)：判断集合是否为空。

3. DateUtil - 日期工具类

DateUtil 是处理日期和时间的一个非常强大的工具类，支持各种日期格式的转换、计算、比较等操作。

import cn.hutool.core.date.DateUtil;
import java.util.Date;

public class DateUtilExample {
    public static void main(String[] args) {
        // 获取当前日期
        Date now = DateUtil.date();
        System.out.println(now);  // 输出当前日期
        
        // 格式化日期
        String formattedDate = DateUtil.format(now, "yyyy-MM-dd HH:mm:ss");
        System.out.println(formattedDate);  // 输出格式化后的日期
        
        // 解析日期字符串
        Date parsedDate = DateUtil.parse("2024-12-20 10:00:00", "yyyy-MM-dd HH:mm:ss");
        System.out.println(parsedDate);  // 输出解析后的日期
        
        // 获取当前时间戳
        long timestamp = DateUtil.current();
        System.out.println(timestamp);  // 输出当前时间戳
    }
}

常用方法：

• date()：获取当前日期。
• format(Date date, String pattern)：格式化日期。
• parse(String dateStr, String pattern)：解析日期字符串。
• current()：获取当前时间戳。

4. FileUtil - 文件工具类

FileUtil 提供了大量的文件操作方法，包括读取文件、写入文件、文件夹操作等。

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("文件创建成功：" + file.exists());
        
        // 写入内容
        FileUtil.writeUtf8String("Hello Hutool", file);
        
        // 读取文件内容
        String content = FileUtil.readUtf8String(file);
        System.out.println(content);  // 输出：Hello Hutool
        
        // 删除文件
        FileUtil.del(file);
        System.out.println("文件已删除：" + !file.exists());
    }
}

常用方法：

• touch(String path)：创建一个文件，如果文件存在，则不做任何操作。
• writeUtf8String(String content, File file)：以 UTF-8 编码向文件写入字符串。
• readUtf8String(File file)：读取文件的 UTF-8 编码内容。
• del(File file)：删除文件或目录。

5. BeanUtil - Bean 操作工具类

BeanUtil 提供了对 Java Bean 的操作方法，支持对象属性的复制、转化等。

import cn.hutool.core.bean.BeanUtil;

import java.util.HashMap;
import java.util.Map;

public class BeanUtilExample {
    public static void main(String[] args) {
        // 将 Map 转换为 Bean 对象
        Map<String, Object> map = new HashMap<>();
        map.put("name", "John");
        map.put("age", 25);
        
        Person person = BeanUtil.mapToBean(map, Person.class, false);
        System.out.println(person);  // Person{name='John', age=25}
        
        // 将 Bean 对象转换为 Map
        Map<String, Object> convertedMap = BeanUtil.beanToMap(person);
        System.out.println(convertedMap);  // {name=John, age=25}


 // 创建 User 对象
        User user = new User("Alice", 30);

        // 创建 UserDTO 对象
        UserDTO userDTO = new UserDTO();

        // 使用 BeanUtil 进行属性拷贝
        BeanUtil.copyProperties(user, userDTO);

        // 输出拷贝后的 UserDTO 对象
        System.out.println(userDTO);  // 输出: UserDTO{name='Alice', age=30}
    }

    static class Person {
        private String name;
        private int age;

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        @Override
        public String toString() {
            return "Person{name='" + name + "', age=" + age + '}';
        }
    }
}

常用方法：

• mapToBean(Map<String, Object> map, Class<T> beanClass, boolean ignoreError)：将 Map 转换为 Bean 对象。
• beanToMap(Object bean)：将 Bean 转换为 Map。
• BeanUtil.copyProperties(brand, copyBrand):属性拷贝

6. RandomUtil - 随机数工具类

RandomUtil 提供了生成随机数、随机字符、随机字符串等的工具方法。

import cn.hutool.core.util.RandomUtil;

public class RandomUtilExample {
    public static void main(String[] args) {
        // 生成随机整数
        int randomInt = RandomUtil.randomInt();
        System.out.println(randomInt);
        
        // 生成指定范围的随机整数
        int randomIntInRange = RandomUtil.randomInt(1, 100);
        System.out.println(randomIntInRange);
        
        // 生成随机字符串
        String randomStr = RandomUtil.randomString(10);
        System.out.println(randomStr);
    }
}

常用方法：

• randomInt()：生成一个随机整数。
• randomInt(int start, int end)：生成指定范围内的随机整数。
• randomString(int length)：生成指定长度的随机字符串。

7. MapUtil - Map操作工具类

1. 判断 Map 是否为空

import cn.hutool.core.collection.MapUtil;
import java.util.Map;
import java.util.HashMap;

public class MapUtilExample {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        
        // 判断 Map 是否为空
        System.out.println(MapUtil.isEmpty(map));  // true
        System.out.println(MapUtil.isNotEmpty(map));  // false
        
        // 添加元素
        map.put("key", "value");
        
        System.out.println(MapUtil.isEmpty(map));  // false
        System.out.println(MapUtil.isNotEmpty(map));  // true
    }
}

2.创建一个空的 Map 或新建一个 HashMap

import cn.hutool.core.collection.MapUtil;

public class MapUtilExample {
    public static void main(String[] args) {
        // 创建一个空的 HashMap
        Map<String, String> emptyMap = MapUtil.newHashMap();
        System.out.println(emptyMap);  // 输出: {}
        
        // 创建一个带初始值的 HashMap
        Map<String, String> mapWithValues = MapUtil.newHashMap(3);
        mapWithValues.put("key1", "value1");
        mapWithValues.put("key2", "value2");
        System.out.println(mapWithValues);  // 输出: {key1=value1, key2=value2}
    }
}

3. 获取 Map 中的值，支持默认值

import cn.hutool.core.collection.MapUtil;

import java.util.Map;
import java.util.HashMap;

public class MapUtilExample {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("key1", "value1");

        // 获取 Map 中的值，存在则返回，否则返回默认值
        String value = MapUtil.get(map, "key1", "defaultValue");
        System.out.println(value);  // 输出: value1
        
        // 获取一个不存在的键，返回默认值
        String defaultValue = MapUtil.get(map, "key2", "defaultValue");
        System.out.println(defaultValue);  // 输出: defaultValue
    }
}

4. 合并多个 Map

import cn.hutool.core.collection.MapUtil;
import java.util.Map;
import java.util.HashMap;

public class MapUtilExample {
    public static void main(String[] args) {
        Map<String, String> map1 = new HashMap<>();
        map1.put("key1", "value1");
        
        Map<String, String> map2 = new HashMap<>();
        map2.put("key2", "value2");

        // 合并两个 Map
        Map<String, String> mergedMap = MapUtil.merge(map1, map2);
        System.out.println(mergedMap);  // 输出: {key1=value1, key2=value2}
    }
}

总结

上述是一些常用的工具类，Hutool是一个小而全的Java工具类库，上述只是列举了部分，涉及到其他的使用方法可以参考官方api文档进行查询。

官网地址：

Hutool🍬一个功能丰富且易用的Java工具库，涵盖了字符串、数字、集合、编码、日期、文件、IO、加密、数据库JDBC、JSON、HTTP客户端等功能。