工具类库（hutool） Java程序员必备

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.11</version>
        </dependency>

三、 hutool 工具类库-常用

最常用的工具类

BeanUtil ：

        // 创建一个 Map，其中包含要填充到 User 对象的属性值
        Map<String, Object> map = new HashMap<>();
        map.put("username", "张三");
        map.put("age", 18);

        // 创建一个 User 对象
        User user = new User();

        // 使用 BeanUtil.fillBeanWithMap 方法填充 User 对象的属性
        BeanUtil.fillBeanWithMap(map,user,true);
        System.out.println(user);

        //使用 BeanUtil.beanToMap 方法将 User 对象转换为 Map
        Map<String,Object> newUser = BeanUtil.beanToMap(user);
        System.out.println(newUser);

        // 使用BeanUtil.copyProperties方法将 User 对象复制到另一个 User 对象
        User user2 = new User();
        BeanUtil.copyProperties(user, user2);
        System.out.println(user2);

核心工具类

Convert：类型转换工具类

示例代码：

        // 将字符串转换为整数
        int intVal = Convert.toInt("12345");
        System.out.println("字符串 '12345' 转换为整数: " + intVal); // 预期输出: 字符串 '12345' 转换为整数: 12345

        // 将字符串转换为长整型
        long longVal = Convert.toLong("123456789012345");
        System.out.println("字符串 '123456789012345' 转换为长整型: " + longVal); // 预期输出: 字符串 '123456789012345' 转换为长整型: 123456789012345

        // 将字符串转换为浮点数
        double doubleVal = Convert.toDouble("123.456");
        System.out.println("字符串 '123.456' 转换为浮点数: " + doubleVal); // 预期输出: 字符串 '123.456' 转换为浮点数: 123.456

        // 将字符串转换为布尔值
        boolean boolVal = Convert.toBool("true");
        System.out.println("字符串 'true' 转换为布尔值: " + boolVal); // 预期输出: 字符串 'true' 转换为布尔值: true

        // 将数组转换为集合
        String[] strArray = {"a", "b", "c"};
        List<String> strList = Convert.toList(String.class, strArray);
        System.out.println("数组转换为集合: " + strList); // 预期输出: 数组转换为集合: [a, b, c]
        
        // 将集合转换为数组
        String[] arrayFromList = Convert.toStrArray(strList);
        System.out.println("集合转换为数组: " + Arrays.toString(arrayFromList)); // 预期输出: 集合转换为数组: [a, b, c]

DateUtil：日期时间工具类

        // 获取当前时间
        System.out.println("当前时间：" + DateUtil.now()); // 输出当前时间字符串

        // 解析日期时间字符串
        String dateStr = "2024-08-04 12:30:45";
        System.out.println("解析日期时间字符串：" + DateUtil.parse(dateStr)); // 输出解析后的日期时间

        // 格式化日期时间
        System.out.println("格式化当前时间：" + DateUtil.format(DateUtil.date(), "yyyy-MM-dd HH:mm:ss")); // 按指定格式输出当前时间

        // 计算日期时间差
        String startDateStr = "2024-08-01 00:00:00";
        String endDateStr = "2024-08-04 12:30:45";
        long betweenDay = DateUtil.between(DateUtil.parse(startDateStr), DateUtil.parse(endDateStr), DateUnit.DAY);
        System.out.println("两个日期之间的天数差：" + betweenDay); // 输出两个日期之间的天数差

        // 日期时间偏移
        System.out.println("当前时间加一天：" + DateUtil.offsetDay(DateUtil.date(), 1)); // 输出当前时间加一天后的日期

        // 获取月份的第一天和最后一天
        System.out.println("当前月份的第一天：" + DateUtil.beginOfMonth(DateUtil.date())); // 输出当前月份的第一天
        System.out.println("当前月份的最后一天：" + DateUtil.endOfMonth(DateUtil.date())); // 输出当前月份的最后一天

StrUtil：字符串工具类

        // 检查字符串是否为空
        boolean isEmpty = StrUtil.isEmpty("  "); // 空格字符串
        System.out.println("字符串是否为空（包括空格）：" + isEmpty); // 预期输出：true

        // 检查字符串是否为空白
        boolean isBlank = StrUtil.isBlank("  "); // 空格字符串
        System.out.println("字符串是否为空白：" + isBlank); // 预期输出：true

        // 去除字符串两端的空格
        String trimmedStr = StrUtil.trim("  Hello Hutool!  ");
        System.out.println("去除两端空格后的字符串：" + trimmedStr); // 预期输出：Hello Hutool!

        // 拼接字符串;
        String joinedStr = StrUtil.join(",", "a", "b", "c");
        System.out.println("拼接后的字符串：" + joinedStr); // 预期输出：a,b,c

        // 字符串长度
        int length = StrUtil.length("Hello Hutool!");
        System.out.println("字符串长度：" + length); // 预期输出：13

        // 首字母大写
        String capitalizedStr = StrUtil.upperFirst("hello hutool!");
        System.out.println("首字母大写后的字符串：" + capitalizedStr); // 预期输出：Hello hutool!

        // 首字母小写
        String uncapitalizedStr = StrUtil.lowerFirst("HELLO HUTOOL!");
        System.out.println("首字母小写后的字符串：" + uncapitalizedStr); // 预期输出：hELLO HUTOOL!

        // 判断字符串是否包含子串
        boolean contains = StrUtil.contains("Hello Hutool!", "Hutool");
        System.out.println("字符串是否包含子串 'Hutool'：" + contains); // 预期输出：true

        // 判断字符串是否以特定子串开头
        boolean startsWith = StrUtil.startWith("Hello Hutool!", "Hello");
        System.out.println("字符串是否以 'Hello' 开头：" + startsWith); // 预期输出：true

        // 判断字符串是否以特定子串结尾
        boolean endsWith = StrUtil.endWith("Hello Hutool!", "Hutool!");
        System.out.println("字符串是否以 'Hutool!' 结尾：" + endsWith); // 预期输出：true

NumberUtil：数字工具类

        // 字符串转数字
        String numStr = "123.456";
        double num = NumberUtil.parseDouble(numStr);
        System.out.println("字符串转double：" + num); // 预期输出：123.456

        // 数字格式化
        String formattedNum = NumberUtil.decimalFormat("0.00", num);
        System.out.println("格式化数字：" + formattedNum); // 预期输出：123.46

        // 数字四舍五入
        double roundedNum = NumberUtil.round(num, 2);
        System.out.println("四舍五入后的数字：" + roundedNum); // 预期输出：123.46

        // 计算百分比
        double percentage = NumberUtil.percent(50, 200);
        System.out.println("50是200的百分比：" + percentage + "%"); // 预期输出：25%

        // 判断是否为数字
        boolean isNumber = NumberUtil.isNumber("123.456");
        System.out.println("字符串 '123.456' 是否为数字：" + isNumber); // 预期输出：true

        // 判断是否为整数
        boolean isInteger = NumberUtil.isInteger("123");
        System.out.println("字符串 '123' 是否为整数：" + isInteger); // 预期输出：true

        // 判断是否为素数
        boolean isPrime = NumberUtil.isPrime(17);
        System.out.println("数字 17 是否为素数：" + isPrime); // 预期输出：true

        // 数字范围限定
        int limitedNum = NumberUtil.range(100, 0, 200);
        System.out.println("数字100限定在0到200之间：" + limitedNum); // 预期输出：100

        // 数字相加
        double sum = NumberUtil.add(10.5, 20.3);
        System.out.println("10.5和20.3的和：" + sum); // 预期输出：30.8

        // 数字相减
        double subtract = NumberUtil.sub(20.3, 10.5);
        System.out.println("20.3减去10.5的结果：" + subtract); // 预期输出：9.8

CollUtil：集合工具类

        // 字符串转数字
        String numStr = "123.456";
        double num = NumberUtil.parseDouble(numStr);
        System.out.println("字符串转double：" + num); // 预期输出：123.456

        // 数字格式化
        String formattedNum = NumberUtil.decimalFormat("0.00", num);
        System.out.println("格式化数字：" + formattedNum); // 预期输出：123.46

        // 数字四舍五入
        BigDecimal roundedNum = NumberUtil.round(num, 2);
        System.out.println("四舍五入后的数字：" + roundedNum); // 预期输出：123.46


        // 判断是否为数字
        boolean isNumber = NumberUtil.isNumber("123.456");
        System.out.println("字符串 '123.456' 是否为数字：" + isNumber); // 预期输出：true

        // 判断是否为整数
        boolean isInteger = NumberUtil.isInteger("123");
        System.out.println("字符串 '123' 是否为整数：" + isInteger); // 预期输出：true

        // 判断是否为素数
        boolean isPrime = NumberUtil.isPrimes(17);
        System.out.println("数字 17 是否为素数：" + isPrime); // 预期输出：true

        // 数字范围限定
        int[] limitedNum = NumberUtil.range(0, 200, 80);
        System.out.println("数字80限定在0到200之间：" + Arrays.toString(limitedNum)); // 预期输出：[0, 80, 160]

        // 数字相加
        double sum = NumberUtil.add(10.5, 20.3);
        System.out.println("10.5和20.3的和：" + sum); // 预期输出：30.8

        // 数字相减
        double subtract = NumberUtil.sub(20.3, 10.5);
        System.out.println("20.3减去10.5的结果：" + subtract); // 预期输出：9.8

ArrayUtil：数组工具类

        // 创建一个数组
        int[] intArray = {1, 2, 3, 4, 5};

        // 获取数组长度
        int length = ArrayUtil.length(intArray);
        System.out.println("数组长度：" + length); // 预期输出：5

        // 获取数组第一个元素
        int firstElement = ArrayUtil.get(intArray, 0);
        System.out.println("数组第一个元素：" + firstElement); // 预期输出：1

        // 获取数组最后一个元素
        int lastElement = ArrayUtil.get(intArray, length - 1);
        System.out.println("数组最后一个元素：" + lastElement); // 预期输出：5

        // 检查数组是否包含某个元素
        boolean contains = ArrayUtil.contains(intArray, 3);
        System.out.println("数组是否包含元素 3：" + contains); // 预期输出：true

        ArrayUtil.isSorted(intArray);
        System.out.println("排序后的数组：" + Arrays.toString(intArray)); // 预期输出：[1, 2, 3, 4, 5]

        // 数组反转
        int[] reversedArray = ArrayUtil.reverse(intArray);
        System.out.println("反转后的数组：" + Arrays.toString(reversedArray)); // 预期输出：[5, 4, 3, 2, 1]

MapUtil：Map工具类

        // 创建一个 Map
        Map<String, Object> map = MapUtil.createMap(HashMap.class);

        // 向 Map 中添加元素
        map.put("key1", "value1");
        map.put("key2", "value2");
        map.put("key3", "value3");
        
        // 获取 Map 中的元素
        Object value1 = map.get("key1");
        System.out.println("获取元素 value1：" + value1); // 预期输出：value1

        // 检查 Map 是否包含某个键
        boolean containsKey = map.containsKey("key2");
        System.out.println("Map 是否包含键 key2：" + containsKey); // 预期输出：true

        // 检查 Map 是否包含某个值
        boolean containsValue = map.containsValue("value2");
        System.out.println("Map 是否包含值 value2：" + containsValue); // 预期输出：true

        // 删除 Map 中的元素
        map.remove("key1");
        
        // 清空 Map
        map.clear();
        
        // 检查 Map 是否为空
        boolean isEmpty = MapUtil.isEmpty(map);
        System.out.println("Map 是否为空：" + isEmpty); // 预期输出：true

ClassUtil：类工具类

        // 获取 Class 对象
        Class<?> clazz = ClassUtil.getClass(String.class);
        System.out.println("获取 Class 对象：" + clazz); // 预期输出：class java.lang.String

        // 获取 Class 对象的字符串表示
        String className = ClassUtil.getClassName(String.class,true);
        System.out.println("获取 Class 对象的字符串表示：" + className); // 预期输出：String

        // 获取 Class 对象的类名
        String simpleName = ClassUtil.getClassName(String.class,true);
        System.out.println("获取 Class 对象的类名：" + simpleName); // 预期输出：String

        // 获取 Class 对象的包名
        String packageName = com.fasterxml.jackson.databind.util.ClassUtil.getPackageName(String.class);
        System.out.println("获取 Class 对象的包名：" + packageName); // 预期输出：java.lang

ReflectUtil：反射工具类

        // 获取 User 类的字段
        Field[] fieldNames = ReflectUtil.getFields(User.class);
        System.out.println("获取 User 类的字段名：" + Arrays.toString(fieldNames));

        // 获取方法信息
        Method[] methods = ReflectUtil.getMethods(User.class);
        System.out.println("获取 User 类的方法信息：" + Arrays.toString(methods));

        // 获取构造方法信息
        Constructor<?>[] constructors = ReflectUtil.getConstructors(User.class);
        System.out.println("获取 User 类的构造方法信息：" + Arrays.toString(constructors));

加密解密

SecureUtil：安全相关工具类，提供MD5、SHA、AES等算法

        // 使用 MD5 算法进行加密
        String md5 = SecureUtil.md5("password");
        System.out.println("MD5 加密结果：" + md5);

        // 使用 SHA 算法进行加密
        String sha1 = SecureUtil.sha1("password");
        System.out.println("SHA1 加密结果：" + sha1);

        // 使用 SHA-256 算法进行加密
        String sha256 = SecureUtil.sha256("password");
        System.out.println("SHA-256 加密结果：" + sha256);

DigestUtil：摘要算法工具类

        // 使用 MD5 算法进行摘要
        String md5 = DigestUtil.md5Hex("password");
        System.out.println("MD5 摘要结果：" + md5);

        // 使用 SHA-1 算法进行摘要
        String sha1 = DigestUtil.sha1Hex("password");
        System.out.println("SHA-1 摘要结果：" + sha1);

JSON

JSONUtil：JSON解析和生成工具类

        // 创建一个 JSONObject 对象
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("name", "张三");
        jsonObject.put("age", 25);
        jsonObject.put("email", "zhangsan@example.com");

        // 将 JSONObject 对象转换为 JSON 字符串
        String jsonStr = JSONUtil.toJsonStr(jsonObject);
        System.out.println("JSON 字符串：" + jsonStr);

        // 将 JSON 字符串转换为 JSONObject 对象
        JSONObject parsedJson = JSONUtil.parseObj(jsonStr);
        System.out.println("解析后的 JSONObject：" + parsedJson);

        // 将 JSON 字符串转换为 Java 对象
        User user = JSONUtil.toBean(jsonStr, User.class);
        System.out.println("解析后的 Java 对象：" + user);