探索实用的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);
控制台输出：
ASC-排序后:[1, 2, 3]
DESC-排序后:[3, 2, 1]
随机排序后:[3, 1, 2]

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
最小值:1

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);
控制台输出：
不可修改集合:[2, 1, 3]

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);
控制台输出：
[2, 1, 3]

集合工具类
对于集合操作，除了前面提到的Collections工具类，CollectionUtils工具类也非常常用。
目前，比较主流的有apache中的org.apache.commons.collections包下的CollectionUtils工具类。
<!--collections依赖-->
<dependency>
    <groupId>commons-collections</groupId>
    <artifactId>commons-collections</artifactId>
    <version>3.2.2</version>
</dependency>
6. 检查集合是否为空
// 有时需要检查集合是否为空。可以使用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);
控制台输出：
并集:[1, 2, 3, 4]
交集:[2]
对称差:[1, 3, 4]
差集:[1, 3]

Guava 是一个由 Google 提供的开源库，其中包含了一系列用于 Java 的实用工具，比如集合（Collections）
、缓存（Caching）、并发（Concurrency）、常用类（Utility classes）等。
在 Maven 项目中添加 Guava 依赖，你需要在项目的 pom.xml 文件中添加以下内容：
<!-- 添加 Guava 库 -->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.0.1-jre</version> <!-- 请使用最新的稳定版本 -->
</dependency>
8. 快速初始化集合
// 有时需要快速初始化集合。此时可以使用Arrays.asList方法。
// 注意：返回的集合是Arrays内部类，不能修改集合元素，否则会抛出UnsupportedOperationException异常
// 建议：使用Lists.newArrayList方法获取集合。
List<Integer> list5 = Lists.newArrayList(1, 2, 3);
System.out.println("快速初始化集合:"+list5);
控制台输出：
快速初始化集合:[1, 2, 3]

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);
控制台输出：
笛卡尔积:[[1, 3], [1, 4], [2, 3], [2, 4]]

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);
控制台输出：
分解:[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]

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);
控制台输出：
流处理:[A, B, C]

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);
控制台输出：
反转:[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

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));
控制台输出：
检查两个对象是否相等:true

16.获取对象的hashCode
// 有时需要获取对象的hashCode。此时可以使用Objects工具类。
// 注意：返回的hashCode是一个int值。
// 建议：使用Objects工具类。
String str = "hello";
System.out.println("获取对象的hashCode:"+Objects.hashCode(str));
控制台输出：
获取对象的hashCode:99162322

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));
控制台输出：
false
true
false
true

18. 拆分字符串
// 有时需要拆分字符串。此时可以使用StringUtils工具类。
// 注意：返回的拆分后的字符串是一个String[]。
// 建议：使用StringUtils工具类。
String itemStr = "a,b,c";
System.out.println(StringUtils.split(itemStr, ","));
System.out.println(itemStr.split(","));
控制台输出：
[Ljava.lang.String;@58651fd0
[Ljava.lang.String;@4520ebad

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+"));
控制台输出：
true
false
false
true

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);
控制台输出：
a,b,c
a,b,c

21.复制对象属性
// 有时需要复制对象属性。此时可以使用BeanUtils工具类。
// 注意：返回的复制后的对象是原对象的引用。
// 建议：使用BeanUtils工具类。
User user = new User();
user.setUserName("admin");
user.setRealName("管理员");
User user1 = new User();
BeanUtils.copyProperties(user, user1);
System.out.println(user1);
控制台输出：
User(userName=admin, realName=管理员, orgTreeName=null, standardCode=null, remark=null)

22.获取指定类的指定方法
// 有时需要获取指定类的指定方法。此时可以使用ReflectionUtils工具类。
// 注意：返回的Method对象是指定类的指定方法。
// 建议：使用ReflectionUtils工具类。
Method method = ReflectionUtils.findMethod(User.class, "getUserName").get();
System.out.println(method);
控制台输出：
public java.lang.String com.songwp.domain.excel.User.getUserName()

23.获取指定方法的参数类型
// 有时需要获取指定方法的参数。此时可以使用ReflectionUtils工具类。
// 注意：返回的Method对象是指定类的指定方法。
// 建议：使用ReflectionUtils工具类。
Method method1 = ReflectionUtils.findMethod(User.class, "setUserName", String.class).get();
System.out.println(method1.getParameterTypes()[0]);
控制台输出：
class java.lang.String

24.MD5加密
// 有时需要对字符串进行MD5加密。此时可以使用DigestUtils工具类。
// 注意：返回的MD5加密后的字符串是一个String。
// 建议：使用DigestUtils工具类。
String str3 = "hello";
String md5Str = DigestUtils.md5Hex(str3);
System.out.println(md5Str);
控制台输出：
5d41402abc4b2a76b9719d911017c592

25.SHA256加密
// 有时需要对字符串进行SHA256加密。此时可以使用DigestUtils工具类。
// 注意：返回的SHA256加密后的字符串是一个String。
// 建议：使用DigestUtils工具类。
String str4 = "hello";
String sha256Str = DigestUtils.sha256Hex(str4);
System.out.println(sha256Str);
控制台输出：
2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824

26.Hutool工具类
Hutool是一个功能丰富且易用的Java工具库，涵盖了字符串、数字、集合、编码、日期、文件、IO、加密、数据库JDBC、JSON、HTTP客户端等功能。
我现在就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);
控制台输出：
2024-12-05 15:49:55
2021-01-01 12:00:00
2021-01-01 12:00:00
2021-01-02 12:00:00
-1
2021-01-01 00:00:00
2021-12-31 23:59:59
2021-01-01 00:00:00
2021-01-31 23:59:59
2021-01-01 00:00:00
2021-01-01 23:59:59

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