Java常用类库大全（学习笔记）持续更新中

一、博主前言

相信大家在搬砖的日常工作中总会遇到很多相对麻烦但又不是很棘手的问题，例如json数据的处理，快速生产api文档工具的选择，读取excel数据等等场景，面对这些小问题，大佬可能选择现场手写一个工具类解决问题，但对于像我这种懒惰的程序员来说，就希望能有一款拿来即用的工具帮我解决问题，得益于Java的火热，也确实有很多使用类库或者api能帮我解决问题。但是紧接着新的问题又来了，这些api怎么调用呢？怎么选择呢？为此，我打算写一遍博客，把我在开发过程中所用到的好用的类库或者api的使用方式记录下来。当然，目前市场上已经有了很多整合的方案，例如HuTool，Guava等。

二、常用类库

2.1 项目日志相关类库

2.1.1 Logback（推荐）

Logback 是 Log4j 的一个分支，由 Log4j 的原始作者创建，旨在作为 Log4j 的后继者，提供了更好的性能和更多的功能。因springboot项目默认采用Logback作为日志插件，所以只需要在 application.properties 或者 application.yml文件中配置日志级别和其他选项，不需要在pom.xml中额外引入依赖。

1.配置文件

application.properties文件（2选1）：

# 设置全局日志级别
logging.level.root=INFO# 设置特定包的日志级别
logging.level.com.example=DEBUG# 日志文件路径(代码所在文件下)
logging.file.name=logs/app.log# 日志文件的最大大小
logging.file.max-size=10MB# 日志文件的最大历史记录数量（2选1）
logging.file.max-history=30

application.yml文件（2选1）：

logging:level:root: INFOcom.example: DEBUGfile:name: logs/app.log(代码所在文件下)max-size: 10MBmax-history: 30

配置好之后，可以使用两种方式调用

使用 Lombok 的 @Slf4j 注解（推荐）：

@Slf4j
@Service
public class TestHelloServiceImpl implements TestHelloService {@Overridepublic String showHello() {System.out.println("hello world");log.info("hello world");return "hello world";}
}

2.创建演示

手动创建 Logger 实例（不推荐）：

import org.springframework.stereotype.Service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;@Service
public class ExampleService {private static final Logger logger = LoggerFactory.getLogger(ExampleService.class);public void doSomething() {logger.info("Doing something...");}
}

如果你需要更详细的日志配置，可以在 resources 目录下创建 logback-spring.xml 文件。Spring Boot 会自动识别并应用这个配置文件。

logback-spring.xml 示例：

<configuration><appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"><encoder><pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern></encoder></appender><appender name="FILE" class="ch.qos.logback.core.FileAppender"><file>logs/app.log</file><encoder><pattern>%date %level [%thread] %logger{10} [%file:%line] %msg%n</pattern></encoder></appender><root level="info"><appender-ref ref="STDOUT" /><appender-ref ref="FILE" /></root>
</configuration>

2.1.2 Log4j2

Log4j 2.0是一个几乎从头开始重新编写的版本，旨在修复Log4j 1.x中的体系结构和设计上的基本问题，并且性能得到了显著提升。

1.添加依赖

在pom.xml中添加Log4j2的依赖。由于Spring Boot默认使用logback作为日志框架，你需要排除默认的logback依赖并添加Log4j2依赖。

   <dependencies><!-- 其他依赖 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId><exclusions><exclusion><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-logging</artifactId></exclusion></exclusions></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-log4j2</artifactId></dependency><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-api</artifactId><version>2.17.1</version></dependency><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-core</artifactId><version>2.17.1</version></dependency><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-slf4j-impl</artifactId><version>2.17.1</version></dependency><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-jul</artifactId><version>2.17.1</version></dependency></dependencies>

2.配置Log4j2

在项目的src/main/resources目录下创建或修改log4j2.xml文件，配置Log4j2的具体设置（默认采用xml，其他方式这里不再赘述）。例如：

   <?xml version="1.0" encoding="UTF-8"?><Configuration status="WARN"><Appenders><Console name="Console" target="SYSTEM_OUT"><PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/></Console><File name="LogFile" fileName="logs/app.log"><PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/></File></Appenders><Loggers><Root level="info"><AppenderRef ref="Console"/><AppenderRef ref="LogFile"/></Root></Loggers></Configuration>

3.使用日志

在Spring Boot应用中使用日志，可以通过@Slf4j注解自动注入Logger对象，然后使用这个对象进行日志记录。

   import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;import org.springframework.stereotype.Service;@Servicepublic class MyService {private static final Logger logger = LogManager.getLogger(MyService.class);public void doSomething() {logger.info("Doing something...");// 其他逻辑}}

2.2 json数据处理相关类库

2.2.1 Jackson

Jackson 是一个用于处理 JSON 的 Java 库，广泛应用于将 Java 对象转换为 JSON 字符串以及从 JSON 字符串反序列化为 Java 对象。以下是 Jackson 的基本使用方法：

1.添加依赖

<dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId><version>2.13.3</version>
</dependency>

2.序列化（Java对象转字符串）

import com.fasterxml.jackson.databind.ObjectMapper;public class Main {public static void main(String[] args) {try {ObjectMapper objectMapper = new ObjectMapper();User user = new User("张三", 25);String jsonString = objectMapper.writeValueAsString(user);System.out.println(jsonString); // 输出: {"name":"张三","age":25}} catch (Exception e) {e.printStackTrace();}}
}

3.反序列化（字符串转Java对象）

import com.fasterxml.jackson.databind.ObjectMapper;public class Main {public static void main(String[] args) {try {ObjectMapper objectMapper = new ObjectMapper();String jsonString = "{\"name\":\"李四\",\"age\":30}";User user = objectMapper.readValue(jsonString, User.class);System.out.println(user.getName()); // 输出: 李四System.out.println(user.getAge());  // 输出: 30} catch (Exception e) {e.printStackTrace();}}
}

2.2.2 FastJSON（推荐）

FastJSON 是阿里巴巴开源的一个高性能的 JSON 库，用于 Java 语言。它提供了丰富的功能，包括 JSON 解析、序列化、反序列化等。FastJSON 的性能非常高，广泛应用于各种 Java 应用中。

1.添加依赖

<dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.2.78</version> <!-- 请使用最新版本 -->
</dependency>

2.序列化和反序列化（Java对象与JSON字符串互转）

import com.alibaba.fastjson.JSON;
import java.util.List;
import java.util.ArrayList;public class Main {public static void main(String[] args) {List<String> hobbies = new ArrayList<>();hobbies.add("阅读");hobbies.add("编程");User user = new User("张三", 25, hobbies);String jsonString = JSON.toJSONString(user);System.out.println(jsonString); // 输出: {"name":"张三","age":25,"hobbies":["阅读","编程"]}User parsedUser = JSON.parseObject(jsonString, User.class);System.out.println(parsedUser.getName()); // 输出: 张三System.out.println(parsedUser.getAge());  // 输出: 25System.out.println(parsedUser.getHobbies()); // 输出: [阅读, 编程]}
}

3.Json转Map

import com.alibaba.fastjson.JSON;
import java.util.Map;public class Main {public static void main(String[] args) {String jsonString = "{\"name\":\"张三\",\"age\":25}";Map<String, Object> map = JSON.parseObject(jsonString, Map.class);System.out.println(map.get("name")); // 输出: 张三System.out.println(map.get("age"));  // 输出: 25}
}

4.处理数组和集合

import com.alibaba.fastjson.JSON;
import java.util.List;
import java.util.ArrayList;public class Main {public static void main(String[] args) {List<User> users = new ArrayList<>();users.add(new User("张三", 25));users.add(new User("李四", 30));String jsonString = JSON.toJSONString(users);System.out.println(jsonString); // 输出: [{"name":"张三","age":25},{"name":"李四","age":30}]}
}

2.3 Apache Commons Lang 库

2.3.1 StringUtils

StringUtils 是 Apache Commons Lang 库中的一个实用工具类，提供了大量处理字符串的方法。这些方法可以帮助你更方便地进行字符串操作，如空值检查、字符串拼接、截取、替换等。

1.添加依赖

<dependency><groupId>org.apache.commons</groupId><artifactId>commons-lang3</artifactId><version>3.12.0</version> <!-- 请使用最新版本 -->
</dependency>

2.空值检查

StringUtils.isEmpty(String str)：检查字符串是否为空或 null。
StringUtils.isNotEmpty(String str)：检查字符串是否不为空且不为 null。
StringUtils.isBlank(String str)：检查字符串是否为空、null 或仅包含空白字符。
StringUtils.isNotBlank(String str)：检查字符串是否不为空、不为 null 且不包含仅空白字符。

3.字符串拼接

join(Iterable<?> iterable, char separator)：将可迭代对象中的元素连接成一个字符串，使用指定的分隔符。
join(Object[] array, char separator)：将数组中的元素连接成一个字符串，使用指定的分隔符。

import org.apache.commons.lang3.StringUtils;public class Main {public static void main(String[] args) {String[] array = {"apple", "banana", "cherry"};List<String> list = Arrays.asList("apple", "banana", "cherry");System.out.println(StringUtils.join(array, ", ")); // 输出: apple, banana, cherrySystem.out.println(StringUtils.join(list, ", "));  // 输出: apple, banana, cherry}
}

4.字符串截取

substring(String str, int start)：从指定位置开始截取字符串。
substring(String str, int start, int end)：从指定位置开始到结束位置截取字符串。
left(String str, int len)：从左边截取指定长度的字符串。
right(String str, int len)：从右边截取指定长度的字符串。

import org.apache.commons.lang3.StringUtils;public class Main {public static void main(String[] args) {String str = "Hello, World!";System.out.println(StringUtils.substring(str, 7));       // 输出: World!System.out.println(StringUtils.substring(str, 0, 5));    // 输出: HelloSystem.out.println(StringUtils.left(str, 5));            // 输出: HelloSystem.out.println(StringUtils.right(str, 6));           // 输出: World!}
}

5.字符串替换

replace(String str, String searchStr, String replacement)：将字符串中的某个子字符串替换为另一个字符串。
replaceAll(String str, String searchRegex, String replacement)：使用正则表达式将字符串中的匹配项替换为另一个字符串。

import org.apache.commons.lang3.StringUtils;public class Main {public static void main(String[] args) {String str = "Hello, World!";System.out.println(StringUtils.replace(str, "World", "Java")); // 输出: Hello, Java!System.out.println(StringUtils.replaceAll(str, "o", "O"));     // 输出: HellO, WOrld!}
}

6.字符串修剪

trim(String str)：去除字符串两端的空白字符。
strip(String str, String stripChars)：去除字符串两端指定的字符。

import org.apache.commons.lang3.StringUtils;public class Main {public static void main(String[] args) {String str1 = "  Hello, World!  ";String str2 = "###Hello, World!###";System.out.println(StringUtils.trim(str1));              // 输出: Hello, World!System.out.println(StringUtils.strip(str2, "#"));        // 输出: Hello, World!}
}

7.字符串重复

repeat(String str, int repeat)：将字符串重复指定次数。

import org.apache.commons.lang3.StringUtils;public class Main {public static void main(String[] args) {String str = "abc";System.out.println(StringUtils.repeat(str, 3));          // 输出: abcabcabc}
}

2.3.2 NumberUtils

NumberUtils 是 Apache Commons Lang 库中的一个实用工具类，提供了大量处理数字的方法。这些方法可以帮助你更方便地进行数字转换、验证和操作。

1.添加依赖

<dependency><groupId>org.apache.commons</groupId><artifactId>commons-lang3</artifactId><version>3.12.0</version> <!-- 请使用最新版本 -->
</dependency>

2.数字转换

toInt(String str)：将字符串转换为整数，如果转换失败返回 0。
toInt(String str, int defaultValue)：将字符串转换为整数，如果转换失败返回默认值。
toDouble(String str)：将字符串转换为双精度浮点数，如果转换失败返回 0.0。
toDouble(String str, double defaultValue)：将字符串转换为双精度浮点数，如果转换失败返回默认值。

import org.apache.commons.lang3.math.NumberUtils;public class Main {public static void main(String[] args) {String str1 = "123";String str2 = "456.78";String str3 = "abc";System.out.println(NumberUtils.toInt(str1));             // 输出: 123System.out.println(NumberUtils.toInt(str3, -1));         // 输出: -1System.out.println(NumberUtils.toDouble(str2));          // 输出: 456.78System.out.println(NumberUtils.toDouble(str3, -1.0));    // 输出: -1.0}
}

3.数字验证

isCreatable(String str)：检查字符串是否可以转换为任意数字类型。
isDigits(String str)：检查字符串是否只包含数字字符。
isNumber(String str)：检查字符串是否可以转换为 Number 类型。

import org.apache.commons.lang3.math.NumberUtils;public class Main {public static void main(String[] args) {String str1 = "123";String str2 = "456.78";String str3 = "abc";System.out.println(NumberUtils.isCreatable(str1));       // 输出: trueSystem.out.println(NumberUtils.isCreatable(str2));       // 输出: trueSystem.out.println(NumberUtils.isCreatable(str3));       // 输出: falseSystem.out.println(NumberUtils.isDigits(str1));          // 输出: trueSystem.out.println(NumberUtils.isDigits(str2));          // 输出: falseSystem.out.println(NumberUtils.isDigits(str3));          // 输出: falseSystem.out.println(NumberUtils.isNumber(str1));          // 输出: trueSystem.out.println(NumberUtils.isNumber(str2));          // 输出: trueSystem.out.println(NumberUtils.isNumber(str3));          // 输出: false}
}

4.数字操作

max(Number… numbers)：返回一组数字中的最大值。
min(Number… numbers)：返回一组数字中的最小值。
createNumber(String str)：将字符串转换为 Number 类型，如果转换失败返回 null。

import org.apache.commons.lang3.math.NumberUtils;public class Main {public static void main(String[] args) {Integer[] numbers = {1, 2, 3, 4, 5};System.out.println(NumberUtils.max(numbers));            // 输出: 5System.out.println(NumberUtils.min(numbers));            // 输出: 1String str1 = "123";String str2 = "456.78";String str3 = "abc";Number number1 = NumberUtils.createNumber(str1);Number number2 = NumberUtils.createNumber(str2);Number number3 = NumberUtils.createNumber(str3);System.out.println(number1);                             // 输出: 123System.out.println(number2);                             // 输出: 456.78System.out.println(number3);                             // 输出: null}
}

5.其他方法

toByte(String str)：将字符串转换为字节，如果转换失败返回 0。
toByte(String str, byte defaultValue)：将字符串转换为字节，如果转换失败返回默认值。
toShort(String str)：将字符串转换为短整型，如果转换失败返回 0。
toShort(String str, short defaultValue)：将字符串转换为短整型，如果转换失败返回默认值。
toLong(String str)：将字符串转换为长整型，如果转换失败返回 0。
toLong(String str, long defaultValue)：将字符串转换为长整型，如果转换失败返回默认值。
toFloat(String str)：将字符串转换为单精度浮点数，如果转换失败返回 0.0f。
toFloat(String str, float defaultValue)：将字符串转换为单精度浮点数，如果转换失败返回默认值。

import org.apache.commons.lang3.math.NumberUtils;public class Main {public static void main(String[] args) {String str1 = "123";String str2 = "456.78";String str3 = "abc";System.out.println(NumberUtils.toByte(str1));            // 输出: 123System.out.println(NumberUtils.toByte(str3, (byte) -1)); // 输出: -1System.out.println(NumberUtils.toShort(str1));           // 输出: 123System.out.println(NumberUtils.toShort(str3, (short) -1)); // 输出: -1System.out.println(NumberUtils.toLong(str1));            // 输出: 123System.out.println(NumberUtils.toLong(str3, -1L));       // 输出: -1System.out.println(NumberUtils.toFloat(str2));           // 输出: 456.78System.out.println(NumberUtils.toFloat(str3, -1.0f));    // 输出: -1.0}
}

2.3.3 ArrayUtils

ArrayUtils 是 Apache Commons Lang 库中的一个实用工具类，提供了大量处理数组的方法。这些方法可以帮助你更方便地进行数组的操作，如添加、删除、查找、合并等。

1.添加依赖

<dependency><groupId>org.apache.commons</groupId><artifactId>commons-lang3</artifactId><version>3.12.0</version> <!-- 请使用最新版本 -->
</dependency>

2.数组添加

add(T[] array, T element)：在数组末尾添加一个元素，返回新的数组。
addAll(T[] array1, T… array2)：将两个数组合并为一个新的数组。

import org.apache.commons.lang3.ArrayUtils;public class Main {public static void main(String[] args) {Integer[] array1 = {1, 2, 3};Integer[] array2 = {4, 5};Integer[] newArray1 = ArrayUtils.add(array1, 4);Integer[] newArray2 = ArrayUtils.addAll(array1, array2);System.out.println(Arrays.toString(newArray1)); // 输出: [1, 2, 3, 4]System.out.println(Arrays.toString(newArray2)); // 输出: [1, 2, 3, 4, 5]}
}

3.数组删除

remove(T[] array, int index)：删除数组中指定索引的元素，返回新的数组。
removeElement(T[] array, T element)：删除数组中指定的元素，返回新的数组。

import org.apache.commons.lang3.ArrayUtils;public class Main {public static void main(String[] args) {Integer[] array = {1, 2, 3, 4, 5};Integer[] newArray1 = ArrayUtils.remove(array, 2);Integer[] newArray2 = ArrayUtils.removeElement(array, 3);System.out.println(Arrays.toString(newArray1)); // 输出: [1, 2, 4, 5]System.out.println(Arrays.toString(newArray2)); // 输出: [1, 2, 4, 5]}
}

4.数组查找

indexOf(T[] array, T valueToFind)：查找数组中指定元素的索引，如果未找到返回 -1。
contains(T[] array, T valueToFind)：检查数组是否包含指定的元素。

import org.apache.commons.lang3.ArrayUtils;public class Main {public static void main(String[] args) {Integer[] array = {1, 2, 3, 4, 5};int index = ArrayUtils.indexOf(array, 3);boolean contains = ArrayUtils.contains(array, 6);System.out.println(index);      // 输出: 2System.out.println(contains);   // 输出: false}
}

5.数组转换

toObject(int[] array)：将基本类型的数组转换为对象数组。
toPrimitive(Integer[] array)：将对象数组转换为基本类型的数组。

import org.apache.commons.lang3.ArrayUtils;public class Main {public static void main(String[] args) {int[] primitiveArray = {1, 2, 3};Integer[] objectArray = {1, 2, 3};Integer[] convertedToObject = ArrayUtils.toObject(primitiveArray);int[] convertedToPrimitive = ArrayUtils.toPrimitive(objectArray);System.out.println(Arrays.toString(convertedToObject)); // 输出: [1, 2, 3]System.out.println(Arrays.toString(convertedToPrimitive)); // 输出: [1, 2, 3]}
}

6.数组填充

fill(T[] array, T value)：将数组中的所有元素设置为指定的值。
fill(T[] array, int fromIndex, int toIndex, T value)：将数组中指定范围内的元素设置为指定的值。

import org.apache.commons.lang3.ArrayUtils;public class Main {public static void main(String[] args) {Integer[] array = {1, 2, 3, 4, 5};ArrayUtils.fill(array, 0);ArrayUtils.fill(array, 1, 3, 99);System.out.println(Arrays.toString(array)); // 输出: [0, 99, 99, 0, 0]}
}

7.数组反转

reverse(T[] array)：反转数组中的元素顺序。

import org.apache.commons.lang3.ArrayUtils;public class Main {public static void main(String[] args) {Integer[] array = {1, 2, 3, 4, 5};ArrayUtils.reverse(array);System.out.println(Arrays.toString(array)); // 输出: [5, 4, 3, 2, 1]}
}

2.3.4 CollectionUtils

CollectionUtils 是 Apache Commons Collections 库中的一个实用工具类，提供了大量处理集合的方法。这些方法可以帮助你更方便地进行集合的操作，如添加、删除、查找、合并等。

1.添加依赖

<dependency><groupId>org.apache.commons</groupId><artifactId>commons-collections4</artifactId><version>4.4</version> <!-- 请使用最新版本 -->
</dependency>

2.集合添加

addAll(Collection coll, T… elements)：将多个元素添加到集合中。
addAll(Collection coll, Collection<? extends T> elements)：将一个集合中的所有元素添加到另一个集合中。

import org.apache.commons.collections4.CollectionUtils;import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;public class Main {public static void main(String[] args) {List<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2, 3));List<Integer> list2 = new ArrayList<>(Arrays.asList(4, 5));CollectionUtils.addAll(list1, 6, 7);CollectionUtils.addAll(list1, list2);System.out.println(list1); // 输出: [1, 2, 3, 6, 7, 4, 5]}
}

3.集合删除

removeAll(Collection coll, Collection<?> elements)：从集合中删除指定的元素。
removeAll(Collection coll, T… elements)：从集合中删除指定的元素

import org.apache.commons.collections4.CollectionUtils;import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;public class Main {public static void main(String[] args) {List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));CollectionUtils.removeAll(list, Arrays.asList(3, 4));CollectionUtils.removeAll(list, 1, 5);System.out.println(list); // 输出: [2]}
}

4.集合查找

containsAny(Collection<?> coll1, Collection<?> coll2)：检查两个集合是否有交集。
containsAll(Collection<?> coll1, Collection<?> coll2)：检查第一个集合是否包含第二个集合中的所有元素。

import org.apache.commons.collections4.CollectionUtils;import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;public class Main {public static void main(String[] args) {List<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2, 3));List<Integer> list2 = new ArrayList<>(Arrays.asList(3, 4, 5));List<Integer> list3 = new ArrayList<>(Arrays.asList(6, 7, 8));boolean hasIntersection = CollectionUtils.containsAny(list1, list2);boolean containsAll = CollectionUtils.containsAll(list1, Arrays.asList(1, 2));System.out.println(hasIntersection); // 输出: trueSystem.out.println(containsAll);     // 输出: true}
}

5.集合合并

union(Collection coll1, Collection coll2)：返回两个集合的并集。
intersection(Collection coll1, Collection coll2)：返回两个集合的交集。
disjunction(Collection coll1, Collection coll2)：返回两个集合的差集（对称差）。

import org.apache.commons.collections4.CollectionUtils;import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;public class Main {public static void main(String[] args) {List<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2, 3));List<Integer> list2 = new ArrayList<>(Arrays.asList(3, 4, 5));List<Integer> union = CollectionUtils.union(list1, list2);List<Integer> intersection = CollectionUtils.intersection(list1, list2);List<Integer> disjunction = CollectionUtils.disjunction(list1, list2);System.out.println(union);         // 输出: [1, 2, 3, 4, 5]System.out.println(intersection);  // 输出: [3]System.out.println(disjunction);   // 输出: [1, 2, 4, 5]}
}

6.集合过滤

select(Collection input, Predicate predicate)：根据谓词筛选集合中的元素。
selectRejected(Collection input, Predicate predicate)：根据谓词筛选集合中不符合条件的元素。

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.Predicate;import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;public class Main {public static void main(String[] args) {List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));Predicate<Integer> evenPredicate = num -> num % 2 == 0;List<Integer> evenNumbers = CollectionUtils.select(list, evenPredicate);List<Integer> oddNumbers = CollectionUtils.selectRejected(list, evenPredicate);System.out.println(evenNumbers); // 输出: [2, 4]System.out.println(oddNumbers);  // 输出: [1, 3, 5]}
}

7.集合转换

transform(Collection input, Transformer<T, R> transformer)：将集合中的每个元素转换为另一种类型。

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.Transformer;import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;public class Main {public static void main(String[] args) {List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));Transformer<Integer, String> stringTransformer = num -> "Number: " + num;CollectionUtils.transform(list, stringTransformer);System.out.println(list); // 输出: [Number: 1, Number: 2, Number: 3, Number: 4, Number: 5]}
}

2.3.5 ObjectUtils

ObjectUtils 是 Apache Commons Lang 库中的一个实用工具类，提供了大量处理对象的方法。这些方法可以帮助你更方便地进行对象的比较、转换、判断等操作。

2.4 Redis相关工具

2.4.1 Spring Data Redis

1. 添加依赖

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2. 配置 Redis 连接

创建一个配置类来配置 RedisTemplate。这个类将定义如何连接到 Redis 服务器以及如何序列化和反序列化数据。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;@Configuration
public class RedisConfig {@Beanpublic RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {RedisTemplate<String, Object> template = new RedisTemplate<>();template.setConnectionFactory(factory);// 使用 StringRedisSerializer 来序列化和反序列化 keytemplate.setKeySerializer(new StringRedisSerializer());template.setHashKeySerializer(new StringRedisSerializer());// 使用 GenericJackson2JsonRedisSerializer 来序列化和反序列化 valuetemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());return template;}
}

在 application.properties 或 application.yml 文件中配置 Redis 连接信息：

# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1ms
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=5000ms

3. 使用 RedisTemplate

在你的类里面注入

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;import java.util.List;@Validated
@RestController
@RequestMapping("/redis")
public class FileController {@Autowiredprivate UserMapper userMapper;@Autowiredprivate RedisTemplate<String, Object> redisTemplate;@PostMapping("/demo")public void demo() {// 定义一个接收表格内容的集合List<UserFileDataVO> userlist = userMapper.selectAll();// 将数据存储到 RedisredisTemplate.opsForValue().set("userList", userlist);}
}

RedisTemplate 是 Spring Data Redis 提供的一个核心类，用于与 Redis 进行交互。它提供了丰富的 API 来操作不同的数据结构（如字符串、列表、集合、哈希、有序集合等）。以下是 RedisTemplate 中一些常用的 API 及其用途：

1. 字符串（String）操作
   API 说明
   opsForValue().set(key, value): 设置键值对。
   opsForValue().get(key): 获取键的值。
   opsForValue().increment(key): 对键的值进行递增。
   opsForValue().decrement(key): 对键的值进行递减。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;@RestController
@RequestMapping("/redis/string")
public class StringController {@Autowiredprivate RedisTemplate<String, Object> redisTemplate;@GetMapping("/set")public String setValue() {redisTemplate.opsForValue().set("stringKey", "Hello, Redis!");return "Value set successfully"; // 注释: Value set successfully}@GetMapping("/get")public String getValue() {String value = (String) redisTemplate.opsForValue().get("stringKey");return "Value: " + value; // 注释: Value: Hello, Redis!}@GetMapping("/increment")public String incrementValue() {redisTemplate.opsForValue().increment("counter");Long value = redisTemplate.opsForValue().get("counter", Long.class);return "Counter incremented to: " + value; // 注释: Counter incremented to: 1}@GetMapping("/decrement")public String decrementValue() {redisTemplate.opsForValue().decrement("counter");Long value = redisTemplate.opsForValue().get("counter", Long.class);return "Counter decremented to: " + value; // 注释: Counter decremented to: 0}
}

2. 列表（List）操作
   API 说明
   opsForList().rightPush(key, value): 在列表右侧添加一个元素。
   opsForList().rightPushAll(key, values): 在列表右侧添加多个元素。
   opsForList().range(key, start, end): 获取列表中指定范围的元素。
   opsForList().remove(key, count, value): 从列表中删除指定数量的元素。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;import java.util.List;@RestController
@RequestMapping("/redis/list")
public class ListController {@Autowiredprivate RedisTemplate<String, Object> redisTemplate;@GetMapping("/add")public String addToList() {redisTemplate.opsForList().rightPush("listKey", "item1");redisTemplate.opsForList().rightPushAll("listKey", "item2", "item3");return "Items added to list successfully"; // 注释: Items added to list successfully}@GetMapping("/get")public String getList() {List<Object> list = redisTemplate.opsForList().range("listKey", 0, -1);return "List: " + list; // 注释: List: [item1, item2, item3]}@GetMapping("/remove")public String removeFromList() {redisTemplate.opsForList().remove("listKey", 1, "item1");List<Object> list = redisTemplate.opsForList().range("listKey", 0, -1);return "List after removal: " + list; // 注释: List after removal: [item2, item3]}
}

3. 集合（Set）操作
   API 说明
   opsForSet().add(key, values): 向集合中添加一个或多个元素。
   opsForSet().members(key): 获取集合中的所有元素。
   opsForSet().remove(key, values): 从集合中删除一个或多个元素。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;import java.util.Set;@RestController
@RequestMapping("/redis/set")
public class SetController {@Autowiredprivate RedisTemplate<String, Object> redisTemplate;@GetMapping("/add")public String addToSet() {redisTemplate.opsForSet().add("setKey", "item1", "item2", "item3");return "Items added to set successfully"; // 注释: Items added to set successfully}@GetMapping("/get")public String getSet() {Set<Object> set = redisTemplate.opsForSet().members("setKey");return "Set: " + set; // 注释: Set: [item1, item2, item3]}@GetMapping("/remove")public String removeFromSet() {redisTemplate.opsForSet().remove("setKey", "item1");Set<Object> set = redisTemplate.opsForSet().members("setKey");return "Set after removal: " + set; // 注释: Set after removal: [item2, item3]}
}

4. 哈希（Hash）操作
   API 说明
   opsForHash().put(key, hashKey, value): 向哈希中添加一个字段和值。
   opsForHash().get(key, hashKey): 获取哈希中指定字段的值。
   opsForHash().entries(key): 获取哈希中所有字段和值。
   opsForHash().delete(key, hashKeys): 从哈希中删除一个或多个字段。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;import java.util.Map;@RestController
@RequestMapping("/redis/hash")
public class HashController {@Autowiredprivate RedisTemplate<String, Object> redisTemplate;@GetMapping("/add")public String addToHash() {redisTemplate.opsForHash().put("hashKey", "field1", "value1");redisTemplate.opsForHash().put("hashKey", "field2", "value2");return "Fields added to hash successfully"; // 注释: Fields added to hash successfully}@GetMapping("/get")public String getHash() {Map<Object, Object> hash = redisTemplate.opsForHash().entries("hashKey");return "Hash: " + hash; // 注释: Hash: {field1=value1, field2=value2}}@GetMapping("/remove")public String removeFromHash() {redisTemplate.opsForHash().delete("hashKey", "field1");Map<Object, Object> hash = redisTemplate.opsForHash().entries("hashKey");return "Hash after removal: " + hash; // 注释: Hash after removal: {field2=value2}}
}

5. 有序集合（ZSet）操作
   API 说明
   opsForZSet().add(key, value, score): 向有序集合中添加一个元素及其分数。
   opsForZSet().range(key, start, end): 获取有序集合中指定范围的元素。
   opsForZSet().remove(key, values): 从有序集合中删除一个或多个元素。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;import java.util.Set;@RestController
@RequestMapping("/redis/zset")
public class ZSetController {@Autowiredprivate RedisTemplate<String, Object> redisTemplate;@GetMapping("/add")public String addToZSet() {redisTemplate.opsForZSet().add("zsetKey", "item1", 1.0);redisTemplate.opsForZSet().add("zsetKey", "item2", 2.0);redisTemplate.opsForZSet().add("zsetKey", "item3", 3.0);return "Items added to zset successfully"; // 注释: Items added to zset successfully}@GetMapping("/get")public String getZSet() {Set<Object> zset = redisTemplate.opsForZSet().range("zsetKey", 0, -1);return "ZSet: " + zset; // 注释: ZSet: [item1, item2, item3]}@GetMapping("/remove")public String removeFromZSet() {redisTemplate.opsForZSet().remove("zsetKey", "item1");Set<Object> zset = redisTemplate.opsForZSet().range("zsetKey", 0, -1);return "ZSet after removal: " + zset; // 注释: ZSet after removal: [item2, item3]}
}