这九个工具库让我的 Java 开发效率提升了80%-51CTO.COM

在 Java 语言的庞大体系中，有很多不错的工具类，能够大大提升我们的开发效率。但如果你不了解它们，就很可能会重复编写一些类似的代码。这不仅浪费时间，而且你写的可能还不如现有的好。今天，我决定和大家分享一些我经常使用的工具类，希望对你们有所帮助。

一、Collections

首先是 java.util 包下的 Collections 类。这个类主要用于操作集合，我个人非常喜欢使用它。以下是一些常用功能：

1. 排序

在工作中，经常需要对集合进行排序。让我们看看如何使用 Collections 工具实现升序和降序排列：

List<Integer> list = new ArrayList<>();
list.add(2);
list.add(1);
list.add(3);
Collections.sort(list); //升序
System.out.println(list);
Collections.reverse(list); //降序
System.out.println(list);

输出：

[1, 2, 3]
[3, 2, 1]

2. 获取最大值或最小值

有时需要在集合中找到最大值或最小值，这时可以使用 Collections 的 max 和 min 方法。例如：

List<Integer> list = new ArrayList<>();
list.add(2);
list.add(1);
list.add(3);
Integer max = Collections.max(list);
Integer min = Collections.min(list);
System.out.println(max);
System.out.println(min);

输出：

3
1

3. 返回空集合

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

private List<Integer> fun(List<Integer> list) {
    if (list == null || list.size() == 0) {
        return Collections.emptyList();
    }
    return list;
}

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

为了防止后续程序修改某个集合的结果，有时我们需要将某个集合定义为不可修改的。这可以通过使用 Collections 的 unmodifiablexxx 方法轻松实现：

List<Integer> list = new ArrayList<>();
list.add(2);
list.add(1);
list.add(3);
List<Integer> integers = Collections.unmodifiableList(list);
integers.add(4);
System.out.println(integers);

输出：

Exception in thread "main" java.lang.UnsupportedOperationException
    at java.base/java.util.Collections$UnmodifiableCollection.add(Collections.java:1092)
    at com.spring.demo.DemoApplication.main(DemoApplication.java:46)

5. 转换为线程安全的集合

我们都知道，Java 中的许多集合，如 ArrayList、LinkedList、HashMap、HashSet 等，都不是线程安全的。换句话说，在多线程环境中，向这些集合中添加数据存在线程安全问题。这时，可以使用 Collections 的 synchronizedxxx 方法直接将这些线程不安全的集合转换为线程安全的集合。例如：

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

它的底层实现会创建 SynchronizedRandomAccessList 或 SynchronizedList 类。这两个类的许多方法都会用 synchronized 加锁。

Collections 工具类中还有许多常用方法，这里就不一一介绍了。

二、CollectionUtils

对于集合操作，除了前面提到的 Collections 工具类，CollectionUtils 工具类也非常常用。目前，比较主流的是 apache 的 org.apache.commons.collections 包下的 CollectionUtils 工具类。

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

它提供了许多方法，例如：

当然，Spring 框架的 org.springframework.util 包下也有 CollectionUtils 工具类。不过，我个人推荐使用 apache 包下的 CollectionUtils 工具类，因为它的工具更多且更全面。举个简单的例子，Spring 中的 CollectionUtils 工具类没有判断集合是否不为空的方法，而 apache 中的有。接下来，我们以 apache 中的 CollectionUtils 工具类为例，介绍一些常用方法。

1. 检查集合是否为空

CollectionUtils 工具类的 isEmpty 方法可以轻松判断集合是否为空，isNotEmpty 方法判断集合是否不为空。

List<Integer> list = new ArrayList<>();
list.add(2);
list.add(1);
list.add(3);
if (CollectionUtils.isEmpty(list)) {
    System.out.println("Collection is empty.");
}
if (CollectionUtils.isNotEmpty(list)) {
    System.out.println("Collection is not empty");
}

2. 对两个集合进行操作

有时我们需要对两个已有的集合进行操作，比如取交集或并集。

List<Integer> list = new ArrayList<>();
list.add(2);
list.add(1);
list.add(3);
List<Integer> list2 = new ArrayList<>();
list2.add(2);
list2.add(4);
//获取并集
Collection<Integer> unionList = CollectionUtils.union(list, list2);
System.out.println(unionList);
//获取交集
Collection<Integer> intersectionList = CollectionUtils.intersection(list, list2);
System.out.println(intersectionList);
//获取交集的补集
Collection<Integer> disjunctionList = CollectionUtils.disjunction(list, list2);
System.out.println(disjunctionList);
//获取差集
Collection<Integer> subtractList = CollectionUtils.subtract(list, list2);
System.out.println(subtractList);

执行结果：

[1, 2, 3, 4]
[2]
[1, 3, 4]
[1, 3]

三、Lists

如果你引入 com.google.guava 的依赖，会得到很多有用的工具类。这里推荐一个 com.google.common.collect 包下的集合工具：Lists。

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

1. 快速初始化集合

有时，我们想初始化集合中的一些元素，这时可以使用 Lists 的 newArrayList 方法。例如：

List<Integer> list = Lists.newArrayList(1, 2, 3);

这比直接创建一个列表然后逐个添加元素更方便。执行结果：

[1, 2, 3]

2. 笛卡尔积

如果你想对两个集合进行笛卡尔积操作，Lists 的 cartesianProduct 方法可以帮你实现：

List<Integer> list1 = Lists.newArrayList(1, 2, 3);
List<Integer> list2 = Lists.newArrayList(4, 5);
List<List<Integer>> productList = Lists.cartesianProduct(list1, list2);
System.out.println(productList);

执行结果：

[[1, 4], [1, 5], [2, 4], [2, 5], [3, 4], [3, 5]]

3. 分割集合

如果你想将一个大集合分割成几个小集合，可以使用 Lists 的 partition 方法：

List<Integer> list = Lists.newArrayList(1, 2, 3, 4, 5);
List<List<Integer>> partitionList = Lists.partition(list, 2);
System.out.println(partitionList);

执行结果：

[[1, 2], [3, 4], [5]]

在这个例子中，列表有 5 条数据。我将列表集合分成了 3 份，每份大小为 2，即变成了 3 个小集合。这是我最喜欢的方法之一，我在项目中经常使用。

4. 流处理

如果我们想对集合内的元素进行操作，可以使用 Lists 的 transform 方法。例如：

List<String> list = Lists.newArrayList("a", "b", "c");
List<String> transformList = Lists.transform(list, x -> x.toUpperCase());
System.out.println(transformList);

小写字母被转换为大写字母。执行结果：

[A, B, C]

5. 反转顺序

Lists 有一个 reverse() 方法用于反转顺序。例如：

List<Integer> list = Lists.newArrayList(3, 1, 2, 5, 4);
List<Integer> reverseList = Lists.reverse(list);
System.out.println(reverseList);

执行结果：

[4, 5, 2, 1, 3]

Lists 还有其他有用的工具，这里只是举几个例子，感兴趣的朋友可以自行研究。

四、Objects

在 jdk7 之后，提供了 Objects 工具类，我们可以通过它对对象进行操作。

1. 检查对象是否为空

在 Java 中，一切皆对象。检查对象是否为空可以说是无处不在。Objects 的 isNull 方法检查对象是否为空，nonNull 方法检查对象是否不为空。例如：

Integer i = new Integer(10);
if (Objects.isNull(i)) {
    System.out.println("Object is null");
}
if (Objects.nonNull(i)) {
    System.out.println("Object is not null");
}

2. 对象为空时抛出异常

如果我们想在对象为空时抛出空指针异常，可以使用 Objects 的 requireNonNull 方法。例如：

Integer i = new Integer(128);
Objects.requireNonNull(i);
Objects.requireNonNull(i, "Parameters cannot be null");
Objects.requireNonNull(i, () -> "Parameters cannot be null");

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

我们经常需要检查两个对象是否相等。Objects 为我们提供了 equals 方法，可以很方便地实现：

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

执行结果：

true

但是使用这个方法时有一个坑。例如，如果将例子改为：

Integer i = new Integer(1);
Long l = new Long(1);
System.out.println(Objects.equals(i, l));

执行结果：

false

你知道为什么输出为 false 吗？可以在评论区交流。

4. 获取对象的哈希码

如果你想获取某个对象的哈希码，可以使用 Objects 的 hashCode 方法。例如：

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

执行结果：

关于 Objects 的内容就介绍到这里，更多的方法可以自行研究。

五、StringUtils

字符串在我们的日常工作中使用得非常频繁。在我们的代码中，经常需要检查字符串是否为空、转换大小写、分割字符串、比较字符串、去除多余空格、连接字符串、使用正则表达式等等。如果我们只使用 String 类提供的方法，就需要手动编写大量额外的代码，既耗时又费力。作为程序员，当然要学会偷懒。现在有一个现成的工具类，即 org.apache.commons.lang3 包下的 StringUtils 工具类，它为我们提供了非常多操作 String 的方法。

1. 检查字符串是否为空

实际上，对于空字符串，不仅有 null，还有“”、“ ”、“null”等多种情况。StringUtils 为我们提供了多个静态方法来检查字符串是否为空。例如：

String str1 = null;
String str2 = "";
String str3 = " ";
String str4 = "abc";
System.out.println(StringUtils.isEmpty(str1));
System.out.println(StringUtils.isEmpty(str2));
System.out.println(StringUtils.isEmpty(str3));
System.out.println(StringUtils.isEmpty(str4));
System.out.println("-------------------------------------");
System.out.println(StringUtils.isNotEmpty(str1));
System.out.println(StringUtils.isNotEmpty(str2));
System.out.println(StringUtils.isNotEmpty(str3));
System.out.println(StringUtils.isNotEmpty(str4));
System.out.println("-------------------------------------");
System.out.println(StringUtils.isBlank(str1));
System.out.println(StringUtils.isBlank(str2));
System.out.println(StringUtils.isBlank(str3));
System.out.println(StringUtils.isBlank(str4));
System.out.println("-------------------------------------");
System.out.println(StringUtils.isNotBlank(str1));
System.out.println(StringUtils.isNotBlank(str2));
System.out.println(StringUtils.isNotBlank(str3));
System.out.println(StringUtils.isNotBlank(str4));

输出：

true
true
false
false
false
false
true
true
true
true
true
false
false
false
false
true

示例中的四个空检查方法：isEmpty、isNotEmpty、isBlank 和 isNotBlank。你可以根据实际情况使用这些方法。建议优先使用 isBlank 和 isNotBlank 方法，因为它们会考虑更多情况。

2. 分割字符串

分割字符串是一个常见需求。如果直接使用 String 类的 split 方法，可能会出现空指针异常。

String str1 = null;
System.out.println(StringUtils.split(str1, ","));
System.out.println(str1.split(","));

输出：

Exception in thread "main" java.lang.NullPointerException
    at java.base/java.util.Objects.requireNonNull(Objects.java:221)
    at java.base/java.util.regex.Pattern.split(Pattern.java:1269)
    at java.base/java.lang.String.split(String.java:2392)
    at com.spring.demo.DemoApplication.main(DemoApplication.java:39)

使用 StringUtils 的 split 方法会返回 null，而使用 String 的 split 方法会报指针异常。

3. 检查是否为纯数字

给定一个字符串，要检查它是否为纯数字，可以使用 isNumeric 方法。例如：

String str1 = "123";
String str2 = "123abc";
String str3 = "0.33";
System.out.println(StringUtils.isNumeric(str1));
System.out.println(StringUtils.isNumeric(str2));
System.out.println(StringUtils.isNumeric(str3));

输出：

true
false
false

4. 将集合连接成字符串

有时，我们需要将集合的内容连接成一个字符串然后输出，这时可以使用 join 方法。例如：

List<String> list = Lists.newArrayList("a", "b", "c");
List<Integer> list2 = Lists.newArrayList(1, 2, 3);
System.out.println(StringUtils.join(list, ","));
System.out.println(StringUtils.join(list2, " "));

输出：

a,b,c
1 2 3

还有很多实用的方法，这里就不一一介绍了。

六、BeanUtils

Spring 为我们提供了一个用于 JavaBean 的工具类，它在 org.springframework.beans 包下，名字是：BeanUtils。

1. 复制对象属性

你是否遇到过这样的需求：将某个对象的所有属性复制到另一个对象。这时可以使用 BeanUtils 的 copyProperties 方法。例如：

User user1 = new User();
user1.setId(1L);
user1.setName("Dylan");
user1.setAddress("Hong Kong");
User user2 = new User();
BeanUtils.copyProperties(user1, user2);
System.out.println(user2);

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

如果你想获取某个类的指定方法以便后续操作，可以使用 BeanUtils 的 findDeclaredMethod 方法。例如：

Method declaredMethod = BeanUtils.findDeclaredMethod(User.class, "getId");
System.out.println(declaredMethod.getName());

3. 获取指定方法的参数

如果你想获取某个方法的参数，可以使用 BeanUtils 的 findPropertyForMethod 方法。例如：

Method declaredMethod = BeanUtils.findDeclaredMethod(User.class, "getId");
PropertyDescriptor propertyForMethod = BeanUtils.findPropertyForMethod(declaredMethod);
System.out.println(propertyForMethod.getName());

还有很多实用的方法，这里就不一一介绍了。

七、ReflectionUtils

有时，我们在项目中需要使用反射功能。如果使用最原始的方法开发，代码量会非常大且麻烦，需要处理大量异常和访问权限问题。好消息是，Spring 为我们提供了一个 ReflectionUtils 工具类，它在 org.springframework.util 包下。

1. 获取方法

如果你想获取某个类的某个方法，可以使用 ReflectionUtils 类的 findMethod 方法。例如：

Method method = ReflectionUtils.findMethod(User.class, "getId");

2. 获取字段

如果你想获取某个类的某个字段，可以使用 ReflectionUtils 类的 findField 方法。例如：

Field field = ReflectionUtils.findField(User.class, "id");

3. 执行方法

如果你想通过反射调用某个方法并传递参数，可以使用 ReflectionUtils 类的 invokeMethod 方法。例如：

ReflectionUtils.invokeMethod(method, springContextsUtil.getBean(beanName), param);

4. 检查字段是否为常量

如果你想检查某个字段是否为常量，可以使用 ReflectionUtils 类的 isPublicStaticFinal 方法。例如：

Field field = ReflectionUtils.findField(User.class, "id");
System.out.println(ReflectionUtils.isPublicStaticFinal(field));

5. 检查是否为 equals 方法

如果你想检查某个方法是否为 equals 方法，可以使用 ReflectionUtils 类的 isEqualsMethod 方法。例如：

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

还有很多实用的方法，这里就不一一介绍了。

八、DigestUtils

有时，我们需要对数据进行加密，比如使用 md5 或 sha256。我们可以使用 Apache 的 org.apache.commons.codec.digest 包下的 DigestUtils 类。

1. MD5 加密

如果你想使用 MD5 加密数据，可以使用 DigestUtils 的 md5Hex 方法。例如：

String md5Hex = DigestUtils.md5Hex("Dylan");
System.out.println(md5Hex);

2. SHA256 加密

如果你想使用 SHA256 加密数据，可以使用 DigestUtils 的 sha256Hex 方法。例如：

String md5Hex = DigestUtils.sha256Hex("Dylan");
System.out.println(md5Hex);

这个工具类还有许多其他加密方法：

九、HttpStatus

很多时候，我们会在代码中定义 HTTP 返回码。例如，正常接口返回 200，异常返回 500，如果接口找不到则返回 404。

private int SUCCESS_CODE = 200;
private int ERROR_CODE = 500;
private int NOT_FOUND_CODE = 404;

实际上，org.springframework.http 包下的 HttpStatus 枚举或 org.apache.http 包下的 HttpStatus 接口已经为我们定义了常用的 HTTP 返回码，我们可以直接使用，真的不需要重新定义。以下是 HttpStatus 类的部分内容：

总结

在这篇文章中，我介绍了 Java 开发中 9 个非常实用的工具类，它们可以帮助我们提高开发效率，减少重复代码，并简化日常的开发任务。从集合操作到字符串处理，从对象操作到反射机制，再到数据加密和 HTTP 状态码处理，这些工具类提供了强大而灵活的功能，让我们能够更加专注于业务逻辑的实现，而不是底层细节的处理。