糊涂（Hutool）工具常见的使用方法

?简介：

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<>() {
            @Override
            public 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);  //调整数组大小为3
        System.out.println(ArrayUtil.length(resize));   //输出调整后数组的大小
        System.out.println(ArrayUtil.toString(resize));
        Object[] newSize = ArrayUtil.resize(resize, 6);  //调整数组大小为6
        System.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
    @AllArgsConstructor
    class 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);
    }