简介：
Hutool是一个小而全的Java工具类库，通过静态方法封装，降低相关API的学习成本，提高工作效率，使Java拥有函数式语言般的优雅，让Java语言也可以“甜甜的”。
安装：
在我们的maven中引入糊涂的依赖即可
<!--引入Hutool工具类--><dependency><groupId>cn.hutool</groupId><artifactId>hutool-all</artifactId><version>5.8.16</version></dependency>因为我们使用的是单元测试，所以我们还需要引入junit的依赖。如果是spring boot项目，就不需要引入，引入junit，因为springboot已经继承了，要是maven项目就需要引入。
<!--引入junit单元测试--><dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter</artifactId><scope>test</scope></dependency>集合类：
集合工具-ColUtil
主要封装了对数组和集合类的操作
新建一个ColUtilTest测试类：
public class ColUtilTest {}在这个类上添加 @Slf4j注解
@Slf4j
public class ColUtilTest {}join方法：
就是将一个集合转换成字符串。
@Test@DisplayName(value = "测试集合转成字符串")void testListToStr(){String[] str = {"a","b","c","d"};ArrayList<String> list = CollUtil.newArrayList(str);String join = CollUtil.join(list, ","); //用指定分隔符分割log.info(join);}sortPageAll方法
这是一个组合方法，功能是将给定的多个集合放到一个集合（list）中，根据给定的
Comparator对象排序，然后分页取数据。
@Test@DisplayName(value = "合并集合到一个集合中，并按照分页的数据按需取出")void testToList(){//Integer类型的比较器Comparator<Integer> comparator = new Comparator<>() {@Overridepublic int compare(Integer o1, Integer o2) {return o1.compareTo(o2);}};//新建三个集合ArrayList<Integer> list1 = CollUtil.newArrayList(1, 2, 3);ArrayList<Integer> list2 = CollUtil.newArrayList(4, 5, 6);ArrayList<Integer> list3 = CollUtil.newArrayList(7, 8, 9);//把list1，list2，list3，按照从小到大排序，取 0~3个List<Integer> result = CollUtil.sortPageAll(0, 3, comparator, list1, list2, list3);System.out.println(result);}popPart方法
传入一个栈对象，然后弹出指定数目的元素对象，弹出是指
pop()方法，会从原栈中删掉。并否则删除的元素。
@Test@DisplayName(value = "测试出栈")void testPopPart(){Stack stack = new Stack();stack.push(1);stack.push(2);stack.push(3);stack.push(4);List popPart = CollUtil.popPart(stack, 2);System.out.println(popPart); //输出，出栈的元素System.out.println(stack); //查看原来的stack}append方法：
在数组末尾添加一个元素，其实就是List.add()方法实现的。
@Test@DisplayName(value = "给数组末尾添加元素")void testToAppend(){Integer[] ids = {4,5};Integer[] append = ArrayUtil.append(ids, 1, 2, 3);System.out.println(Arrays.toString(append)); //输出数组元素System.out.println(ArrayUtil.toString(append)); //输出数组元素}resize方法
重新调整数组的大小，如果调整后的大小比原来小，截断，如果比原来大，则多出的位置用null补位。
@Test@DisplayName("重新调整数据的大小")void testResize(){Object[] array = ArrayUtil.newArray(5); //创建一个长度为5的数组array[0] = 1;array[1] = 2;array[2] = 3;array[3] = 4;System.out.println(ArrayUtil.toString(array)); //输出数据的数据System.out.println(ArrayUtil.length(array)); //查看这个数组的长度Object[] resize = ArrayUtil.resize(array, 3); //调整数组大小为3System.out.println(ArrayUtil.length(resize)); //输出调整后数组的大小System.out.println(ArrayUtil.toString(resize));Object[] newSize = ArrayUtil.resize(resize, 6); //调整数组大小为6System.out.println(ArrayUtil.toString(newSize)); //测试新数组里面的数据System.out.println(ArrayUtil.length(newSize)); //测试新数组的长度}addAll方法
将多个集合添加到一个
Collection中
@Test@DisplayName(value = "把多个集合，合并到一个集合中")void testAddAll(){Collection coll = new ArrayList();coll.add(88);coll.add(99);Collection<Integer> collection = CollUtil.addAll(CollUtil.newArrayList(1, 2, 3, 4), CollUtil.newArrayList(6, 7, 8));collection.addAll(coll);System.out.println(collection);}sub方法
对集合切片，其他类型的集合会转换成List，
自动修正越界等问题，完全避免
IndexOutOfBoundsException异常。
@Test@DisplayName(value = "测试对集合进行切片")void testSubList(){ArrayList<Integer> list = CollUtil.newArrayList(1, 2, 3, 4, 5, 6);List<Integer> subList = CollUtil.sub(list, 0, 3);System.out.println(subList); //输出切片的数据System.out.println(CollUtil.sub(list, 0, list.size() + 3)); //已经明显超出集合长度了System.out.println(list); //原集合}isEmpty，isNotEmpty方法
判断集合是否为空（包括null和没有元素的集合）
@Test@DisplayName(value = "list集合转成map")void testListToMap(){ArrayList<Integer> keys = CollUtil.newArrayList(1, 2, 3, 4);ArrayList<String> values = CollUtil.newArrayList("a", "b", "c", "d");Map<Integer, String> map = CollUtil.zip(keys, values);System.out.println(map);}zip方法
给定两个集合，然后两个集合中的元素一一对应，组成一个Map。此方法还有一个重载方法，可以传字符，然后给定分隔符，字符串会被split成列表。
@Test@DisplayName(value = "list集合转成map")void testListToMap(){ArrayList<Integer> keys = CollUtil.newArrayList(1, 2, 3, 4);ArrayList<String> values = CollUtil.newArrayList("a", "b", "c", "d");Map<Integer, String> map = CollUtil.zip(keys,values);System.out.println(map);}列表工具-ListUtil
List在集合中使用最为频繁，因此新版本的Hutool中针对
List单独封装了工具方法
indexOfAll方法
查找某个元素，在集合中的位置（返回的是索引）
@Test@DisplayName(value = "查找某个元素在集合中出现的位置")void test1(){LinkedList<String> linkedList = ListUtil.toLinkedList("1", "2", "3", "4", "3", "2", "1");int[] ints = ListUtil.indexOfAll(linkedList, "2"::equals); //输出的是索引System.out.println(ArrayUtil.toString(ints));}快速生成list集合方法：
用下面的方法，可以帮助我们快速的生成list集合。
@Test@DisplayName(value = "快速生成list集合")void testFindOption(){List<Integer> list = ListUtil.of(1, 2, 3, 4, 5);list.forEach(l ->{System.out.println(l); //遍历集合});ArrayList<Integer> arrayList = ListUtil.toList(1, 2, 3, 4);System.out.println(arrayList);LinkedList<Integer> linkedList = ListUtil.toLinkedList(1, 2, 3, 4, 5, 6, 7);System.out.println(linkedList);List<Integer> integerList = Arrays.asList(1, 2, 3, 4);System.out.println(integerList);}sub方法
此方法是列表截取，根据起始索引截取。不会影响原来的集合
@Test@DisplayName(value = "集合数据截取")void testSubList(){ArrayList<Integer> list = ListUtil.toList(1, 2, 3, 4, 5, 6);List<Integer> sub = ListUtil.sub(list, 0, 3);System.out.println(sub); //截取出来的集合System.out.println(list); //原集合}sortByProperty方法
按照bean对象的某个数字类型的字段值排序
先创建一个 TestBean实体类对象，添加 @Data，和@AllArgsConstructor注解
@Data@NoArgsConstructor@AllArgsConstructorclass TestBean{private Integer id;private String name;}
@Test@DisplayName(value = "按照我们自定义的bean对象中的id属性排序")void testSort(){ArrayList<TestBean> list = ListUtil.toList(new TestBean(2, "测试2"),new TestBean(4, "测试4"),new TestBean(1, "测试1"),new TestBean(3, "测试3"));list.forEach(System.out::println); //排序前ListUtil.sortByProperty(list,"id");System.out.println("************************************************");list.forEach(l -> System.out.println(l)); //排序后}swapTo方法
将指定元素和指定下标位置的元素交换位置
@Test@DisplayName(value = "元素交换")void testSwap(){List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);ListUtil.swapTo(list,5,1); // 元素为5 的和下标是1的交换位置System.out.println(list);}partition方法
- 这个方法起到分组的作用。
- 通过传入要分组的集合，每个分组区间的大小，将一个集合分成不同的块。
@Test@DisplayName(value = "集合分组")void testPart(){ArrayList<Integer> list = ListUtil.toList(1, 2, 3, 4, 5, 6,7);List<List<Integer>> partition = ListUtil.partition(list, 3); //三个元素是一组System.out.println(partition);System.out.println(ListUtil.partition(list, 2)); //两个元素是一组}开发中常用工具类：
随机工具-RandomUtil
RandomUtil主要针对JDK中Random对象做封装，严格来说，Java产生的随机数都是伪随机数，所以Hutool封装后产生的随机结果也是伪随机结果。
新建一个 RandomTest测试类：在添加@slf4j注解
@Slf4j
@DisplayName(value = "测试生成随机数")
public class RandomTest {}randomInt方法
RandomUtil.randomInt获得指定范围内的随机数- 前包后不包
@Test@DisplayName("测试生成指定范围的随机数")void randomTest1(){log.info("测试生成指定范围的随机数");for (int i = 0; i < 100; i++) {int random = RandomUtil.randomInt(10, 100);if (random == 10){log.info("包含了{}",random);}if (random == 100){log.info("包含了{}",random);}System.out.println("生成的随机数是："+random);}}randomBytes 方法
- 生成一个 byte类型范围内的随机数，包含正数和负数。
- 可以传递一个参数，表示生成几个。
@Test@DisplayName("测试生成在byte范围内的随机数，包括正数和负数，返回在一个数组中")void randomTest2(){log.info("测试生成在byte范围内的随机数，包括正数和负数，返回在一个数组中");byte[] bytes = RandomUtil.randomBytes(10);System.out.println(ArrayUtil.toString(bytes));}randomString 方法
- 获得一个随机的字符串（只包含数字和字符）
- 传入一个参数指定，生成的随机字符串的长度
@Test@DisplayName(value = "获得一个随机的字符串(包含数字和字符)")void testRandomStr(){String s1 = RandomUtil.randomString(10);String s2 = RandomUtil.randomString(4);System.out.println(s1);System.out.println(s2);}randomNumbers 方法
获得一个只包含数字的字符串
@Test@DisplayName(value = "获得一个随机的字符串(包含数字)")void testRandomNums(){String numbers1 = RandomUtil.randomNumbers(10);String numbers2 = RandomUtil.randomNumbers(7);System.out.println(numbers1);System.out.println(numbers2);}唯一 ID工具-IdUtil
唯一ID生成应用十分广泛，生成方法也多种多样，Hutool针对一些常用生成策略做了简单封装。
唯一ID生成器的工具类，涵盖：
- UUID
- ObjectId（MongoDB）
- Snowflake（Twitter）
UUID
UUID全称通用唯一识别码（universally unique identifier），JDK通过
java.util.UUID提供了 Leach-Salz 变体的封装。Hutool中，生成一个UUID字符串方法如下：
我们先新建一个测试类：UuidTest，然后加上@Slf4j的注解
@Slf4j
@DisplayName(value = "UUID的测试类")
public class UuidTest {}randomUUID方法
生成的UUID是带 - 的字符串
@Test@DisplayName(value = "测试生成带 - 的UUID")public void testId1(){log.info("测试生成带 - 的UUID");String uuid = cn.hutool.core.util.IdUtil.randomUUID();System.out.println(uuid);simpleUUID方法
生成不带 - 的字符串
@Test@DisplayName(value = "测试生成不带 - 的UUID")public void testId2(){log.info("测试生成不带 - 的UUID");String uuid = cn.hutool.core.util.IdUtil.simpleUUID();System.out.println(uuid);}说明：
Hutool重写了java.util.UUID的逻辑，使用糊涂工具生成不带 - UUID字符串，不需要做字符串替换，性能提高一倍左右。
ObjectId
ObjectId是MongoDB数据库的一种唯一ID生成策略，是UUID version1的变种
我们新建一个ObjectIdTest测试类，加上@Slf4j的注解。
@Slf4j
@DisplayName(value = "ObjectId的测试类")
public class ObjectIdTest {}next方法
生成类似于： 5bsf78fg878dsg7svdsf98dsds9
@Test@DisplayName(value = "测试生成一串的ObjectId")void testObjectIdTest1(){log.info("测试生成一大串的ObjectId");String next = ObjectId.next();System.out.println(next);}objectId方法
这个方法是 Hutool-4.1.14才开始提供
@Test@DisplayName(value = "测试生成一串的ObjectId")void testObjectIdTest2(){log.info("测试生成一大串的ObjectId");String id = IdUtil.objectId();System.out.println(id);}数组工具-ArrayUtil
数组工具类主要是解决对象数组（包括包装类型数组）和原始类型数组使用方法不统一的问题。
新建一个ArrayUtilTest测试类，加上@Slf4j注解
@Slf4j
public class ArrayUtilTest {}isEmpty方法
数组的判空类似于字符串的判空，标准是
null或者数组长度为0，ArrayUtil中封装了针对原始类型和泛型数组的判空和判非空：
@Test@DisplayName(value = "测试数组是否为空")void testIsEmpty(){int[] a = {};int[] b = null;int[] c = {1,2,3};System.out.println(ArrayUtil.isEmpty(a));System.out.println(ArrayUtil.isEmpty(b));System.out.println(ArrayUtil.isEmpty(c));}isNotEmpty方法
@Test@DisplayName(value = "测试非空判断")void testIsNotEmpty(){int[] a = {};int[] b = null;int[] c = {1,2,3};System.out.println(ArrayUtil.isNotEmpty(a));System.out.println(ArrayUtil.isNotEmpty(b));System.out.println(ArrayUtil.isNotEmpty(c));}newArray方法
新建泛型数组。
Array.newInstance并不支持泛型返回值，在此封装此方法使之支持泛型返回值。
@Test@DisplayName(value = "新建泛型数组")void testNewArray(){Object[] strArr = ArrayUtil.newArray(String.class, 4);strArr[0] = "1";strArr[1] = "2";strArr[2] = "8";System.out.println(ArrayUtil.toString(strArr));}我的泛型是 String类型的，在给数组添加新元素的时候，如果添加 其他类型，比如 Integer类型，就会报错。
resize方法
使用ArrayUtil.size方法，生成一个新的重新设置大小的数组
@Test@DisplayName(value = "调整数组大小")void testArrResize(){Object[] array = ArrayUtil.newArray(5);System.out.println(array.length); //新生成数组的长度Object[] resize = ArrayUtil.resize(array, 3);System.out.println(resize.length);}addAll方法
Array.addAll方法，将多个泛型数组合并为一个数组。
@Test@DisplayName(value = "合并数组")void testAddAll(){Object[] intArr = ArrayUtil.newArray(Integer.class, 3);Object[] strArr = ArrayUtil.newArray(String.class, 4);Object[] all = ArrayUtil.addAll(intArr, strArr);System.out.println(all.length);all[0] = 1;all[4] = "你好";all[2] = 3.8D;System.out.println(ArrayUtil.toString(all));}cone方法
数组本身支持clone方法，因此确定为某种类型数组时调用
ArrayUtil.clone(T[]),不确定类型的使用ArrayUtil.clone(T)，两种重载方法在实现上有所不同，但是在使用中并不能感知出差别。
@Test@DisplayName(value = "克隆数组")void testClone(){Integer[] a = {1,2,3,4};Integer[] cloneB = ArrayUtil.clone(a);System.out.println(ArrayUtil.toString(cloneB));}数字工具-NUmberUtil
数字工具针对数学运算做工具性封装
新建一个 NumberUtilTest 测试类，并添加@Slf4j注解
@Slf4j
public class NumberUtilTest {}加减乘除
add方法
针对数字类型做加法
@Test@DisplayName(value = "测试减法")void testSub(){BigDecimal sub = NumberUtil.sub(1, 2, 3, 4, 5);System.out.println(sub);}sub方法
针对数字类型做减法
@Test@DisplayName(value = "测试减法")void testSub(){BigDecimal sub = NumberUtil.sub(1, 2, 3, 4, 5);System.out.println(sub);}mul方法
针对数字类型做乘法
@Test@DisplayName(value = "测试乘法")void testMul(){double mul = NumberUtil.mul(3.4, 0.345);System.out.println(mul);}div方法
针对数字类型做除法，并提供重载方法用于规定除不尽的情况下保留小数位数和舍弃方式。
@Test@DisplayName(value = "测试除法")void testDiv(){double div = NumberUtil.div(10, 0.34);System.out.println(div);}round方法
NumberUtil.round方法主要封装BigDecimal中的方法来保留小数，返回BigDecimal，这个方法更加灵活，可以选择四舍五入或者全部舍弃等模式。
@Test@DisplayName(value = "四舍五入保留小数点")void testRound(){Double tel1 = 12345.123456;Double tel2 = 12345.127656;Console.log(round(tel1,4)); //四舍五入，且保留小数点后四位Console.log(round(tel2,3)); //四舍五入，且保留小数点后三位}roundStr方法
NumberUtil.roundStr方法主要封装String.format方法,舍弃方式采用四舍五入。
@Test@DisplayName(value = "另一种方法")void testRoundStr(){double te1=123456.123456;double te2=123456.128456;Console.log(roundStr(te1,2));//四舍五入，保留小数点后两位Console.log(roundStr(te2,2));//四舍五入，保留小数点后两位}校验数字：
isNumber方法
是否为数字
@Test@DisplayName(value = "检验是否是数字")void testIsNumber(){String str = "899daoen";String num = "4353";System.out.println(NumberUtil.isNumber(str));System.out.println(NumberUtil.isNumber(num));}isInteger方法
是否为整数
@Test@DisplayName(value = "检验是否是整数")void testIsInteger(){String i1 = "123.4";String i2 = "89424";String i3 = "89asda424";System.out.println(NumberUtil.isInteger(i1));System.out.println(NumberUtil.isInteger(i2));System.out.println(NumberUtil.isInteger(i3));}isDouble方法
是否是浮点数
@Test@DisplayName(value = "校验是否是浮点数")void testIsDouble(){String d1 = "12546";String d2 = "1254gfg6";String d3 = "1.234";System.out.println(NumberUtil.isDouble(d1));System.out.println(NumberUtil.isDouble(d2));System.out.println(NumberUtil.isDouble(d3));}isPrimes方法
是否是质数
@Test@DisplayName(value = "校验是否是质数")void testIsPrimes(){Integer p1 = 3;Integer p2 = 12;Integer p3 = 17;System.out.println(NumberUtil.isPrimes(p1));System.out.println(NumberUtil.isPrimes(p2));System.out.println(NumberUtil.isPrimes(p3));}随机数：
generateRandomNumber方法
生成不重复随机数 根据给定的最小数字和最大数字，以及随机数的个数，产生指定的不重复的数组。
@Test@DisplayName(value = "生成不重复的随机数")void testGenRandom(){int[] ints = NumberUtil.generateRandomNumber(1, 20, 19); //size范围不能超过end - begin的差System.out.println(ArrayUtil.toString(ints));}generateBySet方法
生成不重复随机数 根据给定的最小数字和最大数字，以及随机数的个数，产生指定的不重复的数组。
@Test@DisplayName(value = "生成不重复的数组")void testGenBySet(){Integer[] generate = NumberUtil.generateBySet(5, 10, 5);//size范围不能超过end - begin的差System.out.println(ArrayUtil.toString(generate));}整数列表：
range方法
方法根据范围和步进，生成一个有序整数列表
@Test@DisplayName(value = "生成一个有序整数数组")void testRange(){int[] range = NumberUtil.range(7); //从 0 开始 到 7 结束System.out.println(ArrayUtil.toString(range));int[] ints = NumberUtil.range(5, 10); //生成一个从5开始，到10结束的数组System.out.println(ArrayUtil.toString(ints));}appendRange方法
将给定范围内的整数添加到已有集合中
@Test@DisplayName(value = "把指定范围内的整数，添加到一个集合中")void testAppendRange(){ArrayList<Integer> list = ListUtil.toList(1, 2, 3, 4);Collection<Integer> collection = NumberUtil.appendRange(6, 9, list);collection.forEach(c -> System.out.println(c));}compare 方法
@Test@DisplayName(value = "比较两个数的大小")void testCompare(){/*** x 是第一个参数，y是第二个参数* x > y 返回 1* x < y 返回 -1* x = y 返回 0*/System.out.println(NumberUtil.compare(12, 15));System.out.println(NumberUtil.compare(20, 10));System.out.println(NumberUtil.compare(25, 25));}
