HuTool工具超详细笔记

HuTool工具超详细笔记

      HuTool是一个小而全的Java工具类库，通过静态方法封装，降低相关API的学习成本，提高工作效率，它涵盖了Java开发底层代码中的方方面面；

1、Hutool官网

https://www.hutool.cn/docs/#/

API：https://apidoc.gitee.com/dromara/hutool/

HuTool提供了以下组件

2、HuTool环境的搭建

在pom.xml中加入依赖

• hutool-all是引用全部模块
• 还可以单独引入所需要的模块（hutool-aop、hutool-core、hutool-db、hutool-http…详见官方文档： https://www.hutool.cn/docs/#/

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

3、HuTool的使用

      HuTool中对很多方法进行了封装，组成各种Util工具类，下面就分享我经常使用的一部分，具体还请看官网，仅作参考；

3.1、类型转换工具类-Convert

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

 //1.转换为字符串
String iStr = Convert.toStr(1);
//2.转换为Integer数组
String[] b = {"1", "2", "3", "4"};
Integer[] integers = Convert.toIntArray(b);
//3.转换为日期对象,快速格式化时间；添加默认值（用于转化失败时的默认值）
Date date = Convert.toDate("2021-10-20", new Date());
//4.数字转换
//数字转英文
String numberToWord = Convert.numberToWord(123);//ONE HUNDRED AND TWENTY THREE ONLY
//数字简化
String s2 = Convert.numberToSimple(18300);//1.83w
//数字转中文
String numberToChinese = Convert.numberToChinese(54, true);//伍拾肆
String numberToChineseNow = Convert.numberToChinese(54, false);//五十四
//5.转换为集合
Object[] arr = {"a", "你", "好", "", 1};
List<?> list = Convert.toList(arr);
//6.半角转全角
String s = Convert.toSBC("123456789");//１２３４５６７８９
//7.全角转半角
String s1 = Convert.toDBC("１２３４５６７８９");//123456789
//8.普通字符串转为16进制(因为字符串牵涉到编码问题，因此必须传入编码对象，此处使用UTF-8编码)
String strToHex = Convert.toHex("转换为16进制", CharsetUtil.CHARSET_UTF_8);//e8bdace68da2e4b8ba3136e8bf9be588b6
//9.16进制转为普通字符串
String hexToStr = Convert.hexToStr("e8bdace68da2e4b8ba3136e8bf9be588b6", CharsetUtil.CHARSET_UTF_8);//转换为16进制
//10.Unicode和字符串的转换
String strToUnicode = Convert.strToUnicode("Unicode和字符串的转换");//Unicode\u548c\u5b57\u7b26\u4e32\u7684\u8f6c\u6362
String unicodeToStr = Convert.unicodeToStr("Unicode\\u548c\\u5b57\\u7b26\\u4e32\\u7684\\u8f6c\\u6362");//Unicode和字符串的转换
//11.编码转换(UTF-8编码后用GBK解码再用GBK编码后用UTF-8解码会存在某些中文转换失败的问题)
String str = "编码转换";
//将UTF_8转为ISO_8859_1
String result = Convert.convertCharset(str, CharsetUtil.UTF_8, CharsetUtil.ISO_8859_1);//ç¼–ç è½¬æ¢
String raw = Convert.convertCharset(result, CharsetUtil.ISO_8859_1, "UTF-8");//编码转换
//12.转换时间(毫秒转换为分)
long millisecondsToMinutes = Convert.convertTime(123456789, TimeUnit.MILLISECONDS, TimeUnit.MINUTES);//2057
long minutesToMilliseconds = Convert.convertTime(10, TimeUnit.MINUTES, TimeUnit.MILLISECONDS);//600000
//13.转换为指定类型
Object o = Convert.convertQuietly(float.class, 9);

3.2、日期时间

日期时间是提供针对JDK中Date和Calendar对象的封装；

3.2.1、日期时间工具-DateUtil

这其中的封装主要是日期和字符串之间的转换，以及提供对日期的定位（一个月前等）；

/*1.Date、long、Calendar之间的相互转换*/
//当前时间
DateTime date1 = DateUtil.date();
DateTime date2 = DateUtil.date(Calendar.getInstance());
Date date3 = DateUtil.date(System.currentTimeMillis());
//当前时间字符串，格式：yyyy-MM-dd HH:mm:ss
String now = DateUtil.now();
//当前日期字符串，格式：yyyy-MM-dd
String today = DateUtil.today();
/*2.字符串转日期*/
String dateStr = "2021-10-21 18:00:01";
Date date = DateUtil.parse(dateStr, "yyyy-MM-dd HH:mm:ss");
/*3.格式化日期输出*/
String d = "2021-10-21 18:27:01";
Date parse = DateUtil.parse(d);//2021-10-21 00:00:00
//定义的样式
String format = DateUtil.format(parse, "yyyy/MM/dd"); //2021/10/21
//常用格式的格式化
String formatDate = DateUtil.formatDate(parse); //2021-10-21
//时间
String formatDateTime = DateUtil.formatDateTime(parse);//2021-10-21 18:27:01
//时分秒
String formatTime = DateUtil.formatTime(parse);//18:27:01
/*4.获取Date对象的某个部分*/
//获得年
int year = DateUtil.year(date1);//2021
//获得月（从0开始）
int month = DateUtil.month(date1);//9
//获得月份枚举
Month monthEnum = DateUtil.monthEnum(date1);//OCTOBER
/*5.开始和结束时间*/
//一天的开始
DateTime beginOfDay = DateUtil.beginOfDay(date);//2021-10-21 00:00:00
//一天的结束时间
DateTime endOfDay = DateUtil.endOfDay(date);//2021-10-21 23:59:59
/*6.日期时间偏移*/
//偏移两天
Date newDate = DateUtil.offset(date, DateField.DAY_OF_MONTH, 2); //2021-10-23 18:00:01
//后偏移3天
DateTime newDate2 = DateUtil.offsetDay(date, 3); //2021-10-24 18:00:01
//前偏移3小时
DateTime newDate3 = DateUtil.offsetHour(date, -3); //2021-10-21 15:00:01
//昨天
DateTime yesterday = DateUtil.yesterday();
//明天
DateTime tomorrow = DateUtil.tomorrow();
//上周
DateTime lastWeek = DateUtil.lastWeek();
//下月
DateTime nextMonth = DateUtil.nextMonth();
/*7.时间差*/
long between = DateUtil.between(date, DateUtil.parse("2021-10-01 00:00:01"), DateUnit.DAY);//20
/*8.星座、属相、年龄、是否闰年*/
String zodiac = DateUtil.getZodiac(Month.FEBRUARY.getValue(), 19);//双鱼座
String chineseZodiac = DateUtil.getChineseZodiac(2002);//马
int age = DateUtil.ageOfNow("2002-05-21");//19
boolean leapYear = DateUtil.isLeapYear(2021);//false

3.2.2、日期时间对象-DateTime

DateTime类继承于java.util.Date类，为Date类扩展了众多简便方法，这些方法多是DateUtil静态方法的对象表现形式，使用DateTime对象可以完全替代开发中Date对象的使用。

//使用对象获取日期成员的年、月、日
DateTime dateTime = new DateTime("2021-01-05 12:34:23", DatePattern.NORM_DATETIME_FORMAT);
int year = dateTime.year();//2021
//月份
Month month = dateTime.monthEnum();//JANUARY
//日
int dayOfMonth = dateTime.dayOfMonth();//5
//格式化为字符串
String toString = dateTime.toString();

3.2.3、农历日期-ChineseDate

农历日期，提供生效、天干地支、传统节日等方法；

//通过农历构建
ChineseDate chineseDate = new ChineseDate(2002, 05, 21);
//通过公历构建
ChineseDate chineseDate1 = new ChineseDate(DateUtil.parseDate("2002-01-21"));
String chineseMonth = chineseDate.getChineseMonth();//一月
String chineseMonthName = chineseDate.getChineseMonthName();//正月
// 初一
String chineseDay = chineseDate.getChineseDay();
String cyclical = chineseDate.getCyclical();// 壬午
//生肖
String chineseZodiac = chineseDate.getChineseZodiac();//马
// 传统节日
String festivals = chineseDate.getFestivals();
// 天干地支，生肖、农历
String all = chineseDate.toString();//壬午马年 五月廿一
//天干地支
String cyclicalYMD = chineseDate.getCyclicalYMD();//壬午年丙午月庚午日

3.2.4、计时器工具

计时器功计算方法或过程执行的时间

TimeInterval timer = DateUtil.timer();
/**
* 代码执行过程
 */
ThreadUtil.sleep(100);
//花费毫秒数
long interval = timer.interval();
//返回花费时间，并重置开始时间
timer.intervalRestart();
//花费分钟数
timer.intervalMinute();

3.3、工具类

3.3.1、字符串工具-StrUtil

String str = "abCDEfghi";
//是否为空
boolean blank = StrUtil.isBlank(str);//false
//是否不为空
boolean notBlank = StrUtil.isNotBlank(str);//true
//去掉字符串后缀（removeprefix：前缀）
String removeSuffix = StrUtil.removeSuffix("test.txt", ".txt");//test
//忽略大小写去掉前缀(removeSuffixIgnoreCase:去掉后缀)
String removePrefixIgnoreCase = StrUtil.removePrefixIgnoreCase(str, "A");//bCDEfghi
//sub方法
//顺数第2个到第4个，包含尾部包含头
String sub = StrUtil.sub(str, 2, 4);//CD
//-3表示倒数第三个字符
String sub1 = StrUtil.sub(str, 2, -3);//CDEf
//format方法（使用字符串模板代替字符串拼接）
String template = "{}爱{}!{}";
String fin = StrUtil.format(template, "我", "JAVA","哈哈哈"); //我爱JAVA!哈哈哈

3.3.2、数字工具

/*数字工具*/
//加
double add = NumberUtil.add(1, 1);//2.0
//减
double sub2 = NumberUtil.sub(3, 1);//2.0
//乘
double mul = NumberUtil.mul(3, 3);//9.0
//除
double div = NumberUtil.div(3, 1);//3.0
//保留小数
BigDecimal round = NumberUtil.round(123456.123456, 4);//123456.1235
//直接舍弃
BigDecimal round1 = NumberUtil.round(123456.123456, 4, RoundingMode.DOWN);//123456.1234
//主要采用四舍五入的方式
String roundStr = NumberUtil.roundStr(123456.123456, 5);//123456.12346
//对decimal进行格式化
//每三位以逗号进行分隔
String decimalFormat = NumberUtil.decimalFormat(",###", 299792458);//299,792,458
//取一位整数
String s = NumberUtil.decimalFormat("0", 2999.12356);//2999
//取一位整数和两位小数
String s1 = NumberUtil.decimalFormat("0.00", 2999.12356);//2999.12
//显示为科学计数法，并取五位小数
String s2 = NumberUtil.decimalFormat("#.#####E0", 299.12356);//2.99124E2
//加入单位
String s3 = NumberUtil.decimalFormat(",###米", 29912356);//29,912,356米
//以百分比方式计数，并取两位小数
String s4 = NumberUtil.decimalFormat("#.##%", 0.272365);//27.24%
//生成不重复随机数(开始数、结束数、随机数数量)
int[] ints = NumberUtil.generateRandomNumber(3, 30, 5);
String s5 = Arrays.toString(ints);//[12, 24, 29, 13, 5]
//包装类型
Integer[] integers = NumberUtil.generateBySet(3, 30, 5);
String s6 = Arrays.toString(integers);//[16, 17, 18, 29, 13]
//整数列表(有序整数列表)
int[] range = NumberUtil.range(3, 30, 5);
String s7 = Arrays.toString(range);//[3, 8, 13, 18, 23, 28]

3.3.3、其他工具类

包含：数组工具、随机工具、身份证工具、脱敏工具、社会信用码

/*运行命令行工具*/
List<String> ipconfig = RuntimeUtil.execForLines("ipconfig");
/*数组工具*/
//判断非空
int[] a = {};
boolean empty = ArrayUtil.isEmpty(a);//true
//判断非空
boolean notEmpty = ArrayUtil.isNotEmpty(a);//false
/*随机工具-RandomUtil*/
//产生10~20的随机数
int randomInt = RandomUtil.randomInt(10, 20);
//获得一个长度为4只包含数字的字符串
String randomNumbers = RandomUtil.randomNumbers(4);
//获得一个随机的字符串（只包含数字和字符）
String randomString = RandomUtil.randomString("123456AbC",7);
/*UUID*/
//生成的是不带-的字符串
String simpleUUID = IdUtil.simpleUUID();
/*身份证工具*/
String idCard = "612703199109010012";
//验证身份证是否合法
boolean validCard = IdcardUtil.isValidCard(idCard);//true
//获取生日
String birthByIdCard = IdcardUtil.getBirthByIdCard(idCard);//19910901
//获取年龄
int ageByIdCard = IdcardUtil.getAgeByIdCard(idCard);//30
//获取生日年
Short yearByIdCard = IdcardUtil.getYearByIdCard(idCard);//1991
//获取生日月
Short monthByIdCard = IdcardUtil.getMonthByIdCard(idCard);//9
//获取生日天
Short dayByIdCard = IdcardUtil.getDayByIdCard(idCard);//1
//获取性别
int genderByIdCard = IdcardUtil.getGenderByIdCard(idCard);//1
//获取省份
String provinceByIdCard = IdcardUtil.getProvinceByIdCard(idCard);//陕西
/*脱敏工具*/
//身份证号码(前一位后两位)
String idCardNum = DesensitizedUtil.idCardNum(idCard, 1, 2);//6***************12
//手机号
String mobilePhone = DesensitizedUtil.mobilePhone("13912349832");//139****9832
//全部脱敏
String password = DesensitizedUtil.password("123456");//******
//StrUtil(索引为1开始索引为3结束)
String hide = StrUtil.hide("123456", 1, 3);//1**456
/*
* 社会信用码（18位）：
* 第一部分：登记管理部门代码1位 (数字或大写英文字母)
* 第二部分：机构类别代码1位 (数字或大写英文字母)
* 第三部分：登记管理机关行政区划码6位 (数字)
* 第四部分：主体标识码（组织机构代码）9位 (数字或大写英文字母)
* 第五部分：校验码1位 (数字或大写英文字母)
*/
//随机生成社会信用码
String randomCreditCode = CreditCodeUtil.randomCreditCode();//B6123727GNXBQA6FRJ
//校验
boolean creditCode = CreditCodeUtil.isCreditCode(randomCreditCode);//true

3.4、语言特性

/*HashMap扩展-Dict*/
//通过链式构造，创建Dict对象
Dict dict = Dict.create()
    .set("key1", 1)//int
    .set("key2", 1000L)//long
    .set("key3", DateTime.now());//Date
Long v2 = dict.getLong("key1");//1
System.out.println(v2);
/*打印封装*/
String[] a = {"abc", "bcd", "def"};
Console.log(a);//[abc, bcd, def]
Console.error("错误信息！");//错误信息！
/*字段验证器*/
//验证给定字符串是否为邮箱格式
boolean email = Validator.isEmail("123@163.com");//true
//是否是社会信用码
boolean isCreditCode = Validator.isCreditCode("B6123727GNXBQA6FRJ");//true
//是否是中文
boolean hasChinese = Validator.hasChinese("1212");//false
//是否是数字
boolean hasNumber = Validator.hasNumber("2314");//true
//自定义正则然后验证(纯数字)
boolean matchRegex = Validator.isMatchRegex("^[0-9]*$", "12");//true
//异常验证（当不是中文时抛出异常）
//String s = Validator.validateChinese("1212", "内容非中文！");
/*字符串格式化*/
String result1 = StrFormatter.format("this is {} for {}", "a", "b");//this is a for b
//转义{}
String result2 = StrFormatter.format("this is \\{} for {}", "a", "b");//this is {} for a
//转义\
String result3 = StrFormatter.format("this is \\\\{} for {}", "a", "b");//this is \a for b
//树形结构
// 构建node列表
List<TreeNode<String>> nodeList = CollUtil.newArrayList();

nodeList.add(new TreeNode<>("1", "0", "系统管理", 5));
nodeList.add(new TreeNode<>("11", "1", "用户管理", 222222));
nodeList.add(new TreeNode<>("111", "11", "用户添加", 0));
nodeList.add(new TreeNode<>("2", "0", "店铺管理", 1));
nodeList.add(new TreeNode<>("21", "2", "商品管理", 44));
nodeList.add(new TreeNode<>("221", "2", "商品管理2", 2));

// 0表示最顶层的id是0
List<Tree<String>> treeList = TreeUtil.build(nodeList, "0");
/*
[店铺管理[2]
  商品管理2[221]
  商品管理[21]
, 系统管理[1]
用户管理[11]
  用户添加[111]
]
* */
Console.log(treeList);

3.5、集合类

集合包中封装了包括Enumeration、Iterator等的包装

3.5.1、集合工具-CollUtil

主要增加了对数组、集合类的操作

String[] col = new String[]{"a", "b", "c", "d", "e"};
//集合转换为字符串，是StrUtil.split()的反方法
List<String> colList = CollUtil.newArrayList(col);
//给集合里追加一个元素
colList.add("f");
String str = CollUtil.join(colList, "#"); //a#b#c#d#e#f
//是否为空
boolean empty = colList.isEmpty();//false
//给定两个集合，然后两个集合中的元素一一对应，成为一个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);//{a=1, b=2, c=3, d=4}

3.5.2、列表工具-ListUtil

//获取满足指定规则所有的元素的位置
List<String> a = ListUtil.toLinkedList("1", "2", "3", "4", "3", "2", "1");
int[] indexArray = ListUtil.indexOfAll(a, "1"::equals);//[0, 6]
//拆分（对集合按照指定长度分段，每一个段为单独的集合，返回这个集合的列表）
List<List<Object>> lists = ListUtil.split(Arrays.asList(1, 2, 3, 4), 2);//[[1, 2], [3, 4]]
//平均拆分
List<List<Object>> split = ListUtil.splitAvg(Arrays.asList(1, 2, 3, 4), 2);//[[1, 2], [3, 4]]
lists = ListUtil.splitAvg(Arrays.asList(1, 2, 3, 4), 3);//[[1, 2], [3], [4]]
//编辑元素
LinkedList<String> strings = ListUtil.toLinkedList("1", "2", "3");
final List<String> filter = (List<String>) CollUtil.edit(strings, str1 -> "edit" + str1);//[edit1, edit2, edit3]
//列表截取
final List<Integer> of = ListUtil.of(1, 2, 3, 4, 5, 6);//[1, 2, 3, 4, 5, 6]
//从索引为2开始截取到4
final List<Integer> sub = ListUtil.sub(of, 2, 5);//[3, 4, 5]
// 对子列表操作不影响原列表
sub.remove(0);//[4, 5]
//反转
List<String> reverse = ListUtil.reverse(strings);//[3, 2, 1]
//新建ArrayList
ArrayList<String> stringss = ListUtil.toList("21","都与偶i","dsf","欧赔");
stringss.add("二");
stringss.add("ewq");
stringss.add("换个");//[21, 都与偶i, dsf, 欧赔, 二, ewq, 换个]
//根据汉字的拼音顺序排序
ListUtil.sortByPinyin(stringss);//[21, dsf, ewq, 都与偶i, 二, 换个, 欧赔]
//将对应List转换为不可修改的List
List<String> unmodifiable = ListUtil.unmodifiable(stringss);
unmodifiable.remove(0);//报错不可修改

3.5.3、Iterator工具-IterUtil

//新建ArrayList
ArrayList<String> arrayList = ListUtil.toList(null, "都与偶i", "", "欧赔");
//获取列表的第一个元素
Object first = IterUtil.getFirst(arrayList);//null
//获取元素类型
Class<?> elementType = IterUtil.getElementType(arrayList);//class java.lang.String
//第一个非null
String firstNoneNull = IterUtil.getFirstNoneNull(arrayList);//都与偶i
//是否有null元素
boolean hasNull = IterUtil.hasNull(arrayList);//true
//是否全部为null
boolean allNull = IterUtil.isAllNull(arrayList);//false
//是否为null或者无元素
boolean empty1 = IterUtil.isEmpty(arrayList);//false

3.6、Map

MapUtil是针对Map的一一列工具方法的封装，包括getXXX的快捷值转换方法

//快速创建多种类型的HashMap实例
HashMap<Object, Object> objectObjectHashMap = MapUtil.newHashMap(3, true);
objectObjectHashMap.put("a", "1");
objectObjectHashMap.put("b", "2");
objectObjectHashMap.put("c", "3");
objectObjectHashMap.put("d", "4");
//将一个或多个键值对加入到一个新建的Map中
Map<Object, Object> colorMap = MapUtil.of(new String[][]{{"RED", "#FF0000"}, {"GREEN", "#00FF00"}, {"BLUE", "#0000FF"}});//{RED=#FF0000, GREEN=#00FF00, BLUE=#0000FF}
//是否为空
boolean empty = MapUtil.isEmpty(objectObjectHashMap);//false
//键值互换
Map<Object, Object> reverse = MapUtil.reverse(objectObjectHashMap);//{1=a, 2=b, 3=c, 4=d}
//获取指定类型的值
Object a = MapUtil.get(objectObjectHashMap, "c", String.class);//3
/*
* 双查找功能--BiMap
* 要求key和value都不能重复（非强制要求）
* 如果key重复了，后加入的键值对会覆盖之前的键值对
* 如果value重复了，则会按照不确定的顺序覆盖key
* HashMap无序（按照hash顺序），则谁覆盖谁和hash算法有关；
* 如果是LinkedHashMap，则有序，是后加入的覆盖先加入的
*/
BiMap<String, Integer> biMap = new BiMap<>(new HashMap<>());
biMap.put("aaa", 111);
biMap.put("bbb", 222);
Integer aaa = biMap.get("aaa");//111
String key = biMap.getKey(222);//bbb
/*可重复键值Map-TableMap
*通过键值单独建立List方式，使键值对一一对应，实现正向和反向两种查找
*数据越多越慢
*/
TableMap<String, Integer> tableMap = new TableMap<>(5);
tableMap.put("aaa", 111);
tableMap.put("bbb", 222);//TableMap{keys=[aaa, bbb], values=[111, 222]}
Integer aaa1 = tableMap.get("aaa");//111
String key1 = tableMap.getKey(222);//bbb
List<Integer> aaa2 = tableMap.getValues("aaa");//[111]
List<String> keys = tableMap.getKeys(111);//[aaa]

3.7、Code编码

包含常用编码方式的编码和解码

3.7.1、Base62编码解码-Base62

Base62编码是由10个数字、26个大写英文字母和26个小写英文字母组成，多用于安全领域和短URL生成

/*Base62编码解码-Base62*/
String str = "http://www.hao123.com/net?3306";
//编码
String encode = Base62.encode(str);//1S4kP7RyGjrqI1dXQYPlfpWeb3FlOwa6LpFnfBQta
//解码
String decodeStr = Base62.decodeStr(encode);//http://www.hao123.com/net?3306

3.7.2、Base64编码解码-Base64

Base64编码是用64（2的6次方）个ASCII字符来表示256（2的8次方）个ASCII字符，也就是三位二进制数组经过编码后变为四位的ASCII字符显示，长度比原来增加1/3

/*Base64编码解码-Base64*/
//编码
String encode1 = Base64.encode(str);//aHR0cDovL3d3dy5oYW8xMjMuY29tL25ldD8zMzA2
//解码
String decodeStr1 = Base64.decodeStr(encode1);//http://www.hao123.com/net?3306

3.7.3、回转N位密码-Rot

回转N位密码-Rot这里是回转13位是一种简易的置换暗码：下图是对照表

/*回转N位密码-Rot(RotN（rotate by N places），回转N位密码，是一种简易的替换式密码)*/
//编码（回转13位）
String encode13 = Rot.encode13(str);//uggc://jjj.unb456.pbz/arg?6639
// 解码
String decode13 = Rot.decode13(encode13);//http://www.hao123.com/net?3306

3.8、拆分字符串（StrSplitter）

String str = "a, ,efedsfs,   ddf";
//参数：被切分字符串，分隔符逗号，0表示无限制分片数，去除两边空格，忽略空白项
List<String> split = StrSplitter.split(str, ',', 0, true, true);//[a, efedsfs, ddf]
//拆分以“/”分割
String str1 = "https://blog.csdn.net/weixin_42601136";
List<String> strings = StrSplitter.splitPath(str1,'0');//[https:, blog.csdn.net, weixin_42601136]
//长度为3，截取长度字符串
String[] strings1 = StrSplitter.splitByLength(str1, 3);//[htt, ps:, //b, log, .cs, dn., net, /we, ixi, n_4, 260, 113, 6]
//切分字符串，去除每个元素两边空格，忽略大小写
List<String> strings2 = StrSplitter.splitTrimIgnoreCase(str, ",", 0, true);//[a, efedDDsfs, ddf]
//切分字符串为字符串数组
String[] strings3 = StrSplitter.splitToArray(str, ",", 0, true, true);//[a, efedDDsfs, ddf]

3.9、邮箱工具-MainUtil

在Java中发送邮件主要品依靠javax.mail包，但是由于使用比较繁琐，因此Hutool针对其做了封装

3.9.1、引入依赖

<dependency>
    <groupId>com.sun.mail</groupId>
    <artifactId>javax.mail</artifactId>
    <version>1.6.2</version>
</dependency>

3.9.2、实现

MailUtil.send参数：

• tos: 对方的邮箱地址，可以是单个，也可以是多个（Collection表示）
• subject：标题
• content：邮件正文，可以是文本，也可以是HTML内容
• isHtml： 是否为HTML，如果是，那参数3识别为HTML内容
• files： 可选：附件，可以为多个或没有，将File对象加在最后一个可变参数中即可

MailAccount account = new MailAccount();
//邮件服务器的SMTP地址，可选，默认为smtp.<发件人邮箱后缀>
account.setHost("smtp.163.com");
//邮件服务器的SMTP端口，可选，默认25
account.setPort(25);
//默认为true
account.setAuth(true);
//发件人（必须正确，否则发送失败）
account.setFrom("XXXXXX@163.com");
//用户名，默认为发件人邮箱前缀
account.setUser("XXXXXX@163.com");
//密码或者授权码
account.setPass("XXXXXX"); 
String send = null;
try {
    //基础发送
    send = MailUtil.send(account, "XXXXXX@qq.com", "邮件标题", "邮件内容", false);
    //发送HTML邮件并附带附件
    send = MailUtil.send(account, "XXXXXX@qq.com", "致敬立农", "<h1>测试邮件</h1>", true, FileUtil.file("E:/PianAi/myNote/nn.txt"));
    //群法邮件
    ArrayList<String> tos = CollUtil.newArrayList(
        "XXXXXX@qq.com",
        "XXXXXX@qq.com");
    send = MailUtil.send(account,tos, "邮件标题", "邮件来自群发测试", false);
} catch (Exception e) {
    e.printStackTrace();
}
System.out.println(send);

注：

• 163邮箱是授权码不是登录密码
• 在发送时首先打开POP3/SMTP/IMAP

3.10、二维码工具-QrcodeUtil

3.10.1、导入依赖

<dependency>
    <groupId>com.google.zxing</groupId>
    <artifactId>core</artifactId>
    <version>3.3.3</version>
</dependency>

3.10.2、基础二维码

File generate = QrCodeUtil.generate("https://blog.csdn.net/weixin_42601136", 300, 300, FileUtil.file("qrcode.jpg"));

3.10.3、自定义参数

QrConfig config = new QrConfig(300, 300);
// 设置边距，既二维码和背景之间的边距
config.setMargin(3);
// 设置前景色，既二维码颜色（青色）
config.setForeColor(Color.CYAN.getRGB());
// 设置背景色（灰色）
config.setBackColor(Color.GRAY.getRGB());
// 生成二维码到文件，也可以到流
File generate = QrCodeUtil.generate("https://blog.csdn.net/weixin_42601136", config, FileUtil.file("qrcode.jpg"));

3.10.4、附带logo小图标

File generate = QrCodeUtil.generate(
    "https://blog.csdn.net/weixin_42601136", //二维码内容
    QrConfig.create().setImg("e:/111.jpg"), //附带logo
    FileUtil.file("qrcodeWithLogo.jpg")//写出到的文件
);

3.10.5、调整纠错级别

纠错级别使用zxing的ErrorCorrectionLevel枚举封装，包括：L、M、Q、H几个参数，由低到高。

低级别的像素块更大，可以远距离识别，但是遮挡就会造成无法识别。高级别则相反，像素块小，允许遮挡一定范围，但是像素块更密集。

QrConfig qrConfig = new QrConfig();
//高级纠错
config.setErrorCorrection(ErrorCorrectionLevel.L);
File generate = QrCodeUtil.generate("https://blog.csdn.net/weixin_42601136", config, FileUtil.file("qrcodeCustom.jpg"));  

3.10.6、流的形式传给前端

写入response流中返回前端

/**
 * 获取二维码
*/
@GetMapping("/getQRCode")
@ResponseBody
public void getQRCode(HttpServletResponse response) throws IOException {
    String qrCodeUrl = "https://blog.csdn.net/weixin_42601136";
    try {
        QrConfig config = new QrConfig(300, 300);
        config.setMargin(3);
        //高级纠错
        config.setErrorCorrection(ErrorCorrectionLevel.L);
        QrCodeUtil.generate(qrCodeUrl, config, "png", response.getOutputStream());
        log.info("生成二维码成功!");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

<!-- 可用img标签进行接收 -->
<img th:src="xxxurl地址/getQRCode">

3.11、Emoji工具-EmojiUtil

3.11.1、加入依赖

<dependency>
    <groupId>com.vdurmont</groupId>
    <artifactId>emoji-java</artifactId>
    <version>4.0.0</version>
</dependency>

3.11.2、使用

//转Emoji
String alias = EmojiUtil.toAlias("😄");//:smile:
//回转
String emoji = EmojiUtil.toUnicode(":smile:");//😄
//转换为网页的形式
String s = EmojiUtil.toHtml("😄");//😄

3.12、拼音工具-PinyinUtil

3.12.1、引入依赖

<dependency>
    <groupId>io.github.biezhi</groupId>
    <artifactId>TinyPinyin</artifactId>
    <version>2.0.3.RELEASE</version>
</dependency>

3.12.1、使用

//获取拼音(分隔符为空格)
String pinyin = PinyinUtil.getPinyin("你好", " ");//ni hao
//获取拼音首字母
String result = PinyinUtil.getFirstLetter("H是第一个", "、 ");//h、 s、 d、 y、 g
//自定义拼音库
Pinyin4jEngine engine = new Pinyin4jEngine();
String pinyin1 = engine.getPinyin("你好a兄弟", " ");//ni hao a xiong di

3.13、压缩封装-CompressUtil

3.13.1、引入依赖

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-compress</artifactId>
    <version>1.21</version>
</dependency>

3.12.1、压缩

//压缩e:/other为ZIP
final File fileToZip = FileUtil.file("e:/other.ZIP");
CompressUtil.createArchiver(CharsetUtil.CHARSET_UTF_8, ArchiveStreamFactory.ZIP, fileToZip)
    .add(FileUtil.file("e:/other"))
    .finish().close();
//压缩文件夹部分文件(如果是免疫就不进行压缩)
final File zipFile = FileUtil.file("e:/other.ZIP");
CompressUtil.createArchiver(CharsetUtil.CHARSET_UTF_8, ArchiveStreamFactory.ZIP, zipFile)
    .add(FileUtil.file("e:/other"), (file) -> {
        if ("免疫".equals(file.getName())) {
            return false;
        }
        return true;
    })
    .finish().close();

3.12.2、解压

Extractor extractor = CompressUtil.createExtractor(CharsetUtil.defaultCharset(), FileUtil.file("e:/other.ZIP"));
extractor.extract(FileUtil.file("e:/111"));

3.14、图形验证码-Hutool-captcha

验证码生成和校验功能

3.14.1、线段干扰的验证码

//定义图形验证码的长和宽
LineCaptcha lineCaptcha = CaptchaUtil.createLineCaptcha(200, 100);
//图形验证码写出，可以写出到文件，也可以写出到流
lineCaptcha.write("e:/line.png");
lineCaptcha.write(response.getOutputStream());
//输出code
Console.log(lineCaptcha.getCode());//24kbo
//验证图形验证码的有效性，返回boolean值
lineCaptcha.verify("1234");//false
//验证有效性
Console.log(lineCaptcha.verify(lineCaptcha.getCode()));//true
//重新生成验证码
lineCaptcha.createCode();
lineCaptcha.write("d:/line.png");
//新的验证码
Console.log(lineCaptcha.getCode());

3.14.2、圆圈干扰验证码

//定义图形验证码的长、宽、验证码字符数、干扰元素个数
CircleCaptcha captcha = CaptchaUtil.createCircleCaptcha(200, 100, 4, 20);
//CircleCaptcha captcha = new CircleCaptcha(200, 100, 4, 20);
//图形验证码写出，可以写出到文件，也可以写出到流
captcha.write("e:/circle.png");
System.out.println(captcha.getCode());//iny4
//验证图形验证码的有效性，返回boolean值
captcha.verify("1234");

3.14.3、扭曲干扰验证码

//定义图形验证码的长、宽、验证码字符数、干扰线宽度
ShearCaptcha captcha = new ShearCaptcha(200, 100, 4, 4);
//图形验证码写出，可以写出到文件，也可以写出到流
captcha.write("e:/shear.png");
System.out.println(captcha.getCode());//7qrf
//验证图形验证码的有效性，返回boolean值
captcha.verify("1234");

3.14.4、自定义验证码

3.14.4.1、自定义纯数字的验证码（随机4位数字，可重复）

//自定义纯数字的验证码（随机4位数字，可重复）
RandomGenerator randomGenerator = new RandomGenerator("0123456789", 4);
LineCaptcha lineCaptcha = CaptchaUtil.createLineCaptcha(200, 100);
lineCaptcha.setGenerator(randomGenerator);
lineCaptcha.write("e:/12.jpg");
System.out.println(lineCaptcha.getCode());//6476

3.14.4.2、定义验证码内容为四则运算方式

//定义验证码内容为四则运算方式
ShearCaptcha captcha = CaptchaUtil.createShearCaptcha(200, 45, 4, 4);
captcha.setGenerator(new MathGenerator());
captcha.write("e:/22.png");
System.out.println(captcha.getCode());//95-89=

3.15、加密解密-Hutool-crypto

加密分为三种：

1. 对称加密（symmetric），例如：AES、DES等
2. 非对称加密（asymmetric），例如：RSA、DSA等
3. 摘要加密（digest），例如：MD5、SHA-1、SHA-256、HMAC等

3.15.1、对称加密-SymmetricCrypto

对称加密(也叫私钥加密)指加密和解密使用相同密钥的加密算法。有时又叫传统密码算法，就是加密密钥能够从解密密钥中推算出来，同时解密密钥也可以从加密密钥中推算出来。而在大多数的对称算法中，加密密钥和解密密钥是相同的，所以也称这种加密算法为秘密密钥算法或单密钥算法。它要求发送方和接收方在安全通信之前，商定一个密钥；

3.15.1.1、AES算法

//AES加密解密
String content = "AES加密解密";
//随机生成密钥
byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.AES.getValue()).getEncoded();
//构建
AES aes = SecureUtil.aes(key);
//加密
byte[] encrypt = aes.encrypt(content);
//解密
byte[] decrypt = aes.decrypt(encrypt);
Console.log("解密", decrypt);//AES加密解密
//加密为16进制表示
String encryptHex = aes.encryptHex(content);
System.out.println(encryptHex);//b8c9fcef08dec99da26df6e250388ec4
//解密为原字符串
String decryptStr = aes.decryptStr(encryptHex, CharsetUtil.CHARSET_UTF_8);//AES加密解密

3.15.1.2、DES算法

String desContent = "DES加密解密";
//随机生成密钥
byte[] desKey = SecureUtil.generateKey(SymmetricAlgorithm.DESede.getValue()).getEncoded();
//构建
SymmetricCrypto des = new SymmetricCrypto(SymmetricAlgorithm.DESede, desKey);
//加密
byte[] desEncrypt = des.encrypt(desContent);
//解密
byte[] desDecrypt = des.decrypt(desEncrypt);
Console.log("解密", desDecrypt);//DES加密解密
//加密为16进制表示
String encryptHex = des.encryptHex(desContent);
System.out.println(encryptHex);//0107a63a161579ed6bde2fd65a10119c
//解密为原字符串
String decryptStr = des.decryptStr(encryptHex, CharsetUtil.CHARSET_UTF_8);//DES加密解密

3.15.2、非对称加密-AsymmetricCrypto

非对称加密，最常用的就是RSA和DSA，在Hutool中使用AsymmetricCrypto对象来负责加密解密。

非对称加密有公钥和私钥两个概念，私钥自己拥有，不能给别人，公钥公开。根据应用的不同，我们可以选择使用不同的密钥加密：

1. 签名：使用私钥加密，公钥解密。用于让所有公钥所有者验证私钥所有者的身份并且用来防止私钥所有者发布的内容被篡改，但是不用来保证内容不被他人获得。
2. 加密：用公钥加密，私钥解密。用于向公钥所有者发布信息,这个信息可能被他人篡改,但是无法被他人获得。

RSA rsa = new RSA();
//获取私钥
rsa.getPrivateKey();
rsa.getPrivateKeyBase64();
//获取公钥
rsa.getPublicKey();
rsa.getPublicKeyBase64();
//公钥加密、私钥解密
byte[] encrypt1 = rsa.encrypt(StrUtil.bytes("kak爱学习java!(公钥加密、私钥解密)", CharsetUtil.CHARSET_UTF_8), KeyType.PublicKey);
byte[] decrypt1 = rsa.decrypt(encrypt1, KeyType.PrivateKey);
String str = StrUtil.str(decrypt1, CharsetUtil.CHARSET_UTF_8);//kak爱学习java!(公钥加密、私钥解密)
//私钥加密、公钥解密
byte[] encrypt2 = rsa.encrypt(StrUtil.bytes("kak爱学习java!(私钥加密、公钥解密)", CharsetUtil.CHARSET_UTF_8), KeyType.PrivateKey);
byte[] decrypt2 = rsa.decrypt(encrypt2, KeyType.PublicKey);
String str1 = StrUtil.str(decrypt2, CharsetUtil.CHARSET_UTF_8);//kak爱学习java!(私钥加密、公钥解密)

4、参考资料

HuTool官方文档：https://www.hutool.cn/docs/#/

参考博客：

• https://blog.csdn.net/weixin_50394734/article/details/117913438
• https://blog.csdn.net/boy_chen93/article/details/100155127
• https://blog.csdn.net/xgysimida/article/details/108719640
• https://my.oschina.net/looly/blog/1504160