探索实用的Java工具类

1.排序

有时需要对集合进行排序。此时可以使用Collections的sort方法。

List<Integer> list = new ArrayList<>();
        list.add(2);
        list.add(1);
        list.add(3);
        Collections.sort(list); // ASC
        System.out.println("ASC-排序后:"+list);
        Collections.reverse(list); // DESC
        System.out.println("DESC-排序后:"+list);
        Collections.shuffle(list); // 随机排序
        System.out.println("随机排序后:"+list);

2.获取最大值或最小值

有时需要在集合中找到最大值或最小值。此时可以使用Collections的max和min方法。
注意：如果集合为空，则会抛出NoSuchElementException异常
建议：使用Collections的max和min方法。

        List<Integer> list1 = new ArrayList<>();
        list1.add(2);
        list1.add(1);
        list1.add(3);
        Integer max = Collections.max(list1);
        Integer min = Collections.min(list1);
        System.out.println("最大值:"+max);
        System.out.println("最小值:"+min);

**　3.返回空集合**

有时在检查空值后，我们需要返回一个空集合。可以使用emptyList方法

注意：返回的空集合是不可修改的，不能添加元素，否则会抛出UnsupportedOperationException异常

建议：使用Collections.emptyList()方法获取空集合

 List<Object> emptyList = Collections.emptyList();
        System.out.println("空集合:"+emptyList);

**　4.转换为不可修改集合**

有时需要将一个可修改的集合转换为不可修改的集合。可以使用unmodifiableList方法

注意：返回的不可修改集合是只读的，不能修改集合元素，否则会抛出UnsupportedOperationException异常

建议：使用Collections.unmodifiableList方法获取不可修改集合

List<Integer> list2 = new ArrayList<>();
        list2.add(2);
        list2.add(1);
        list2.add(3);
        List<Integer> unmodifiableList = Collections.unmodifiableList(list2);
        // 不能添加元素，否则会抛出UnsupportedOperationException异常
        //unmodifiableList.add(4);
        System.out.println("不可修改集合:"+unmodifiableList);

5. 转换为线程安全集合

有时需要将一个不可修改的集合转换为线程安全的集合。可以使用synchronizedList方法
注意：返回的线程安全集合是线程安全的，可以在多线程环境下使用，但是效率会降低
建议：使用Collections.synchronizedList方法获取线程安全集合
其底层实现会创建SynchronizedRandomAccessList或SynchronizedList类。
这两个类的许多方法会使用synchronized进行锁定。

        List<Integer> list3 = new ArrayList<>();
        list3.add(2);
        list3.add(1);
        list3.add(3);
        // 将ArrayList转换为线程安全集合
        List<Integer> integers = Collections.synchronizedList(list3);
        System.out.println(integers);

6.检查集合是否为空

对于集合操作，除了前面提到的Collections工具类，CollectionUtils工具类也非常常用。

目前，比较主流的有apache中的org.apache.commons.collections包下的CollectionUtils工具类。

<dependency>
    <groupId>commons-collections</groupId>
    <artifactId>commons-collections</artifactId>
    <version>3.2.2</version>
</dependency>

有时需要检查集合是否为空。可以使用isEmpty方法
注意：如果集合为空，则返回true，否则返回false
建议：使用CollectionUtils.isEmpty方法检查集合是否为空
其底层实现会调用isEmpty方法。

        List<Integer> list4 = new ArrayList<>();
        list4.add(2);
        list4.add(1);
        list4.add(3);
        if (CollectionUtils.isEmpty(list)) {
            System.out.println("集合为空。");
        } else {
            System.out.println("集合不为空。");
        }

7.对两个集合进行操作

有时需要对两个集合进行操作。此时可以使用Collections的相关方法。
注意：Collections提供了很多方法，可以对集合进行操作。
建议：使用Collections的相关方法。

        List<Integer> list01 = new ArrayList<>();
        list01.add(2);
        list01.add(1);
        list01.add(3);

        List<Integer> list02 = new ArrayList<>();
        list02.add(2);
        list02.add(4);

        // 获取并集
        Collection unionList = CollectionUtils.union(list01, list02);
        System.out.println("并集:"+unionList);

        // 获取交集
        Collection intersectionList = CollectionUtils.intersection(list01, list02);
        System.out.println("交集:"+intersectionList);

        // 获取对称差
        Collection disjunctionList = CollectionUtils.disjunction(list01, list02);
        System.out.println("对称差:"+disjunctionList);

        // 获取差集
        Collection subtractList = CollectionUtils.subtract(list01, list02);
        System.out.println("差集:"+subtractList);

8. 快速初始化集合

<dependency>
      <groupId>com.google.guava</groupId>
      <artifactId>guava</artifactId>
      <version>28.2-jre</version>
</dependency>

有时需要快速初始化集合。此时可以使用Arrays.asList方法。
注意：返回的集合是Arrays内部类，不能修改集合元素，否则会抛出UnsupportedOperationException异常
建议：使用Lists.newArrayList方法获取集合。

        List<Integer> list5 = Lists.newArrayList(1, 2, 3);
       System.out.println("快速初始化集合:"+list5);

9.笛卡尔积

有时需要计算两个集合的笛卡尔积。此时可以使用cartesianProduct方法。
注意：返回的笛卡尔积是一个List<List<T>>，其中每个元素是一个List<T>。
建议：使用cartesianProduct方法计算笛卡尔积。

        List<Integer> list6 = Lists.newArrayList(1, 2);
        List<Integer> list7 = Lists.newArrayList(3, 4);
        List<List<Integer>> cartesianProductList = Lists.cartesianProduct(list6, list7);
        System.out.println("笛卡尔积:"+cartesianProductList);

10. 集合分解

有时需要将一个集合分解为多个集合。此时可以使用partition方法。
注意：返回的分解是一个List<List<T>>，其中每个元素是一个List<T>。
建议：使用partition方法分解集合。

        List<Integer> list8 = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        List<List<Integer>> partitionList = Lists.partition(list8, 3);
        System.out.println("分解:"+partitionList);

11. 流处理

将某个集合转换为另一个接口，可以使用Lists的transform方法
注意：返回的转换后的集合是另一个接口。
建议：使用Lists.transform方法转换集合。

        List<String> list9 = Lists.newArrayList("a","b","c");
        // 将字符串集合转换为大写字符串集合
        List<String> transformList = Lists.transform(list9, String::toUpperCase);
        System.out.println(transformList);

12.反转顺序

有时需要反转集合的顺序。此时可以使用reverse方法。
注意：返回的反转后的集合是原集合的引用。
建议：使用reverse方法反转集合。

        List<Integer> list10 = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Collections.reverse(list10);
        System.out.println("反转:"+list10);

13. Objects工具类

有时需要判断对象是否为空。此时可以使用Objects工具类。
注意：Objects工具类提供了很多方法，可以判断对象是否为空、是否相等、是否相同等。
建议：使用Objects工具类。

       //判断对象是否为空
        Integer num = new Integer(10);
        if (Objects.isNull(num)) {
            System.out.println("对象为空。");
        } else {
            System.out.println("对象不为空。");
        }

14. 当对象为null时抛出异常

如果我们想在对象为null时抛出空指针异常，可以使用Objects的requireNonNull方法
注意：如果对象为null，则会抛出NullPointerException异常。
建议：使用Objects工具类。

        Integer i = new Integer(128);
        Objects.requireNonNull(i);
        Objects.requireNonNull(i, "参数不能为空");
        Objects.requireNonNull(i, () -> "参数不能为空");

15. 检查两个对象是否相等

有时需要判断两个对象是否相等。此时可以使用Objects工具类。
注意：如果两个对象相等，则返回true，否则返回false。
建议：使用Objects工具类。

        Integer i1 = new Integer(1);
        Integer i2 = new Integer(1);
        System.out.println(Objects.equals(i1, i2));

16.获取对象的hashCode

有时需要获取对象的hashCode。此时可以使用Objects工具类。
注意：返回的hashCode是一个int值。
建议：使用Objects工具类。

        String str = "hello";
        System.out.println(Objects.hashCode(str));

17. 检查字符串是否为null

有时需要检查字符串是否为null。此时可以使用StringUtils工具类。
注意：如果字符串为null，则返回true，否则返回false。
建议：使用StringUtils工具类。

        String str1 = "hello";
        String str2 = null;
        System.out.println(StringUtils.isBlank(str1));
        System.out.println(StringUtils.isBlank(str2));
        System.out.println(StringUtils.isEmpty(str1));
        System.out.println(StringUtils.isEmpty(str2));

18. 拆分字符串

有时需要拆分字符串。此时可以使用StringUtils工具类。
注意：返回的拆分后的字符串是一个String[]。
建议：使用StringUtils工具类。

        String itemStr = "a,b,c";
        System.out.println(StringUtils.split(itemStr, ","));
        System.out.println(itemStr.split(","));

19. 检查是否为纯数字

有时需要检查字符串是否为纯数字。此时可以使用StringUtils工具类。
注意：如果字符串为纯数字，则返回true，否则返回false。
建议：使用StringUtils工具类。

        String numStr = "123456";
        String numStr1 = "123abc";
        String numStr2 = "3.1415926";
        System.out.println(StringUtils.isNumeric(numStr));
        System.out.println(StringUtils.isNumeric(numStr1));
        System.out.println(StringUtils.isNumeric(numStr2));
        // 使用正则表达式
        System.out.println(numStr.matches("\\d+"));

20. 将集合连接成字符串

有时需要将集合连接成字符串。此时可以使用StringUtils工具类。
注意：返回的连接后的字符串是一个String。
建议：使用StringUtils工具类。

        List<String> list11 = Lists.newArrayList("a", "b", "c");
        // 使用join方法
        String joinStr = StringUtils.join(list11, ",");
        System.out.println(joinStr);
        // 使用String.join方法
        String stringStr = String.join(",", list11);
        System.out.println(stringStr);

21. 复制对象属性

有时需要复制对象属性。此时可以使用BeanUtils工具类。
注意：返回的复制后的对象是原对象的引用。
建议：使用BeanUtils工具类。

        User user = new User();
        user.setUserName("admin");
        user.setRealName("管理员");
        User user1 = new User();
        BeanUtils.copyProperties(user, user1);
        System.out.println(user1);

22. 获取指定类的指定方法

有时需要获取指定类的指定方法。此时可以使用ReflectionUtils工具类。
注意：返回的Method对象是指定类的指定方法。
建议：使用ReflectionUtils工具类。

        Method method = ReflectionUtils.findMethod(User.class, "getUserName").get();
        System.out.println(method);

23.获取指定方法的参数类型

有时需要获取指定方法的参数。此时可以使用ReflectionUtils工具类。
注意：返回的Method对象是指定类的指定方法。
建议：使用ReflectionUtils工具类。

        Method method1 = ReflectionUtils.findMethod(User.class, "setUserName", String.class).get();
        System.out.println(method1.getParameterTypes()[0]);

24. MD5加密

有时需要对字符串进行MD5加密。此时可以使用DigestUtils工具类。
注意：返回的MD5加密后的字符串是一个String。
建议：使用DigestUtils工具类。

        String str3 = "hello";
        String md5Str = DigestUtils.md5Hex(str3);
        System.out.println(md5Str);

25.SHA256加密

有时需要对字符串进行SHA256加密。此时可以使用DigestUtils工具类。
注意：返回的SHA256加密后的字符串是一个String。
建议：使用DigestUtils工具类。

        String str4 = "hello";
        String sha256Str = DigestUtils.sha256Hex(str4);
        System.out.println(sha256Str);

26.Hutool工具类https://www.hutool.cn/就maven安装方式做个简单介绍：
在项目的pom.xml的dependencies中加入以下内容:

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

我这里就利用hutool对日期处理进行实例展示，其它的大家可以参照官网进行学习：

有时需要处理日期。此时可以使用DateUtil工具类。
注意：DateUtil工具类提供了很多方法，可以处理日期。
建议：使用hutool-DateUtil工具类提供了很多方法工具类。

       // 获取当前日期
        System.out.println(DateUtil.now());
        // 字符串日期转指定格式日期
        Date date = DateUtil.parse("2021-01-01 12:00:00", "yyyy-MM-dd HH:mm:ss");
        System.out.println(date);
        // 日期格式化
        String formatDate = DateUtil.format(date, "yyyy-MM-dd HH:mm:ss");
        System.out.println(formatDate);
        // 日期加减
        Date date1 = DateUtil.offsetDay(date, 1);
        System.out.println(date1);
        // 日期比较
        int compareDate = DateUtil.compare(date, date1);
        System.out.println(compareDate);
        // 日期计算
        Date date2 = DateUtil.beginOfYear(date);
        System.out.println(date2);
        Date date3 = DateUtil.endOfYear(date);
        System.out.println(date3);
        // 日期计算
        Date date4 = DateUtil.beginOfMonth(date);
        System.out.println(date4);
        Date date5 = DateUtil.endOfMonth(date);
        System.out.println(date5);
        // 日期计算
        Date date6 = DateUtil.beginOfDay(date);
        System.out.println(date6);
        Date date7 = DateUtil.endOfDay(date);
        System.out.println(date7);

结论

在本篇文章中，我们深入探讨了多个实用的Java工具类，展示了如何利用这些类来简化编程工作。无论是通过Objects来进行对象的检查与操作，还是使用StringUtils进行字符串的处理，抑或是借助BeanUtils与ReflectionUtils进行对象属性的复制和反射操作，这些工具类都为我们提供了强大的支持。此外，DigestUtils则让数据加密变得简单高效,而hutool工具类我们只对日期处理进行介绍，从而解决我们日常工作日期转换的处理，hutool中还有许多封装的方法及类库,有兴趣的小伙伴可以继续参照官网文档进行学习和探索。