精华内容
下载资源
问答
  • Hutool

    2021-04-06 17:56:05
    Hutool是一个Java基础工具类,对文件、流、加密解密、转码、正则、线程、XML等JDK方法进行封装,组成各种Util工具类,同时提供以下组件:布隆过滤缓存克隆接口类型转换日期处理数据库ORM(基于ActiveRecord思想)...
  • HuTool

    2021-03-14 01:58:11
    HuTool Hutool参考文档 1、简介 2、包含组件 一个java基础工具类,对文件、流、加密解密、转码、正则、线程、XML等JDK方法进行封装,组成各种Util工具类,同时提供以下组件: 注意:可以根据需求对每个模块...

    HuTool


    Hutool参考文档

    1、简介

    image-20210219135841091


    image-20210219140031878


    2、包含组件

    一个java基础工具类,对文件、流、加密解密、转码、正则、线程、XML等JDK方法进行封装,组成各种Util工具类,同时提供以下组件:

    image-20210219140436586

    注意:可以根据需求对每个模块单独引入,也可以通过引入hutool-all方式引入所有模块

    3、使用Hutool


    直接在项目中导入依赖即可:

    <!-- https://mvnrepository.com/artifact/cn.hutool/hutool-all -->
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>5.3.10</version>
    </dependency>
    
    

    4、Convert类型转换

    image-20210219141439195

    3、如何使用

    1. 转换为字符串

      image-20210219142700098


      image-20210219142844024


    image-20210219143115625


    5、IO流操作


    image-20210219143358431

    package cn.dxj1016.Hutool;
    
    import cn.hutool.core.io.IoUtil;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class TestOUtils {
        public static void main(String[] args) throws IOException {
    //        原始文件拷贝
            FileInputStream is = new FileInputStream(new File("D:\\笔记\\java\\狂神说java\\程序2\\mybatis-Study\\mybatis-01\\src\\main\\resources\\aa.txt"));
            FileOutputStream os = new FileOutputStream(new File("D:\\笔记\\java\\狂神说java\\程序2\\mybatis-Study\\mybatis-01\\src\\main\\resources\\cc.txt"));
    //使用Hutool
            IoUtil.copy(is, os);
    //            IoUtil.copy(is, os,2024);//指定缓冲区大小
            /*//        定义缓冲区
            byte[] b = new byte[1024];
            int len = 0;
            while (true) {
                len = is.read(b);
                if (len == -1) {
                    break;
                } else {
                    os.write(b,0,len);
                }
    
            }
            is.close();
            os.close();*/
    
        }
    }
    
    
    
    展开全文
  • hutool

    2020-02-17 19:46:18
    [官网:https://www.hutool.cn/](https://www.hutool.cn/)
    [官网:]https://www.hutool.cn/
    
    展开全文
  • Hutool工具

    万次阅读 多人点赞 2020-12-09 19:54:56
    Hutool是一个小而全的Java工具类库,通过静态方法封装,降低相关API的学习成本,提高工作效率,使Java拥有函数式语言般的优雅,让Java语言也可以“甜甜的”。 Hutool中的工具方法来自每个用户的精雕细琢,它涵盖了...

    很多方法请看官网地址:hutool官网地址

    简介

    Hutool是一个小而全的Java工具类库,通过静态方法封装,降低相关API的学习成本,提高工作效率,使Java拥有函数式语言般的优雅,让Java语言也可以“甜甜的”。

    Hutool中的工具方法来自每个用户的精雕细琢,它涵盖了Java开发底层代码中的方方面面,它既是大型项目开发中解决小问题的利器,也是小型项目中的效率担当;

    Hutool是项目中“util”包友好的替代,它节省了开发人员对项目中公用类和公用工具方法的封装时间,使开发专注于业务,同时可以最大限度的避免封装不完善带来的bug。

    Hutool名称的由来
    Hutool = Hu + tool,是原公司项目底层代码剥离后的开源库,“Hu”是公司名称的表示,tool表示工具。Hutool谐音“糊涂”,一方面简洁易懂,一方面寓意“难得糊涂”。

    Hutool如何改变我们的coding方式
    Hutool的目标是使用一个工具方法代替一段复杂代码,从而最大限度的避免“复制粘贴”代码的问题,彻底改变我们写代码的方式。

    以计算MD5为例:

    【以前】打开搜索引擎 -> 搜“Java MD5加密” -> 打开某篇博客-> 复制粘贴 -> 改改好用
    【现在】引入Hutool -> SecureUtil.md5()
    Hutool的存在就是为了减少代码搜索成本,避免网络上参差不齐的代码出现导致的bug。
    包含组件
    一个Java基础工具类,对文件、流、加密解密、转码、正则、线程、XML等JDK方法进行封装,组成各种Util工具类,同时提供以下组件:

    模块 介绍
    hutool-aop JDK动态代理封装,提供非IOC下的切面支持
    hutool-bloomFilter 布隆过滤,提供一些Hash算法的布隆过滤
    hutool-cache 简单缓存实现
    hutool-core 核心,包括Bean操作、日期、各种Util等
    hutool-cron 定时任务模块,提供类Crontab表达式的定时任务
    hutool-crypto 加密解密模块,提供对称、非对称和摘要算法封装
    hutool-db JDBC封装后的数据操作,基于ActiveRecord思想
    hutool-dfa 基于DFA模型的多关键字查找
    hutool-extra 扩展模块,对第三方封装(模板引擎、邮件、Servlet、二维码、Emoji、FTP、分词等)
    hutool-http 基于HttpUrlConnection的Http客户端封装
    hutool-log 自动识别日志实现的日志门面
    hutool-script 脚本执行封装,例如Javascript
    hutool-setting 功能更强大的Setting配置文件和Properties封装
    hutool-system 系统参数调用封装(JVM信息等)
    hutool-json JSON实现
    hutool-captcha 图片验证码实现
    hutool-poi 针对POI中Excel和Word的封装
    hutool-socket 基于Java的NIO和AIO的Socket封装

    Maven
    在项目的pom.xml的dependencies中加入以下内容:

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

    痛点

    在Java开发中我们要面对各种各样的类型转换问题,尤其是从命令行获取的用户参数、从HttpRequest获取的Parameter等等,这些参数类型多种多样,我们怎么去转换他们呢?常用的办法是先整成String,然后调用XXX.parseXXX方法,还要承受转换失败的风险,不得不加一层try catch,这个小小的过程混迹在业务代码中会显得非常难看和臃肿。

    Convert类

    Convert类可以说是一个工具方法类,里面封装了针对Java常见类型的转换,用于简化类型转换。Convert类中大部分方法为toXXX,参数为Object,可以实现将任意可能的类型转换为指定类型。同时支持第二个参数defaultValue用于在转换失败时返回一个默认值。

    Java常见类型转换

    1.转换为字符串:

    int a = 1;
    //aStr为"1"
    String aStr = Convert.toStr(a);
    
    long[] b = {1,2,3,4,5};
    //bStr为:"[1, 2, 3, 4, 5]"
    String bStr = Convert.toStr(b);
    

    2.转换为指定类型数组:

    String[] b = { "1", "2", "3", "4" };
    //结果为Integer数组
    Integer[] intArray = Convert.toIntArray(b);
    
    long[] c = {1,2,3,4,5};
    //结果为Integer数组
    Integer[] intArray2 = Convert.toIntArray(c);
    

    3.转换为日期对象:

    String a = "2017-05-06";
    Date value = Convert.toDate(a);
    

    4.转换为集合

    Object[] a = {"a", "你", "好", "", 1};
    List<?> list = Convert.convert(List.class, a);
    //从4.1.11开始可以这么用
    List<?> list = Convert.toList(a);
    

    其它类型转换

    1.标准类型
    通过Convert.convert(Class, Object)方法可以将任意类型转换为指定类型,Hutool中预定义了许多类型转换,例如转换为URI、URL、Calendar等等,这些类型的转换都依托于ConverterRegistry类。通过这个类和Converter接口,我们可以自定义一些类型转换。详细的使用请参阅“自定义类型转换”一节。

    2.泛型类型
    通过convert(TypeReference reference, Object value)方法,自行new一个TypeReference对象可以对嵌套泛型进行类型转换。例如,我们想转换一个对象为List类型,此时传入的标准Class就无法满足要求,此时我们可以这样:

    Object[] a = { "a", "你", "好", "", 1 };
    List<String> list = Convert.convert(new TypeReference<List<String>>() {}, a);
    

    通过TypeReference实例化后制定泛型类型,即可转换对象为我们想要的目标类型。

    16进制(Hex)

    在很多加密解密,以及中文字符串传输(比如表单提交)的时候,会用到16进制转换,就是Hex转换,为此Hutool中专门封装了HexUtil工具类,考虑到16进制转换也是转换的一部分,因此将其方法也放在Convert类中,便于理解和查找,使用同样非常简单:

    转为16进制(Hex)字符串

    String a = "我是一个小小的可爱的字符串";
    
    //结果:"e68891e698afe4b880e4b8aae5b08fe5b08fe79a84e58fafe788b1e79a84e5ad97e7aca6e4b8b2"
    String hex = Convert.toHex(a, CharsetUtil.CHARSET_UTF_8);
    

    将16进制(Hex)字符串转为普通字符串:

    String hex = "e68891e698afe4b880e4b8aae5b08fe5b08fe79a84e58fafe788b1e79a84e5ad97e7aca6e4b8b2";
    
    //结果为:"我是一个小小的可爱的字符串"
    String raw = Convert.hexStrToStr(hex, CharsetUtil.CHARSET_UTF_8);
    
    //注意:在4.1.11之后hexStrToStr将改名为hexToStr
    String raw = Convert.hexToStr(hex, CharsetUtil.CHARSET_UTF_8);
    

    因为字符串牵涉到编码问题,因此必须传入编码对象,此处使用UTF-8编码。 toHex方法同样支持传入byte[],同样也可以使用hexToBytes方法将16进制转为byte[]

    Unicode和字符串转换

    与16进制类似,Convert类同样可以在字符串和Unicode之间轻松转换:

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

    编码转换

    在接收表单的时候,我们常常被中文乱码所困扰,其实大多数原因是使用了不正确的编码方式解码了数据。于是Convert.convertCharset方法便派上用场了,它可以把乱码转为正确的编码方式:

    String a = "我不是乱码";
    //转换后result为乱码
    String result = Convert.convertCharset(a, CharsetUtil.UTF_8, CharsetUtil.ISO_8859_1);
    String raw = Convert.convertCharset(result, CharsetUtil.ISO_8859_1, "UTF-8");
    Assert.assertEquals(raw, a);
    

    注意 经过测试,UTF-8编码后用GBK解码再用GBK编码后用UTF-8解码会存在某些中文转换失败的问题。

    时间单位转换

    Convert.convertTime方法主要用于转换时长单位,比如一个很大的毫秒,我想获得这个毫秒数对应多少分:

    long a = 4535345;
    
    //结果为:75
    long minutes = Convert.convertTime(a, TimeUnit.MILLISECONDS, TimeUnit.MINUTES);
    

    金额大小写转换

    面对财务类需求,Convert.digitToChinese将金钱数转换为大写形式:

    double a = 67556.32;
    
    //结果为:"陆万柒仟伍佰伍拾陆元叁角贰分"
    String digitUppercase = Convert.digitToChinese(a);
    

    注意 转换为大写只能精确到分(小数点儿后两位),之后的数字会被忽略。

    原始类和包装类转换

    有的时候,我们需要将包装类和原始类相互转换(比如Integer.class 和 int.class),这时候我们可以:

    //去包装
    Class<?> wrapClass = Integer.class;
    
    //结果为:int.class
    Class<?> unWraped = Convert.unWrap(wrapClass);
    
    //包装
    Class<?> primitiveClass = long.class;
    
    //结果为:Long.class
    Class<?> wraped = Convert.wrap(primitiveClass);
    

    格式化为字符串

    调用toString()方法即可返回格式为yyyy-MM-dd HH:mm:ss的字符串,调用toString(String format)可以返回指定格式的字符串。

    DateTime dateTime = new DateTime("2017-01-05 12:34:23", DatePattern.NORM_DATETIME_FORMAT);
    //结果:2017-01-05 12:34:23
    String dateStr = dateTime.toString();
    
    //结果:2017/01/05
    

    LocalDateTime工具-LocalDateTimeUtil

    使用

    1. 日期转换
    String dateStr = "2020-01-23T12:23:56";
    DateTime dt = DateUtil.parse(dateStr);
    
    // Date对象转换为LocalDateTime
    LocalDateTime of = LocalDateTimeUtil.of(dt);
    
    // 时间戳转换为LocalDateTime
    of = LocalDateTimeUtil.ofUTC(dt.getTime());
    
    1. 日期字符串解析
    // 解析ISO时间
    LocalDateTime localDateTime = LocalDateTimeUtil.parse("2020-01-23T12:23:56");
    
    
    // 解析自定义格式时间
    localDateTime = LocalDateTimeUtil.parse("2020-01-23", DatePattern.NORM_DATE_PATTERN);
    

    解析同样支持LocalDate:

    LocalDate localDate = LocalDateTimeUtil.parseDate("2020-01-23");
    
    // 解析日期时间为LocalDate,时间部分舍弃
    localDate = LocalDateTimeUtil.parseDate("2020-01-23T12:23:56", DateTimeFormatter.ISO_DATE_TIME);
    
    1. 日期格式化
    LocalDateTime localDateTime = LocalDateTimeUtil.parse("2020-01-23T12:23:56");
    
    // "2020-01-23 12:23:56"
    String format = LocalDateTimeUtil.format(localDateTime, DatePattern.NORM_DATETIME_PATTERN);
    
    1. 日期偏移
    final LocalDateTime localDateTime = LocalDateTimeUtil.parse("2020-01-23T12:23:56");
    
    // 增加一天
    // "2020-01-24T12:23:56"
    LocalDateTime offset = LocalDateTimeUtil.offset(localDateTime, 1, ChronoUnit.DAYS);
    

    如果是减少时间,offset第二个参数传负数即可:

    // "2020-01-22T12:23:56"
    offset = LocalDateTimeUtil.offset(localDateTime, -1, ChronoUnit.DAYS);
    
    1. 日期偏移
    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
    between.toDays();
    
    1. 一天的开始和结束
    LocalDateTime localDateTime = LocalDateTimeUtil.parse("2020-01-23T12:23:56");
    
    // "2020-01-23T00:00"
    LocalDateTime beginOfDay = LocalDateTimeUtil.beginOfDay(localDateTime);
    
    // "2020-01-23T23:59:59.999999999"
    LocalDateTime endOfDay = LocalDateTimeUtil.endOfDay(localDateTime);
    

    字符串工具-StrUtil

    1.removePrefix、removeSuffix方法
    这两个是去掉字符串的前缀后缀的,例如去个文件名的扩展名啥。

    String fileName = StrUtil.removeSuffix("pretty_girl.jpg", ".jpg")  //fileName -> pretty_girl
    

    还有忽略大小写的removePrefixIgnoreCase和removeSuffixIgnoreCase都比较实用。
    2. sub方法
    不得不提一下这个方法,有人说String有了subString你还写它干啥,我想说subString方法越界啥的都会报异常,你还得自己判断,难受死了,我把各种情况判断都加进来了,而且index的位置还支持负数哦,-1表示最后一个字符(这个思想来自于Python,如果学过Python的应该会很喜欢的),还有就是如果不小心把第一个位置和第二个位置搞反了,也会自动修正(例如想截取第4个和第2个字符之间的部分也是可以的哦~) 举个栗子

    String str = "abcdefgh";
    String strSub1 = StrUtil.sub(str, 2, 3); //strSub1 -> c
    String strSub2 = StrUtil.sub(str, 2, -3); //strSub2 -> cde
    String strSub3 = StrUtil.sub(str, 3, 2); //strSub2 -> c
    

    3.format方法

    String template = "{}爱{},就像老鼠爱大米";
    String str = StrUtil.format(template, "我", "你"); //str -> 我爱你,就像老鼠爱大米
    

    参数我定义成了Object类型,如果传别的类型的也可以,会自动调用toString()方法的。

    Digester

    以MD5为例:

    Digester md5 = new Digester(DigestAlgorithm.MD5);
    
    // 5393554e94bf0eb6436f240a4fd71282
    String digestHex = md5.digestHex(testStr);
    

    当然,做为最为常用的方法,MD5等方法被封装为工具方法在DigestUtil中,以上代码可以进一步简化为:

    // 5393554e94bf0eb6436f240a4fd71282
    String md5Hex1 = DigestUtil.md5Hex(testStr);
    

    Hutool-http

    最简单的使用莫过于用HttpUtil工具类快速请求某个页面:

    //GET请求
    String content = HttpUtil.get(url);
    

    一行代码即可搞定,当然Post请求也很简单:

    //POST请求
    HashMap<String, Object> paramMap = new HashMap<>();
    paramMap.put("city", "北京");
    
    String result1 = HttpUtil.post(url, paramMap);
    

    Post请求只需使用Map预先制定form表单项即可。

    展开全文
  • Java开发常用类库之Hutool

    万次阅读 多人点赞 2021-02-19 20:33:13
    Java 开发常用类库之Hutool

    本文的所有代码均已上传GitHub,HuTool学习

    学习交流q群:470464545,大家一起学习进步,CSDN博客:lolly1023

    文章目录

    简介与安装

    简介

    Hutool是一个小而全的Java工具类库,通过静态方法封装,降低相关API的学习成本,提高工作效率,使Java拥有函数式语言般的优雅,让Java语言也可以“甜甜的”。

    Hutool中的工具方法来自每个用户的精雕细琢,它涵盖了Java开发底层代码中的方方面面,它既是大型项目开发中解决小问题的利器,也是小型项目中的效率担当;

    Hutool是项目中“util”包友好的替代,它节省了开发人员对项目中公用类和公用工具方法的封装时间,使开发专注于业务,同时可以最大限度的避免封装不完善带来的bug。

    Hutool名称的由来

    Hutool = Hu + tool,是原公司项目底层代码剥离后的开源库,“Hu”是公司名称的表示,tool表示工具。Hutool谐音“糊涂”,一方面简洁易懂,一方面寓意“难得糊涂”。

    Hutool如何改变我们的coding方式

    Hutool的目标是使用一个工具方法代替一段复杂代码,从而最大限度的避免“复制粘贴”代码的问题,彻底改变我们写代码的方式。

    以计算MD5为例:

    • 【以前】打开搜索引擎 -> 搜“Java MD5加密” -> 打开某篇博客-> 复制粘贴 -> 改改好用
    • 【现在】引入Hutool -> SecureUtil.md5()

    Hutool的存在就是为了减少代码搜索成本,避免网络上参差不齐的代码出现导致的bug。


    上述摘自HuTool官网

    安装

    在Maven项目中
    在项目的pom.xml的dependencies中加入以下内容:

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

    非Maven项目中
    点击以下任一链接,下载hutool-all-X.X.X.jar即可:

    注意 Hutool 5.x支持JDK8+,对Android平台没有测试,不能保证所有工具类或工具方法可用。 如果你的项目使用JDK7,请使用Hutool 4.x版本

    常用方法

    本文的所有代码均已上传GitHub,HuTool学习

    类型转换

    类型转换的工具类为Convert

    转为字符串

    		// int类型转换
    		int aInt = 1023;
    		String aStr = Convert.toStr(aInt);
    		// aStr结果为1023
    		System.out.println(aStr);
    		// 数组进行转换
    		int[] bArray = {1,2,3,4,5};
    		String bStr = Convert.toStr(bArray);
    		// bStr结果为[1, 2, 3, 4, 5]
    		System.out.println(bStr);
    

    转为指定类型数组

    		String[] strArray = { "1", "0", "2", "3" };
    		//结果为Integer数组
    		Integer[] intArray = Convert.toIntArray(strArray);
    		System.out.println(Convert.toStr(intArray));
    		
    		Integer[] intArray2 = {1,0,2,3};
    		//结果为String数组
    		String[] strArray2 = Convert.toStrArray(intArray2);
    		System.out.println(Convert.toStr(strArray2));
    

    转换为Date日期对象

    		String date = "2000-10-23";
    		//结果为Date日期对象
    		Date value = Convert.toDate(date);
    		System.out.println(value);
    

    转化为List集合

    		Object[] objectArray = {"lolly1023","lolly",1023};
    		List<?> list = Convert.convert(List.class, objectArray);
    		System.out.println(list);
    		// 4.1.11版本之后可使用toList
    		List<?> list2 = Convert.toList(objectArray);
    		System.out.println(list2);
    

    日期时间

    日期时间的工具类为DateUtil

    多种获取日期的方式

    		// 获取当前时间的Date对象
    		Date nowDate = DateUtil.date();
    		System.out.println(nowDate);
    		
    		// 使用Calendar获取当前时间的Date对象
    		Date nowDate2 = DateUtil.date(Calendar.getInstance());
    		System.out.println(nowDate2);
    		
    		// 使用当前时间戳获取当前时间的Date对象
    		Date nowDate3 = DateUtil.date(System.currentTimeMillis());
    		System.out.println(nowDate3);
    		
    		// 使用工具类获取当前时间的字符串,格式为:yyyy-MM-dd HH:mm:ss
    		String nowDateStr = DateUtil.now();
    		System.out.println(nowDateStr);
    		
    		// 使用工具类获取当前时间的字符串,格式为:yyyy-MM-dd
    		String todayDateStr= DateUtil.today();
    		System.out.println(todayDateStr);
    

    输出样式为:

    2021-02-19 21:04:12
    2021-02-19 21:04:12
    2021-02-19 21:04:12
    2021-02-19 21:04:12
    2021-02-19
    

    字符串转换为Date对象

    字符串转为Date对象使用到了DateUtil工具类中的parse方法,该方法会自动识别一些日期的常用格式,例如:

    1. yyyy-MM-dd HH:mm:ss.SSS
    2. yyyy-MM-dd HH:mm:ss
    3. yyyy-MM-dd HH:mm
    4. yyyy-MM-dd
    5. HH:mm:ss
    		// 字符串转为Date对象 
    		String dateStr = "2000-10-23 12:30";
    		Date date = DateUtil.parse(dateStr);
    		// 输出2000-10-23 12:30:00
    		System.out.println(date);
    		
    		// 也可以在转的时候指定格式
    		Date date2 = DateUtil.parse(dateStr,"yyyy-MM-dd");
    		// 输出2000-10-23 00:00:00
    		System.out.println(date2);
    

    格式化Date对象

    		//格式化Date日期对象
    		Date date4 = DateUtil.date();
    		
    		String format = DateUtil.format(date4, "yyyy年MM月dd日");
    		// 输出为2021年02月19日
    		System.out.println(format);
    		
    		String formatDate = DateUtil.formatDate(date4);
    		// 常用格式化,输出为2021-02-19
    		System.out.println(formatDate);
    		
    		String formatDateTime = DateUtil.formatDateTime(date4);
    		// 精确到秒,结果为2021-02-19 21:16:09
    		System.out.println(formatDateTime);
    		
    		String formatTime = DateUtil.formatTime(date4);
    		// 只保留时分秒,结果为21:16:09
    		System.out.println(formatTime);
    

    获取Date对象的年月日

    		// 获取Date对象的年月日
    		Date date5 = DateUtil.date();
    		// 获取年,结果为2021
    		System.out.println(DateUtil.year(date5));
    		// 获取月,结果为1(从0开始计数,0则为一月)
    		System.out.println(DateUtil.month(date5));
    		// 获取日(在本年)
    		System.out.println(DateUtil.dayOfYear(date5));
    		// 获取日(在本月)
    		System.out.println(DateUtil.dayOfMonth(date5));
    		// 获取日(在本周)
    		System.out.println(DateUtil.dayOfWeek(date5));
    

    开始和结束日期

    用于计算开始时间和结束时间,有每天的,每月的,等等

    		Date date3 = DateUtil.date();
    
    		//一天的开始,结果:2021-02-19 00:00:00
    		Date beginOfDay = DateUtil.beginOfDay(date3);
    		System.out.println(beginOfDay);
    		//一天的结束,结果:2021-02-19 23:59:59
    		Date endOfDay = DateUtil.endOfDay(date3);
    		System.out.println(endOfDay);
    		//一月的开始,结果:2021-02-01 00:00:00
    		Date beginOfMonth = DateUtil.beginOfMonth(date3);
    		System.out.println(beginOfMonth);
    		//一月的结束,结果:2021-02-28 23:59:59
    		Date endOfMonth = DateUtil.endOfMonth(date3);
    		System.out.println(endOfMonth);
    

    日期时间的偏移

    日期的减少或者添加,可以对时分秒天周月等进行更改

    		String dateStr2 = "2000-10-23 12:30";
    		Date date6 = DateUtil.parse(dateStr2);
    		
    		// 偏移10天
    		DateTime newDate = DateUtil.offsetDay(date, 10);
    		// 结果为2000-11-02 12:30:00
    		System.out.println(newDate);
    		// 偏移-10天
    		DateTime newDate2 = DateUtil.offsetDay(date, -10);
    		// 结果为2000-10-13 12:30:00
    		System.out.println(newDate2);
    		
    		/**常用的偏移还有
    		 * 月份 :DateUtil.offsetMonth(newDate2, offset)
    		 * 周:DateUtil.offsetWeek(newDate2, offset)
    		 */
    		
    		// 对比这种偏移,还有一种较简单的偏移方法
    		//昨天
    		System.out.println(DateUtil.yesterday());
    		//明天
    		System.out.println(DateUtil.tomorrow());
    		//上周
    		System.out.println(DateUtil.lastWeek());
    		//下周
    		System.out.println(DateUtil.nextWeek());
    		//上个月
    		System.out.println(DateUtil.lastMonth());
    		//下个月
    		System.out.println(DateUtil.nextMonth());
    

    日期时间差

    用于计算两个日期直接的时间差

    		String dateStr3 = "2000-10-23 12:30:00";
    		Date date7 = DateUtil.parse(dateStr3);
    
    		Date date8 = DateUtil.date();
    
    		// 计算2000-10-23距今多久:7424天
    		long betweenDay = DateUtil.between(date7, date8, DateUnit.DAY);
    		System.out.println(betweenDay);
    

    计时器

    		TimeInterval timer = DateUtil.timer();
    		
    		try {
    			// 模拟耗时操作
    			Thread.sleep(2000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		//花费毫秒数
    		System.out.println(timer.interval());
    		//返回花费时间,并重置开始时间
    		System.out.println(timer.intervalRestart());
    		//花费分钟数
    		System.out.println(timer.intervalMinute());
    

    星座与属相

    这个功能还是挺出乎意料的,没想到还有这种

    		// "天秤座"
    		String zodiac = DateUtil.getZodiac(Month.OCTOBER.getValue(), 23);
    		System.out.println(zodiac);
    		// "龙"
    		String chineseZodiac = DateUtil.getChineseZodiac(2000);
    		System.out.println(chineseZodiac);
    

    年龄与闰年判断

    不得不说,这个工具类小玩意还挺多

    		//年龄
    		System.out.println(DateUtil.ageOfNow("2000-10-23"));
    
    		//是否闰年
    		System.out.println(DateUtil.isLeapYear(2000));
    

    IO流相关

    文件的拷贝

    		// 文件的拷贝
    		BufferedInputStream in = FileUtil.getInputStream("d:/桌面/HuTool学习.md");
    		BufferedOutputStream out = FileUtil.getOutputStream("d:/桌面/HuTool学习复制.md");
    		long copySize = IoUtil.copy(in, out, IoUtil.DEFAULT_BUFFER_SIZE);
    		// 拷贝文件的大小
    		System.out.println(copySize);
    		System.out.println("拷贝成功");
    		in.close();
    		out.close();
    

    文件类型判断

    用于文件类型的判断,返回值为文件的类型

    		File file = FileUtil.file("d:/桌面/HuTool学习.md");
    		String type = FileTypeUtil.getType(file);
    		//输出的是文件的格式
    		Console.log(type);
    

    文件监听

    在以前,我们需要监听文件的变化:创建修改删除等,需要进行遍历来定时检查文件,效率很低,性能很差,所以有了这个工具类。
    监听指定事件

    		File file2 = FileUtil.file("example.properties");
    		//这里只监听文件或目录的修改事件
    		WatchMonitor watchMonitor = WatchMonitor.create(file2, 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();
    

    监听全部事件

    		WatchMonitor.createAll(file, new SimpleWatcher(){
    		    @Override
    		    public void onModify(WatchEvent<?> event, Path currentPath) {
    		        Console.log("EVENT modify");
    		    }
    		}).start();
    

    文件的读取

    		//默认UTF-8编码,可以在构造中传入第二个参数做为编码
    		FileReader fileReader = new FileReader("d:/桌面/HuTool测试.txt");
    		String result = fileReader.readString();
    		System.out.println(result);
    

    文件的写入

    		FileWriter writer = new FileWriter("d:/桌面/HuTool测	试.txt");
    		writer.write("添加文本",true);
    

    文件追加

    主要用于类似日志这种(此类只有在写入文件的时候打开文件,写入结束之后,此类不需要关闭

    		File file = new File("d:/桌面/HuTool测试.txt");
    		FileAppender appender = new FileAppender(file, 16, true);
    		appender.append("lolly1023");
    		appender.append("追加");
    		appender.append("成功");
    
    		appender.flush();
    		appender.toString();
    

    文件跟随

    有时候需要启动线程来“监控文件的变化,类似于Linux下的tail -f命令

    	Tailer tailer = new Tailer(FileUtil.file("d:/桌面/test.log"), Tailer.CONSOLE_HANDLER, 2);
    	tailer.start();
    

    实时打印文件变化的类

    /**
     * 命令行打印的行处理器
     * 
     * @author looly
     * @since 4.5.2
     */
    public static class ConsoleLineHandler implements LineHandler {
        @Override
        public void handle(String line) {
            Console.log(line);
        }
    }
    

    该方法会阻塞线程

    文件名与扩展名

    获取文件名

    		File file = FileUtil.file("d:/桌面/HuTool学习.md");
    
    		// HuTool学习.md
    		String name = FileNameUtil.getName(file);
    		System.out.println(name);
    

    单独获取主文件名扩展名

    		File file1 = FileUtil.file("d:/桌面/HuTool学习.md");
    
    		// "HuTool学习"
    		String name1 = FileNameUtil.mainName(file1);
    		System.out.println(name1);
    		// "md"
    		String name2 = FileNameUtil.extName(file1);
    		System.out.println(name2);
    

    工具类

    字符串工具

    判断是否为空

    给定指定字符串,如果是空,则返回true,使用到hasBlankhasEmpty方法。hasEmpty只判断是否为null或者是空字符串,hasBlank会把不可见的字符也算为空。

    		String nullStr = null;
    		// true
    		System.out.println(StrUtil.hasBlank(nullStr));
    		// true
    		System.out.println(StrUtil.hasEmpty(nullStr));
    

    删除前后缀

    removePrefix为删除字符串前缀,removeSuffix为删除字符串后缀,经常用于去文件扩展名。

    		String fileName = StrUtil.removeSuffix("HuTool学习.md", ".md"); 
    		// HuTool学习
    		System.out.println(fileName);
    		String fileName1 = StrUtil.removePrefix("HuTool学习.md", "HuTool学习."); 
    		// md
    		System.out.println(fileName1);
    

    截取字符串

    String中就有截取字符串的方法,但是时常会越界,在这个工具类中,该方法会自动判断,支持负数,(与python相同),第二个位置与第一个位置搞反了的话,也会自动识别更改。

    		String str = "lolly1023";
    		
    		String strSub1 = StrUtil.sub(str, 0, 5); 
    		// lolly
    		System.out.println(strSub1);
    		String strSub2 = StrUtil.sub(str, 0, -4);
    		// lolly
    		System.out.println(strSub2);
    		String strSub3 = StrUtil.sub(str, 5, 0);
    		// lolly
    		System.out.println(strSub3);
    

    格式化字符串

    使用{}进行占位即可,然后使用format方法进行格式化

    		// 使用{}占位
    		String template = "{}+{}=2";
    		// 1+1=2
    		String str1 = StrUtil.format(template, "1", "1"); 
    		System.out.println(str1);
    

    16进制工具

    16进制的转换

    		String str = "测试16进制转换";
    
    		String hex = HexUtil.encodeHexStr(str, CharsetUtil.CHARSET_UTF_8);
    		// e6b58be8af953136e8bf9be588b6e8bdace68da2
    		System.out.println(hex);
    
    		String decodedStr = HexUtil.decodeHexStr(hex);
    		// 测试16进制转换,解码后与str相同
    		System.out.println(decodedStr);
    

    URL工具

    标准化URL链接

    对于不带http://头的地址做简单补全。

    		String url = "http://www.hutool.cn//aaa/bbb";
    		// 结果为:http://www.hutool.cn/aaa/bbb
    		String normalize = URLUtil.normalize(url);
    		System.out.println(normalize);
    		url = "http://www.hutool.cn//aaa/\\bbb?a=1&b=2";
    		// 结果为:http://www.hutool.cn/aaa/bbb?a=1&b=2
    		normalize = URLUtil.normalize(url);
    		System.out.println(normalize);
    

    XML工具

    读取XML

    读取XML分为两个方法:

    • XmlUtil.readXML 读取XML文件
    • XmlUtil.parseXml 解析XML字符串为Document对象

    写XML

    • XmlUtil.toStr 将XML文档转换为String
    • XmlUtil.toFile 将XML文档写入到文件

    创建XML

    • XmlUtil.createXml 创建XML文档, 创建的XML默认是utf8编码,修改编码的过程是在toStr和toFile方法里,既XML在转为文本的时候才定义编码。

    XML操作

    通过以下工具方法,可以完成基本的节点读取操作。

    • XmlUtil.cleanInvalid 除XML文本中的无效字符
    • XmlUtil.getElements 根据节点名获得子节点列表
    • XmlUtil.getElement 根据节点名获得第一个子节点
    • XmlUtil.elementText 根据节点名获得第一个子节点
    • XmlUtil.transElements 将NodeList转换为Element列表

    XML与对象转换

    • writeObjectAsXml 将可序列化的对象转换为XML写入文件,已经存在的文件将被覆盖。
    • readObjectFromXml 从XML中读取对象。

    注意 这两个方法严重依赖JDK的XMLEncoderXMLDecoder,生成和解析必须成对存在(遵循固定格式),普通的XML转Bean会报错。

    Xpath操作

    更多Xpath操作:点击此处
    举例xml文件

    <?xml version="1.0" encoding="utf-8"?>
    
    <returnsms> 
      <returnstatus>Success(成功)</returnstatus>  
      <message>ok</message>  
      <remainpoint>1490</remainpoint>  
      <taskID>885</taskID>  
      <successCounts>1</successCounts> 
    </returnsms>
    

    java代码

    		File xmlFile = new File("/Study/HuToolTest/src/main/java/com/rj/bd/HuToolTest/UTilTest/URLUtil/Test.xml");
    		Document docResult=XmlUtil.readXML(xmlFile);
    		Object value = XmlUtil.getByXPath("//returnsms/message", docResult, XPathConstants.STRING);
    		// ok
    		System.out.println(value.toString());
    

    对象工具

    两个对象是否相等

    需要满足:

    1. obj1 == null && obj2 == null
    2. obj1.equals(obj2)

    才会返回true

    		String string1 = "1";
    		Integer integer1 = 1;
    		// false
    		System.out.println(ObjectUtil.equal(string1, integer1));
    

    计算对象长度

    其实本质就是调用不同对象的计算长度方法,支持的类型有:

    • CharSequence
    • Collection
    • Map
    • Iterator
    • Enumeration
    • Array
    		List<Integer> list = new ArrayList<Integer>();
    		// 0
    		System.out.println(ObjectUtil.length(list));
    

    判断是否包含元素

    即为判断对象中是否包含元素

    		List<Integer> list1 = new ArrayList<Integer>();
    		list1.add(0);
    		// true
    		System.out.println(ObjectUtil.contains(list1, 0));
    

    判断是否为空

    		List<Integer> list2 = new ArrayList<Integer>();
    		// false
    		System.out.println(ObjectUtil.isNull(list2));
    		// true
    		System.out.println(ObjectUtil.isNotNull(list2));
    

    克隆

    • ObjectUtil.clone克隆对象,如果对象实现Cloneable接口,调用其clone方法,如果实现Serializable接口,执行深度克隆,否则返回null

    • ObjectUtil.cloneIfPossible 返回克隆后的对象,如果克隆失败,返回原对象

    • ObjectUtil.cloneByStream 序列化后拷贝流的方式克隆,对象必须实现Serializable接口

    序列化与反序列化

    • serialize 序列化,调用JDK序列化
    • unserialize 反序列化,调用JDK

    判断基本类型

    如果该对象是基本类型,则返回true,反之返回false。

    		int i = 0;
    		// true
    		System.out.println(ObjectUtil.isBasicType(i));
    

    反射

    获取某类的全部方法

    		// 获取类中的全部方法
    		Method[] methods = ReflectUtil.getMethods(Test.class);
    

    获取某类的某个方法

    		// 获取类中的某个方法
    		Method method = ReflectUtil.getMethod(Test.class, "getID");
    

    获取某类的构造方法

    		// 获取某类的构造方法
    		ReflectUtil.newInstance(Test.class);
    

    执行方法

    public class TestClass {
    	public String print(String string) {
    		return string;
    	}
    }	
    

    测试类

    		TestClass testClass = new TestClass();
    		// lolly1023
    		ReflectUtil.invoke(testClass, "print", "lolly1023");
    

    剪切板工具

    获取剪切板内容及修改剪切板内容

    		// 获取系统剪切板内容
    		Clipboard copy = ClipboardUtil.getClipboard();
    		// 设置剪切板内容,图片的话使用setImage
    		ClipboardUtil.setStr("123");
    		// 获取剪切板内容:123,图片的话使用getImage
    		System.out.println(ClipboardUtil.getStr());
    

    命令行工具

    通过Java代码执行命令行命令,在Wubdows下是cmd,在Linux下是shell命令

    执行命令

    		// cmd下输入ipconfig为网卡信息
    		String str = RuntimeUtil.execForStr("ipconfig");
    		// 输出正常,为网卡信息
    		System.out.println(str);
    

    数字工具

    加减乘除

    • NumberUtil.add 针对double类型做加法
    • NumberUtil.sub 针对double类型做减法
    • NumberUtil.mul 针对double类型做乘法
    • NumberUtil.div 针对double类型做除法,并提供重载方法用于规定除不尽的情况下保留小数位数和舍弃方式。

    以上的方法都会将double转为BigDecimal,解决了精确问题。

    保留小数

    		double te1=123456.123456;
    		double te2=123456.123456;
    		// 第二个参数为保留几位小数
    		// 123456.1
    		Console.log(NumberUtil.round(te1,1));
    		// 123456.123
    		Console.log(NumberUtil.round(te2,3));
    

    四舍五入

    		double te3=123456.123456;
    		double te4=123456.128456;
    		// 第二个参数为保留几位小数
    		//123456.12
    		Console.log(NumberUtil.roundStr(te3,2));
    		//123456.13
    		Console.log(NumberUtil.roundStr(te4,2));
    

    格式化

    		long c=299792458;//光速
    		String format = NumberUtil.decimalFormat(",###", c);//299,792,458
    		System.out.println(format);
    

    常用的格式化方式

    • 0 -> 取一位整数
    • 0.00 -> 取一位整数和两位小数
    • 00.000 -> 取两位整数和三位小数
    • # -> 取所有整数部分
    • #.##% -> 以百分比方式计数,并取两位小数
    • #.#####E0 -> 显示为科学计数法,并取五位小数
    • ,### -> 每三位以逗号进行分隔,例如:299,792,458
    • 光速大小为每秒,###米 -> 将格式嵌入文本

    更多格式化操作,点击处此

    是否为数字

    • NumberUtil.isNumber 是否为数字
    • NumberUtil.isInteger 是否为整数
    • NumberUtil.isDouble 是否为浮点数
    • NumberUtil.isPrimes 是否为质数

    随机数

    第一个参数为最小值,第二个参数为最大值,第三个参数为长度。

    		// 生成随机数,用int类型数组承载
    		int[] array = NumberUtil.generateRandomNumber(0, 10, 8);
    		System.out.println(Convert.toStr(array));
    		// 生成随机数,用Integer类型数组承载
    		Integer[] array2 = NumberUtil.generateBySet(0, 10, 8);
    		System.out.println(Convert.toStr(array2));
    

    有序整数列表

    生成一个有序的int类型数组

    		// 第一个参数为起点,第二个参数为终点
    		int[] array3 = NumberUtil.range(2, 5);
    		// [2, 3, 4, 5]
    		System.out.println(Convert.toStr(array3));
    

    其它

    • NumberUtil.factorial 阶乘
    • NumberUtil.sqrt 平方根
    • NumberUtil.divisor 最大公约数
    • NumberUtil.multiple 最小公倍数
    • NumberUtil.getBinaryStr 获得数字对应的二进制字符串
    • NumberUtil.binaryToInt 二进制转int
    • NumberUtil.binaryToLong 二进制转long
    • NumberUtil.compare 比较两个值的大小
    • NumberUtil.toStr 数字转字符串,自动并去除尾小数点儿后多余的0

    数组工具

    判断是否为空

    		int[] a = {};
    		int[] b = null;
    		// 判断空
    		// true
    		System.out.println(ArrayUtil.isEmpty(a));
    		// true
    		System.out.println(ArrayUtil.isEmpty(b));
    		
    		//判断非空
    		// false
    		System.out.println(ArrayUtil.isNotEmpty(a));
    

    新建泛型数组

    该方法支持泛型返回值

    		String[] newArray = ArrayUtil.newArray(String.class, 3);
    

    调整大小

    		ArrayUtil.resize(newArray, 4);
    

    合并数组

    		int[] c = {1,2,3};
    		int[] d = {4,5,6};
    		int[] e = ArrayUtil.addAll(c,d);
    		// [1, 2, 3, 4, 5, 6]
    		System.out.println(Convert.toStr(e));
    

    克隆

    1. 泛型数组调用原生克隆
    		Integer[] b = {1,2,3};
    		Integer[] cloneB = ArrayUtil.clone(b);
    		Assert.assertArrayEquals(b, cloneB);
    
    1. 非泛型数组(原始类型数组)调用第二种重载方法
    	int[] a = {1,2,3};
    	int[] clone = ArrayUtil.clone(a);
    	Assert.assertArrayEquals(a, clone);
    

    有序列表生成

    		int[] array = ArrayUtil.range(0,10);
    		// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    		System.out.println(Convert.toStr(array));
    

    拆分数组

    		byte[] array2 = {1,1,1,1,2,2,2,2};
    		byte[][] array3 = ArrayUtil.split(array2, 4);
    		// [[1, 1, 1, 1], [2, 2, 2, 2]]
    		System.out.println(Convert.toStr(array3));
    

    过滤

    举例,过滤数组,保留偶数

    		Integer[] a = {1,2,3,4,5,6};
    		Integer[] filter = ArrayUtil.filter(a, new 		Editor<Integer>(){
       		@Override
        	public Integer edit(Integer t) {
           	return (t % 2 == 0) ? t : null;
        	}});
    		Assert.assertArrayEquals(filter, new Integer[]{2,4,6});
    

    两个数组生成map

    此方法在python中为zip()函数。
    第一个数组为key,第二个数组对应为value

    		String[] keys = {"w", "e", "r", "f"};
    		Integer[] values = {1,0,2,3};
    		Map<String, Integer> map = ArrayUtil.zip(keys, values, true);
    		// {w=1, e=0, r=2, f=3}
    		System.out.println(Convert.toStr(map));
    

    是否包含元素

    		int[] f = {1,2,3};
    		// true
    		System.out.println(ArrayUtil.contains(f, 3));
    

    判断对象是否为数组

    		int[] g = {1,2,3};
    		int h = 1;
    		// true
    		System.out.println(ArrayUtil.isArray(g));
    		// false
    		System.out.println(ArrayUtil.isArray(h));
    

    转为字符串

    		int[] i = {1,2,3};
    		// [1, 2, 3]
    		System.out.println(ArrayUtil.toString(i));
    		// 第二个参数为间隔符, 1/2/3
    		System.out.println(ArrayUtil.join(i, "/"));
    

    随机工具

    基本使用

    • RandomUtil.randomInt 获得指定范围内的随机数
    • RandomUtil.randomBytes 随机bytes
    • RandomUtil.randomEle 随机获得列表中的元素
    • RandomUtil.randomEleSet 随机获得列表中的一定量的不重复元素,返回Set
    • RandomUtil.randomString 获得一个随机的字符串(只包含数字和字符)
    • RandomUtil.randomNumbers 获得一个只包含数字的字符串
    • RandomUtil.randomUUID 随机UUID
    • RandomUtil.weightRandom 权重随机生成器,传入带权重的对象,然后根据权重随机获取对象

    唯一ID工具

    UUID

    UUID全称通用唯一识别码(universally unique identifier)

    		//生成的UUID是带-的字符串
    		String uuid = IdUtil.randomUUID();
    		System.out.println(uuid);
    		//生成的是不带-的字符串
    		String simpleUUID = IdUtil.simpleUUID();
    		System.out.println(simpleUUID);
    

    ObjectId

    ObjectId是MongoDB数据库的一种唯一ID生成策略,是UUID version1的变种。

    		//生成id
    		String id = ObjectId.next();
    		System.out.println(id);
    		//方法2:从Hutool-4.1.14开始提供
    		String id2 = IdUtil.objectId();
    		System.out.println(id2);
    

    Snowflake

    分布式系统中,有一些需要使用全局唯一ID的场景,有些时候我们希望能使用一种简单一些的ID,并且希望ID能够按照时间有序生成。Twitter的Snowflake 算法就是这种生成器。

    		//参数1为终端ID
    		//参数2为数据中心ID
    		Snowflake snowflake = IdUtil.getSnowflake(1, 1);
    		long id3 = snowflake.nextId();
    		System.out.println(id3);
    

    压缩工具

    压缩

    打包到当前目录

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

    打包到指定目录

    		//将aaa目录下的所有文件目录打包到d:/bbb/目录下的aaa.zip文件中
    		// 此处第二个参数必须为文件,不能为目录
    		ZipUtil.zip("d:/aaa", "d:/bbb/aaa.zip");
    
    		//将aaa目录下的所有文件目录打包到d:/bbb/目录下的ccc.zip文件中
    		ZipUtil.zip("d:/aaa", "d:/bbb/ccc.zip");
    

    多个文件进行打包

    		ZipUtil.zip(FileUtil.file("d:/bbb/ccc.zip"), false, 
    		FileUtil.file("d:/test1/file1.txt"),
     		FileUtil.file("d:/test1/file2.txt"),
      		FileUtil.file("d:/test2/file1.txt"),
      	    FileUtil.file("d:/test2/file2.txt")
    		);
    

    解压

    		//将test.zip解压到e:\\aaa目录下,返回解压到的目录
    		File unzip = ZipUtil.unzip("E:\\aaa\\test.zip", "e:\\aaa");
    

    身份证工具

    主要方法为:

    • 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");
    
    		//年龄
    		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");
    
    		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, "内蒙古");
    

    声明本次数据摘自HuTool官网,为随即编造,如有雷同,纯属巧合。

    集合类

    集合工具

    转为字符串

    第二个参数为连接符

    		String[] col= new String[]{"l","o","l","l","y"};
    		List<String> colList = CollUtil.newArrayList(col);
    
    		String str = CollUtil.join(colList, "#"); 
    		// l#o#l#l#y
    		System.out.println(str);
    

    分页

    		//Integer比较器
    		Comparator<Integer> comparator = new Comparator<Integer>(){
    		    @Override
    		    public int compare(Integer o1, Integer o2) {
    		        return o1.compareTo(o2);
    		    }
    		};
    
    		//新建三个列表,CollUtil.newArrayList方法表示新建ArrayList并填充元素
    		List<Integer> list1 = CollUtil.newArrayList(1, 2, 3);
    		List<Integer> list2 = CollUtil.newArrayList(4, 5, 6);
    		List<Integer> list3 = CollUtil.newArrayList(7, 8, 9);
    
    		//参数表示把list1,list2,list3合并并按照从小到大排序后,取0~2个(包括第0个,不包括第2个),结果是[1,2]
    		@SuppressWarnings("unchecked")
    		List<Integer> result = CollUtil.sortPageAll(0, 2, comparator, list1, list2, list3);
    		System.out.println(result);     //输出 [1,2]
    

    可能接触时间有点少,没读太懂,直接略过了。

    创建容器

    	HashMap<String, String> map = CollUtil.newHashMap();
    	HashSet<String> set = CollUtil.newHashSet();
    	ArrayList<String> list = CollUtil.newArrayList();
    

    添加元素

    		CollUtil.setOrAppend(list, 0, "1");
    		System.out.println(list);
    

    调整数据大小

    		List<String> list5 = CollUtil.reverse(list);
    

    没有搞懂改变List大小有啥用。。。,希望有会的指点一下

    合并数组

    		List<String> list4 = new ArrayList<>();
    		List<String> list6 = new ArrayList<>();
    		list4.add("lolly");
    		list6.add("lolly1023");
     		CollUtil.addAll(list4, list6);
     		// [lolly, lolly1023]
    		System.out.println(list4);
    

    截取数组

    		// [lolly]
    		System.out.println(CollUtil.sub(list4, 0, 1));
    

    判断是否为空

    		// false
    		System.out.println(CollUtil.isEmpty(list4));
    		// true
    		System.out.println(CollUtil.isNotEmpty(list4));
    

    集合生成Map

    源自python语法糖

    		Collection<String> keys = CollUtil.newArrayList("a", "b", "c", "d");
    		Collection<Integer> values = CollUtil.newArrayList(1, 2, 3, 4);
    
    		// {a=1,b=2,c=3,d=4}
    		Map<String, Integer> map = CollUtil.zip(keys, values);
    

    过滤方法

    此方法可以过滤掉map中不需要的key
    举例:

    		@Test
    		public void CollUtil_Filter() {
        		Map<String, Object> m = new HashMap<String, Object>() {{
            		put("k1", "v1");
            		put("k2", "v2");
            		put("k3", "v3");
        		}};
        		String[] inc = {"k1", "k3"};//需要的key
        		List<String> incList = Arrays.asList(inc);
        		m = CollectionUtil.filter(m, new Editor<Map.Entry<String, Object>>() {
            		@Override
            		public Map.Entry<String, Object> edit(Map.Entry<String, Object> stringObjectEntry) {
                		if (incList.contains(stringObjectEntry.getKey())) {
                    		return stringObjectEntry;
                		}
                		return null;
            		}
        		});
        		log.info("{}", m);
    		}
    

    控制台输出

    {k3=v3, k1=v1}
    

    列表工具

    过滤列表

    对每一个元素进行过滤

    		List<String> a = ListUtil.toLinkedList("1", "2", "3");
    		// 结果: [edit1, edit2, edit3]
    		List<String> filter = ListUtil.filter(a, str -> "edit" + str);
    

    获取满足规则元素下标

    		List<String> a = ListUtil.toLinkedList("1", "2", "3", "4", "3", "2", "1");
    		// [1, 5]
    		int[] indexArray = ListUtil.indexOfAll(a, "2"::equals);
    

    Iterator工具

    基本方法

    • isEmpty 是否为null或者无元素
    • isNotEmpty 是否为非null或者至少一个元素
    • hasNull 是否有null元素
    • isAllNull 是否全部为null元素
    • countMap 根据集合返回一个元素计数的Map,所谓元素计数就是假如这个集合中某个元素出现了n次,那将这个元素做为key,n做为value
    • join 使用分隔符将集合转换为字符串
    • toMap toMap Entry列表转Map,或者key和value单独列表转Map
    • asIterator EnumerationIterator
    • asIterable IteratorIterable
    • getFirst 获取列表的第一个元素
    • getElementType 获取元素类型

    Map

    Map工具

    行转列

    如若map中的数据为:

    [
      {a: 1, b: 1, c: 1},
      {a: 2, b: 2},
      {a: 3, b: 3},
      {a: 4}
    ]
    

    则使用toListMap之后变为:

    {
       a: [1,2,3,4],
       b: [1,2,3,],
       c: [1]
    }
    

    列转行

    如若map中的数据为:

    {
       a: [1,2,3,4],
       b: [1,2,3,],
       c: [1]
    }
    

    则使用toMapList之后变为:

    [
      {a: 1, b: 1, c: 1},
      {a: 2, b: 2},
      {a: 3, b: 3},
      {a: 4}
    ]
    

    转为字符串

    joinjoinIgnoreNullsortJoin将Map按照给定的分隔符转换为字符串,此方法一般用于签名。

    Map<String, String> build = MapUtil.builder(new HashMap<String, String>())
        .put("key1", "value1")
        .put("key3", "value3")
        .put("key2", "value2").build();
    
    // key1value1key2value2key3value3
    String join1 = MapUtil.sortJoin(build, StrUtil.EMPTY, StrUtil.EMPTY, false);
    // key1value1key2value2key3value3123
    String join2 = MapUtil.sortJoin(build, StrUtil.EMPTY, StrUtil.EMPTY, false, "123");
    

    过滤方法

    举例:

    Map<String, String> map = MapUtil.newHashMap();
    map.put("a", "1");
    map.put("b", "2");
    map.put("c", "3");
    map.put("d", "4");
    
    Map<String, String> map2 = MapUtil.filter(map, (Filter<Entry<String, String>>) t -> Convert.toIn(t.getValue()) % 2 == 0);
    

    结果为:

    {
       b: "2",
       d: "4"
    }
    

    key和value互换

    举例:

    Map<String, String> map = MapUtil.newHashMap();
            map.put("a", "1");
            map.put("b", "2");
            map.put("c", "3");
            map.put("d", "4");
    
    Map<String, String> map2 = MapUtil.reverse(map);
    

    结果为:

    {
       "1": "a",
       "2": "b",
       "3": "c",
       "4": "d",
    }
    

    BiMap

    BiMap,它实现了一种双向查找的功能,即根据key查找value和根据value查找key,Hutool也同样提供此对象。

    基本使用

    BiMap<String, Integer> biMap = new BiMap<>(new HashMap<>());
    biMap.put("aaa", 111);
    biMap.put("bbb", 222);
    
    // 111
    biMap.get("aaa");
    // 222
    biMap.get("bbb");
    
    // aaa
    biMap.getKey(111);
    // bbb
    biMap.getKey(222);
    

    TableMap

    TableMap这类数据结构,通过键值单独建立List方式,使键值对一一对应,实现正向和反向两种查找。

    基本使用

    TableMap<String, Integer> tableMap = new TableMap<>(new HashMap<>());
    tableMap.put("aaa", 111);
    tableMap.put("bbb", 222);
    
    // 111
    tableMap.get("aaa");
    // 222
    tableMap.get("bbb");
    
    // aaa
    tableMap.getKey(111);
    // bbb
    tableMap.getKey(222);
    
    // [111]
    tableMap.getValues("aaa");
    
    //[aaa]
    tableMap.getKeys(111);
    

    Codec编码

    Base62编码解码

    		String a = "Base62";
    
    		// KixpUr22
    		String encode = Base62.encode(a);
    		System.out.println(encode);
    		// 还原为Base62
    		String decodeStr = Base62.decodeStr(encode);
    		System.out.println(decodeStr);
    

    Base64编码解码

    		String a = "Base64";
    
    		// QmFzZTY0
    		String encode = Base64.encode(a);
    		System.out.println(encode);
    		// 还原为Base64
    		String decodeStr = Base64.decodeStr(encode);
    		System.out.println(decodeStr);
    

    Base32编码解码

    		String a = "Base32";
    
    		// IJQXGZJTGI
    		String encode = Base32.encode(a);
    		System.out.println(encode);
    		// 还原为Base32
    		String decodeStr = Base32.decodeStr(encode);
    		System.out.println(decodeStr);
    

    文本操作

    StrBuilder

    在JDK提供的StringBuilder中,拼接字符串变得更加高效和灵活,但是生成新的字符串需要重新构建StringBuilder对象,造成性能损耗和内存浪费,因此Hutool提供了可复用的StrBuilder。

    摘自HuTool官网

    基本使用

    		StrBuilder builder = StrBuilder.create();
    		builder.append("lolly").append("1023").append('!');
    		// lolly1023!
    		System.out.println(builder);
    

    对比StringBuilder来说,性能几乎提升一倍之高。

    Unicode编码转换工具

    字符串转Unicode符

    		//第二个参数true表示跳过ASCII字符(只跳过可见字符)
    		String s = UnicodeUtil.toUnicode("lolly1023中文", true);
    		// lolly1023\u4e2d\u6587
    		System.out.println(s);
    

    Unicode转字符串

    		String str = "lolly1023\u4e2d\u6587";
    		String res = UnicodeUtil.toString(str);
    		// lolly1023中文
    		System.out.println(res);
    

    比较器

    版本比较器

    		// 1.2.1 < 1.12.1,返回-1
    		System.out.println(VersionComparator.INSTANCE.compare("1.2.1", "1.12.1"));
    
    		// 1.12.1 < 1.12.1c,返回-1
    		System.out.println(VersionComparator.INSTANCE.compare("1.12.1", "1.12.1c"));
    
    		// V0.0.20170102 > V0.0.20170101,返回1
    		System.out.println(VersionComparator.INSTANCE.compare("V0.0.20170102", "V0.0.20170101"));
    

    其它比较器

    • ReverseComparator 反转比较器,排序时提供反序
    • VersionComparator 版本比较器,支持如:1.3.20.8,6.82.20160101,8.5a/8.5c等版本形式
    • PropertyComparator Bean属性比较器,通过Bean的某个属性来对Bean对象进行排序
    • IndexedComparator 按照数组的顺序正序排列,数组的元素位置决定了对象的排序先后
    • ComparatorChain 比较器链。此链包装了多个比较器,最终比较结果按照比较器顺序综合多个比较器结果。
    • PinyinComparator 按照GBK拼音顺序对给定的汉字字符串排序。

    异常

    基本方法

    • getMessage 获得完整消息,包括异常名
    • wrap 包装一个异常为指定类型异常
    • wrapRuntime 使用运行时异常包装编译异常
    • getCausedBy 获取由指定异常类引起的异常
    • isCausedBy 判断是否由指定异常类引起
    • stacktraceToString 堆栈转为完整字符串

    其他方法请参考API文档:API文档

    其它异常封装

    • DependencyException 依赖异常
    • StatefulException 带有状态码的异常
    • UtilException 工具类异常
    • NotInitedException 未初始化异常
    • ValidateException 验证异常

    图片

    图片工具

    缩放图片

    		ImgUtil.scale(
    				FileUtil.file("d:/桌面/石原里美.jpg"), 
    				FileUtil.file("d:/桌面/石原里美缩小版.jpg"),
    				0.5f// 缩放比例
    		);
    

    剪裁图片

    		ImgUtil.cut(
    			    FileUtil.file("d:/桌面/石原里美.jpg"), 
    			    FileUtil.file("d:/桌面/石原里美剪裁版.jpg"), 
    			    new Rectangle(200, 200, 200, 200)//裁剪的矩形区域
    		);
    

    分成行列剪裁

    		ImgUtil.slice(
    				FileUtil.file("d:/桌面/石原里美.jpg"), 
    				FileUtil.file("d:/桌面/石原里美"),
    				2, 
    				2
    		);
    

    图片类型转换

    		ImgUtil.convert(
    				FileUtil.file("d:/桌面/石原里美.jpg"), 
    				FileUtil.file("d:/桌面/石原里美.png")
    		);
    

    图片转为黑白

    		ImgUtil.gray(
    				FileUtil.file("d:/桌面/石原里美.jpg"), 
    				FileUtil.file("d:/桌面/石原里美黑白版.jpg")
    		);
    

    添加文字水印

    		ImgUtil.pressText(//
    			    FileUtil.file("d:/桌面/石原里美.jpg"), //
    			    FileUtil.file("d:/桌面/石原里美水印版.jpg"), //
    			    "lolly1023", Color.WHITE, //文字
    			    new Font("黑体", Font.BOLD, 100), //字体
    			    0, //x坐标修正值。 默认在中间,偏移量相对于中间偏移
    			    0, //y坐标修正值。 默认在中间,偏移量相对于中间偏移
    			    0.8f//透明度:alpha 必须是范围 [0.0, 1.0] 之内(包含边界值)的一个浮点数字
    		);
    

    添加图片水印

    		ImgUtil.pressImage(
    			    FileUtil.file("d:/桌面/石原里美.jpg"), 
    			    FileUtil.file("d:/桌面/石原里美图片水印版.jpg"), 
    			    ImgUtil.read(FileUtil.file("d:/桌面/石原里美.jpg")), //水印图片
    			    0, //x坐标修正值。 默认在中间,偏移量相对于中间偏移
    			    0, //y坐标修正值。 默认在中间,偏移量相对于中间偏移
    			    0.1f
    		);
    

    旋转图片

    		// 旋转180度
    		BufferedImage image = (BufferedImage) ImgUtil.rotate(ImageIO.read(FileUtil.file("d:/桌面/石原里美.jpg")), 180);
    		ImgUtil.write(image, FileUtil.file("d:/桌面/石原里美旋转版.jpg"));
    

    水平翻转图片

    	ImgUtil.flip(
    				FileUtil.file("d:/桌面/石原里美.jpg"), 
    				FileUtil.file("d:/桌面/石原里美翻转版.jpg")
    		);
    

    图片编辑器

    图像切割

    		Img.from(
    				FileUtil.file("d:/桌面/石原里美.jpg"))
    	    		.cut(0, 0, 200)//
    	    		.write(FileUtil.file("d:/桌面/石原里美切割版.jpg")
    	    );
    

    图片压缩

    图片压缩只支持jpg文件

    		Img.from(
    				FileUtil.file("d:/桌面/石原里美.jpg"))
    	    		.setQuality(0.5)//压缩比率
    	    		.write(FileUtil.file("d:/桌面/石原里美压缩版.jpg")
    	    );
    

    HuTool暂未学完,持续更新

    本文的所有代码均已上传GitHub,HuTool学习

    学习交流q群:470464545,大家一起学习进步,CSDN博客:lolly1023

    展开全文
  • hutool介绍

    千次阅读 多人点赞 2021-05-25 12:46:58
    Hutool是一个小而全的Java工具类库,通过静态方法封装,降低相关API的学习成本,提高工作效率,使Java拥有函数式语言般的优雅,让Java语言也可以“甜甜的”。 Hutool中的工具方法来自每个用户的精雕细琢,它涵盖了...
  • Hutool欢迎任何人为Hutool添砖加瓦,贡献代码,不过维护者是一个强迫症患者,为了照顾病人,需要提交的pr(pull request)符合一些规范,规范如下: 注释完备,尤其每个新增的方法应按照Java文档规范标明方法说明、...
  • hutool文档pdf

    2020-10-20 00:54:53
    hutool工具包上部分,自己转化的pdf
  • Hutool主页及文档项目 技术选型 主页为纯HTML,只有一个index.html(模板来自网上修改) 文档位于docs文件夹下,纯静态,基于构建。 资源和托管 主页和文档的页面托管于,域名hutool.cn自己持有。 图片、CSS、JS文件...
  • Hutool源代码

    2021-03-15 15:54:06
    Hutool是一个Java基础工具类,对文件、流、加密解密、转码、正则、线程、XML等JDK方法进行封装,组成各种Util工具类,同时提供以下组件: 布隆过滤 缓存 克隆接口 类型转换 日期处理 数据库ORM(基于ActiveRecord...
  • hutool.zip

    2020-07-16 13:58:40
    hutool是一个java基础工具类,该工具类经过长期的发展,API已经非常齐全,涵盖了字符串操作,数据库,网络json等各种方法.
  • Hutool v4.0.12

    2020-10-13 00:17:39
    Hutool是一个Java基础工具类,对文件、流、加密解密、转码、正则、线程、XML等JDK方法进行封装,组成各种Util工具类,同时提供以下组件: 布隆过滤 缓存 克隆接口 类型转换 日期处理
  • Hutool v4.0.11

    2020-10-12 23:10:37
    Hutool是一个Java基础工具类,对文件、流、加密解密、转码、正则、线程、XML等JDK方法进行封装,组成各种Util工具类,同时提供以下组件: 布隆过滤 缓存 克隆接口 类型转换 日期处理
  • Hutool.rar

    2019-11-18 09:25:14
    Hutool是一个Java工具包,也只是一个工具包,它帮助我们简化每一行代码,减少每一个方法,让Java语言也可以“甜甜的”。Hutool最初是我项目中“util”包的一个整理,后来慢慢积累并加入更多非业务相关功能,并广泛...
  • hutool.rar

    2020-05-22 10:57:23
    Hutool是一个Java工具包,也只是一个工具包,它帮助我们简化每一行代码,减少每一个方法,让Java语言也可以“甜甜的”
  • hutool 文档

    千次阅读 2020-05-08 10:01:58
    hutool使用 官网:https://hutool.cn/docs/#/ 就是很多工具类汇合到一起,更加方便实用! jar <dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> ...
  • Hutool 参考文档

    2019-03-21 19:40:15
    Hutool 4.5.1帮助文档,从官网下载的然后使用工具制作的chm格式的离线帮助文档,希望对大家有用
  • hutool官方文档

    2018-09-21 11:32:31
    hutool工具类官方文档,集成该工具类的项目可以参考该文档,进行使用。
  • 初识Hutool

    2019-11-01 16:05:22
    Hutool是一个Java工具包,也只是一个工具包,它帮助我们简化每一行代码,减少每一个方法,让Java语言也可以“甜甜的”。 Hutool是一个Java工具包类库,对文件、流、加密解密、转码、正则、线程、XML等JDK方法进行...
  • Hutool使用

    2021-06-16 15:31:46
    Hutool使用1、简介2、入门和安装3、 部分Util的使用Demo 1、简介 Hutool是一个小而全的Java工具类库,通过静态方法封装,降低相关API的学习成本,提高工作效率。 Hutool是项目中“util”包友好的替代,它节省了开发...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,460
精华内容 6,984
关键字:

hutool