Hutool工具类使用，仅作记录_hutool runtimeutil-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_55627541/article/details/128552193

该文章展示了Java编程中一些实用的工具类方法，包括数组与集合转换、日期处理、字符串操作、IO操作、反射以及JSON转换等，旨在提高开发效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

 public static void main(String[] args) throws ZipException {
        long[] b = {1,2,3,4,5,6};
        System.out.println(Convert.toList(b));

        String[] c = {"1","2","3"};
        System.out.println(Convert.toIntArray(c));//[Ljava.lang.Integer;@3abfe836

        long[] d = {1,2,3,4,5};
        Integer[] intArray2 = Convert.toIntArray(d);
        System.out.println(intArray2);

         转换为日期对象：
        String a = "2017-05-06";
        System.out.println(Convert.toDate(a));

         转换为集合
        Object[] a = {"a", "你", "好", "", 1};
        List<?> list = Convert.toList(a);
        System.out.println(list);

         半角转全角：
        String a = "123456789";
        String sbc = Convert.toSBC(a);
        System.out.println(sbc);

         Unicode和字符串转换
        String a = "我是一个小小的可爱的字符串";
//结果为："\\u6211\\u662f\\u4e00\\u4e2a\\u5c0f\\u5c0f\\u7684\\u53ef\\u7231\\u7684\\u5b57\\u7b26\\u4e32"
        String unicode = Convert.strToUnicode(a);
        System.out.println(unicode);
//结果为："我是一个小小的可爱的字符串"
        String raw = Convert.unicodeToStr(unicode);
        System.out.println(raw);

         毫秒数对应多少分
        long a = 4535345;
//结果为：75
        long minutes = Convert.convertTime(a, TimeUnit.MILLISECONDS, TimeUnit.MINUTES);
        System.out.println(minutes);

         金额大小写转换
        double a = 67556.32;
//结果为："陆万柒仟伍佰伍拾陆元叁角贰分"   转换为大写只能精确到分（小数点儿后两位），之后的数字会被忽略。
        String digitUppercase = Convert.digitToChinese(a);
        System.out.println(digitUppercase);

        数字转中文
 一万零八百八十九点七二  只保留两位小数
        String f1 = Convert.numberToChinese(10889.72356, false);
        System.out.println(f1);
// 使用金额大写
// 壹万贰仟陆佰伍拾叁
        String f2 = Convert.numberToChinese(12653, true);
        System.out.println(f2);

         通过月份枚举可以获得某个月的最后一天
        int lastDay = Month.of(Calendar.FEBRUARY).getLastDay(false);
        System.out.println(lastDay);

        当前时间 Date、long、Calendar之间的相互转换
        Date date = DateUtil.date();
        System.out.println(date);
//当前时间
        Date date2 = DateUtil.date(Calendar.getInstance());
        System.out.println(date2);

//当前时间
        Date date3 = DateUtil.date(System.currentTimeMillis());
        System.out.println(date3);
//当前时间字符串，格式：yyyy-MM-dd HH:mm:ss
        String now = DateUtil.now();
        System.out.println(now);

//当前日期字符串，格式：yyyy-MM-dd
        String today= DateUtil.today();
        System.out.println(today);

          字符串转日期
        String dateStr = "2017-03-01";
        Date date = DateUtil.parse(dateStr);
        System.out.println(date);

         自定义日期转化
        String dateStr = "2017-03-01";
        Date date = DateUtil.parse(dateStr, "yyyy-MM-dd");
        System.out.println(date);

         格式化日期输出
        String dateStr = "2017-03-01";
        Date date = DateUtil.parse(dateStr);

//结果 2017/03/01
        String format = DateUtil.format(date, "yyyy/MM/dd");

//常用格式的格式化，结果：2017-03-01
        String formatDate = DateUtil.formatDate(date);

//结果：2017-03-01 00:00:00
        String formatDateTime = DateUtil.formatDateTime(date);

//结果：00:00:00
        String formatTime = DateUtil.formatTime(date);

         获取Date对象的某个部分
        Date date = DateUtil.date();
//获得年的部分
        System.out.println(DateUtil.year(date));
//获得月份，从0开始计数
        System.out.println(DateUtil.month(date));
//获得月份枚举
        System.out.println(DateUtil.monthEnum(date));

         一天的开始和结束时间
        String dateStr = "2017-03-01 22:33:23";
        Date date = DateUtil.parse(dateStr);

//一天的开始，结果：2017-03-01 00:00:00
        Date beginOfDay = DateUtil.beginOfDay(date);
        System.out.println(beginOfDay);
//一天的结束，结果：2017-03-01 23:59:59
        Date endOfDay = DateUtil.endOfDay(date);
        System.out.println(endOfDay);

         日期时间偏移
        String dateStr = "2017-03-01 22:33:23";
        Date date = DateUtil.parse(dateStr);

//结果：2017-03-03 22:33:23
        Date newDate = DateUtil.offset(date, DateField.DAY_OF_MONTH, 2);

//常用偏移，结果：2017-03-04 22:33:23
        DateTime newDate2 = DateUtil.offsetDay(date, 3);

//常用偏移，结果：2017-03-01 19:33:23
        DateTime newDate3 = DateUtil.offsetHour(date, -3);
        //昨天
        DateUtil.yesterday();
//明天
        DateUtil.tomorrow();
//上周
        DateUtil.lastWeek();
//下周
        DateUtil.nextWeek();
//上个月
        DateUtil.lastMonth();
//下个月
        DateUtil.nextMonth();

         日期时间差
        String dateStr1 = "2017-03-01 22:33:23";
        Date date1 = DateUtil.parse(dateStr1);

        String dateStr2 = "2017-04-01 23:33:23";
        Date date2 = DateUtil.parse(dateStr2);

        long betweenDay = DateUtil.between(date1, date2, DateUnit.DAY);
        System.out.println(betweenDay);// 31

         LocalDateTime工具
         日期转换
        String dateStr = "2020-01-23T12:23:56";
        DateTime dt = DateUtil.parse(dateStr);
        System.out.println(dt);
// Date对象转换为LocalDateTime
        LocalDateTime of = LocalDateTimeUtil.of(dt);
        System.out.println(of);
// 时间戳转换为LocalDateTime
        System.out.println(dt.getTime());
        of = LocalDateTimeUtil.ofUTC(dt.getTime());
        System.out.println(of);
         日期字符串解析
        // 解析ISO时间
        LocalDateTime localDateTime = LocalDateTimeUtil.parse("2020-01-23T12:23:56");
        System.out.println(localDateTime);

// 解析自定义格式时间
        localDateTime = LocalDateTimeUtil.parse("2020-01-23", DatePattern.NORM_DATE_PATTERN);
        System.out.println(localDateTime);

         日期格式化
        LocalDateTime localDateTime = LocalDateTimeUtil.parse("2020-01-23T12:23:56");
        System.out.println(localDateTime);
// "2020-01-23 12:23:56"
        String format = LocalDateTimeUtil.format(localDateTime, DatePattern.NORM_DATETIME_PATTERN);
        System.out.println(format);

         计算时间间隔
        LocalDateTime start = LocalDateTimeUtil.parse("2019-02-02T00:00:00");
        LocalDateTime end = LocalDateTimeUtil.parse("2020-02-02T00:00:00");

        Duration between = LocalDateTimeUtil.between(start, end);

// 365
        System.out.println(between.toDays());

        IOUtil工具类

         文件拷贝
        BufferedInputStream in = FileUtil.getInputStream("d:/test.txt");
        BufferedOutputStream out = FileUtil.getOutputStream("d:/a.txt");
        System.out.println(IoUtil.copy(in, out, IoUtil.DEFAULT_BUFFER_SIZE));

         FileUtil使用

         列出目录和文件
        File[] ls = FileUtil.ls("D:/");
        for (File l : ls) {
            System.out.println(l);
        }

         创建文件，如果父目录不存在也自动创建
        File touch = FileUtil.touch("d:/aaaa.txt");
        FileUtil.del(touch);
        System.out.println(touch);

         读取文件类型
        File file = FileUtil.file("d:/test.txt");
        String type = FileTypeUtil.getType(file);
        Console.log(type);

         监听一个文件的变化或者目录的变动
        File file = FileUtil.file("d:/test.txt");
//这里只监听文件或目录的修改事件
        WatchMonitor watchMonitor = WatchMonitor.create(file, WatchMonitor.ENTRY_MODIFY);
        watchMonitor.setWatcher(new Watcher(){
            @Override
            public void onCreate(WatchEvent<?> event, Path currentPath) {
                Object obj = event.context();
                Console.log("创建：{}-> {}", currentPath, obj);
            }

            @Override
            public void onModify(WatchEvent<?> event, Path currentPath) {
                Object obj = event.context();
                Console.log("修改：{}-> {}", currentPath, obj);
            }

            @Override
            public void onDelete(WatchEvent<?> event, Path currentPath) {
                Object obj = event.context();
                Console.log("删除：{}-> {}", currentPath, obj);
            }

            @Override
            public void onOverflow(WatchEvent<?> event, Path currentPath) {
                Object obj = event.context();
                Console.log("Overflow：{}-> {}", currentPath, obj);
            }
        });

//设置监听目录的最大深入，目录层级大于制定层级的变更将不被监听，默认只监听当前层级目录
        watchMonitor.setMaxDepth(3);
//启动监听
        watchMonitor.start();

         监听全部事件
        File file = FileUtil.file("d:/test.txt");
        WatchMonitor.createAll(file, new SimpleWatcher(){
            @Override
            public void onModify(WatchEvent<?> event, Path currentPath) {
                Console.log("EVENT modify");
            }
        }).start();

         文件读取
        FileReader fileReader = new FileReader("test.properties");
        String result = fileReader.readString();
        System.out.println(result);

         文件写入
        FileWriter writer = new FileWriter("d:/test.txt");
        writer.write("22222111",true);// 第二个参数是否追加

         监控文件变化
        Tailer tailer = new Tailer(FileUtil.file("d:/test.txt"), Tailer.CONSOLE_HANDLER, 2);
        tailer.start();
         StrUtil
         format方法
        String a = "{}爱{},就像风走了八千里不问归期";
        System.out.println(StrUtil.format(a, "我", "你"));
         去掉后缀
        String fileName = StrUtil.removeSuffix("pretty_girl.jpg", ".jpg"); //fileName -> pretty_girl
        System.out.println(fileName);

         ReflectUtil反射工具类
         获取类所有方法
        Method[] methods = ReflectUtil.getMethods(YoloController.class);
        for (Method method : methods) {
            System.out.println(method);
        }
         获取某个类的指定方法
        System.out.println(ReflectUtil.getMethod(Yolo.class, "getId"));

         命令行工具-RuntimeUtil
        String str = RuntimeUtil.execForStr("ipconfig");
        System.out.println(str);

         压缩工具

        将aaa目录下的所有文件目录打包到d:/aaa.zip
        ZipUtil.zip("d:/aaa");

        将aaa目录下的所有文件目录打包到d:/目录下的zsp.zip文件中
        ZipUtil.zip("d:/aaa","d:/zsp.zip");

        多文件压缩
        ZipUtil.zip(FileUtil.file("d:/suoyou.zip"), false,
                FileUtil.file("d:/test.txt"),
                FileUtil.file("d:/a.txt")
        );

        将suoyou.zip解压到e:\\aaa目录下，返回解压到的目录
        File unzip = ZipUtil.unzip("d:\\suoyou.zip", "d:\\aaa", CharsetUtil.CHARSET_GBK);
        System.out.println(unzip);

         压缩并添加密码 使用zip4j,需要增加zip4j依赖
        ZipParameters zipParameters = new ZipParameters();
        zipParameters.setEncryptFiles(true);
        zipParameters.setEncryptionMethod(EncryptionMethod.AES);
        zipParameters.setAesKeyStrength(AesKeyStrength.KEY_STRENGTH_256);
        List<File> filesToAdd = Arrays.asList(
                new File("d:/test.txt"),
                new File("d:/a.txt")
        );
        ZipFile zipFile = new ZipFile("d:\\携带密码.zip", "password".toCharArray());
        zipFile.addFiles(filesToAdd, zipParameters);

         身份证验证
        IdcardUtil现在支持大陆15位、18位身份证，港澳台10位身份证。
        工具中主要的方法包括：
        isValidCard 验证身份证是否合法
        convert15To18 身份证15位转18位
        getBirthByIdCard 获取生日
        getAgeByIdCard 获取年龄
        getYearByIdCard 获取生日年
        getMonthByIdCard 获取生日月
        getDayByIdCard 获取生日天
        getGenderByIdCard 获取性别
        getProvinceByIdCard 获取省份

        String ID_18 = "321083197812162119";
        String ID_15 = "150102880730303";

//是否有效
        boolean valid = IdcardUtil.isValidCard(ID_18);
        boolean valid15 = IdcardUtil.isValidCard(ID_15);

//转换
        String convert15To18 = IdcardUtil.convert15To18(ID_15);
        Assert.assertEquals(convert15To18, "150102198807303035");
        System.out.println(convert15To18);

//年龄
        DateTime date = DateUtil.parse("2017-04-10");

        int age = IdcardUtil.getAgeByIdCard(ID_18, date);
        Assert.assertEquals(age, 38);

        int age2 = IdcardUtil.getAgeByIdCard(ID_15, date);
        Assert.assertEquals(age2, 28);

//生日
        String birth = IdcardUtil.getBirthByIdCard(ID_18);
        Assert.assertEquals(birth, "19781216");
        System.out.println(birth);

        String birth2 = IdcardUtil.getBirthByIdCard(ID_15);
        Assert.assertEquals(birth2, "19880730");

//省份
        String province = IdcardUtil.getProvinceByIdCard(ID_18);
        Assert.assertEquals(province, "江苏");

        String province2 = IdcardUtil.getProvinceByIdCard(ID_15);
        Assert.assertEquals(province2, "内蒙古");

         信息脱敏工具-DesensitizedUtil
         身份证
        System.out.println(DesensitizedUtil.idCardNum("51343620000320711X", 1, 2));
        //手机号
        System.out.println(DesensitizedUtil.mobilePhone("18049531999"));
        // 密码保留位数
        System.out.println(DesensitizedUtil.password("1234567890"));
        Console.log("This is Console log for {}{}.", "test","zzz");

        集合工具-CollUtil
         将集合转换为字符串
        String[] col= new String[]{"a","b","c","d","e"};
        List<String> colList = CollUtil.newArrayList(col);
        String str = CollUtil.join(colList, ""); //str -> a#b#c#d#e
        Console.log(str);

         将两个集合中的元素一一对应，成为一个Map
        Collection<String> keys = CollUtil.newArrayList("a", "b", "c", "d");
        Collection<Integer> values = CollUtil.newArrayList(1, 2, 3, 4);
        Map<String, Integer> map = CollUtil.zip(keys, values);
        Console.log(map);

         列表工具ListUtil

         获取满足指定规则所有的元素的位置
        List<String> a = ListUtil.toLinkedList("1", "2", "3", "4", "3", "2", "1");
        int[] indexArray = ListUtil.indexOfAll(a, "2"::equals);
        Console.log(indexArray);

         拆分 对集合按照指定长度分段，每一个段为单独的集合，返回这个集合的列表
        List<List<Object>> lists1 = ListUtil.split(Arrays.asList(1, 2, 3, 4), 1);
        List<List<Object>> lists2 = ListUtil.split(null, 3);
        Console.log(lists1); // [[1], [2], [3], [4]]
        Console.log(lists2);// []

         编辑元素
        List<String> a = ListUtil.toLinkedList("1", "2", "3");
        final List<String> filter = (List<String>) CollUtil.edit(a, str -> "edit" + str);
        Console.log(filter.get(0));

         列表截取
        final List<Integer> of = ListUtil.of(1, 2, 3, 4);
// [3, 4]
        final List<Integer> sub = ListUtil.sub(of, 2, 4);
        Console.log(sub);// [3,4]
// 对子列表操作不影响原列表
        sub.remove(0);
        Console.log(sub);// [4]
        Console.log(of);

         元素交换
        List<Integer> list = Arrays.asList(7, 2, 8, 9);
// 将元素8和第一个位置(下标)交换
        ListUtil.swapTo(list, 8, 0);
        Console.log(list);

        // 线程安全的HashSet-ConcurrentHashSet
        Set<String> set = new ConcurrentHashSet<>();
        set.add("a");
        set.add("b");
        Console.log(set);
    }

JSONUtil工具类，JSON字符串与对象互转

  public static void main(String[] args) {
        // 任何转JSON字符串 JSONUtil.toJsonStr()

        SortedMap<Object, Object> sortedMap = new TreeMap<Object, Object>() {
            private static final long serialVersionUID = 1L;
            {
                put("attributes", "a");
                put("b", "b");
                put("c", "c");
            }};
        System.out.println(JSONUtil.toJsonStr(sortedMap));


        //JSON字符串解析为JSON对象取数据
        String html = "{\"name\":\"Something must have been changed since you leave\"}";
        JSONObject jsonObject = JSONUtil.parseObj(html);
        System.out.println(jsonObject.getStr("name"));
    }