Apache Commons工具类库使用整理

---

Apache Commons

Apache Commons 是一个开源软件项目，旨在为 Java 开发人员提供常用的工具类和组件。它提供了很多可重复使用的函数库，涵盖了各种领域，包括集合操作、文件操作、网络操作等。

工具类库分类

Apache Commons工具库	描述
commons-lang3	提供了许多Java基本工具类，包括字符串操作、对象操作、数组操作、类型转换等
commons-io	提供了一组用于读取、写入、复制、删除、移动文件和目录的工具类。还包括一些文件过滤器、文件比较器、文件监视器等实用工具
commons-pool2	提供了一个对象池的实现，用于管理可重用对象的分配、释放和空闲状态。这对于频繁创建和销毁的对象，如数据库连接池、线程池等，有很大的性能优势
commons-codec	提供了一些用于编码和解码数据的工具类，包括 Base64、Hex、URL、SHA1、MD5编码等常用编解码方式
commons-collections4	提供了一组扩展和增强了 Java 标准集合框架的工具类和数据结构。提供了更多功能和更丰富的选项，例如扩展的集合、映射、迭代器等
commons-math3	提供了一组用于数学运算和统计分析的工具和算法。涵盖了线性代数、随机数生成、优化、函数拟合、概率分布等方面的功能
commons-compress	提供了一组用于处理压缩和解压缩文件的工具类。支持多种压缩格式，如 zip、tar、bzip2、gzip 等
commons-net	提供了一组用于处理网络协议和网络操作的工具类，包括 FTP、SMTP、POP3、IMAP、Telnet 等
commons-csv	提供了一组用于读取和写入 CSV（逗号分隔值）文件的工具类。支持不同的 CSV 格式、数据解析和生成
commons-configuration2	提供了一个用于加载和管理配置文件的工具库。支持多种配置文件格式和配置源，提供了属性访问、配置组合和继承等功能
commons-text	提供了一组用于处理文本和字符串的工具和算法，包括字符串操作、占位符替换、转义、相似度比较等功能

- commons-lang3

提供了许多Java基本工具类，包括字符串操作、对象操作、数组操作、类型转换等。

maven依赖：

<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-lang3</artifactId>
   <version>3.12.0</version>
</dependency>

常用工具类：

类	描述
ObjectUtils	对象操作工具类（包括对象比较、对象判空、对象类型转换等）
StringUtils	字符串操作工具类（包括字符串判空、字符串格式化、字符串连接、字符串截取等）
NumberUtils	数字操作工具类（包括数字比较、数字范围判断、数字类型转换等）
ArrayUtils	数组操作工具类（包括数组判空、数组合并、数组查找、数组反转等）
DateUtils	日期操作工具类（包括日期格式化、日期解析、日期计算等）
ClassUtils	类操作工具类（包括类加载、类获取、类转换等）
EnumUtils	枚举操作工具类（包括枚举转换、枚举查找、枚举验证等）
RandomUtils	随机数操作工具类（包括随机数生成、随机数种子控制、随机数范围获取等）
SerializationUtils	序列化工具类（包括对象序列化、对象反序列化、对象复制等）
ExceptionUtils	异常处理工具类（包括异常重新抛出、异常堆栈信息、异常消息提取等）
CalendarUtils	日历操作工具类（包括日历获取、日历计算、日历比较等）
ComparableUtils	比较操作工具类（包括对象比较、区间判断、最值获取等）
BooleanUtils	布尔值操作工具类（包括布尔值判断、布尔值转换、布尔值逻辑计算等）
CharSetUtils	字符集操作工具类（包括字符集编解码、字符集转换、字符集判断等）
ClassLoaderUtils	类加载操作工具类（包括资源获取、类加载器管理、路径处理等）
EventUtils	事件操作工具类（包括事件监听、事件触发、事件管理等）
FieldUtils	字段操作工具类（包括字段获取、字段设置、字段验证等）
MemberUtils	成员操作工具类（包括成员获取、成员验证、成员处理等）
MethodUtils	方法操作工具类（包括方法调用、方法查找、方法验证等）
RegExUtils	正则表达式操作工具类（包括正则表达式匹配、替换、验证等）
SystemUtils	系统信息操作工具类（包括环境变量获取、系统属性获取、操作系统获取等）
ThreadUtils	线程操作工具类（包括线程休眠、线程中断、线程状态查询等）
Validate	验证操作工具类（包括参数验证、条件验证、数据验证等）
AnnotationUtils	注解操作工具类（包括注解获取、注解验证、注解解析等）
RandomStringUtils	随机字符串操作工具类（包括随机字符串生成、特殊字符控制、长度控制等）
ConcurrentUtils	并发操作工具类（包括线程池、同步、并发集合等）
TypeUtils	类型操作工具类（包括类型判断、类型转换、类型兼容性判断等）
InheritanceUtils	继承操作工具类（包括继承查询、继承验证、继承管理等）

字符串工具：StringUtils

方法名	方法描述
isEmpty(CharSequence)	判断字符串是否为空（长度为0或为null）
isNotEmpty(CharSequence)	判断字符串是否非空
isAnyEmpty(CharSequence…)	判断多个字符串中是否存在空字符串
isNoneEmpty(CharSequence…)	判断多个字符串是否全不为空
isAllEmpty(CharSequence…)	判断多个字符串是否全部为空
isBlank(CharSequence)	判断字符串是否为空白（包括null、空字符串、只包含空白字符）
isNotBlank(CharSequence)	判断字符串是否非空白
isAnyBlank(CharSequence…)	判断多个字符串中是否存在空白字符串
isNoneBlank(CharSequence…)	判断多个字符串是否全不为空白
isAllBlank(CharSequence…)	判断多个字符串是否全部为空白
trim(String)	去除字符串头尾的空白字符
trimToNull(String)	去除字符串头尾的空白字符，并将结果为empty的字符串转为null
trimToEmpty(String)	去除字符串头尾的空白字符，并将结果为null的字符串转为empty
truncate(String,int)	截断字符串到指定长度，如果超过长度则添加省略符
strip(String)	去除字符串头尾的空白字符和Unicode空格符
stripToNull(String)	去除字符串头尾的空白字符和Unicode空格符，并将结果为empty的字符串转为null
stripToEmpty(String)	去除字符串头尾的空白字符和Unicode空格符，并将结果为null的字符串转为empty
stripStart(String,String)	去除字符串开头的指定字符序列
stripEnd(String,String)	去除字符串结尾的指定字符序列
stripAll(String…)	去除字符串数组中每个字符串的头尾空白字符
stripAccents(String)	去除字符串中的重音符号并替换为对应的非重音字符
equals(CharSequence,CharSequence)	比较两个字符串是否相等
equalsIgnoreCase(CharSequence,CharSequence)	忽略大小写比较两个字符串是否相等
compare(String,String)	比较两个字符串的大小（基于Unicode编码值）
compareIgnoreCase(String,String)	忽略大小写比较两个字符串的大小（基于Unicode编码值）
equalsAny(CharSequence,CharSequence…)	检查字符串是否与多个候选字符串中的任意一个相等
equalsAnyIgnoreCase(CharSequence,CharSequence…)	忽略大小写检查字符串是否与多个候选字符串中的任意一个相等
indexOf(CharSequence,int)	在字符串中查找子字符串的首次出现位置
ordinalIndexOf(CharSequence,CharSequence,int)	在字符串中查找指定子字符串的第N次出现位置
indexOfIgnoreCase(CharSequence,CharSequence)	在字符串中忽略大小写查找子字符串的首次出现位置
lastIndexOf(CharSequence,CharSequence)	在字符串中查找子字符串的最后一次出现位置
lastOrdinalIndexOf(CharSequence,CharSequence,int)	在字符串中查找指定子字符串的倒数第N次出现位置
lastIndexOfIgnoreCase(CharSequence,CharSequence)	在字符串中忽略大小写查找子字符串的最后一次出现位置
contains(CharSequence,CharSequence)	判断字符串是否包含指定子字符串
containsIgnoreCase(CharSequence,CharSequence)	忽略大小写判断字符串是否包含指定子字符串
containsWhitespace(CharSequence)	判断字符串是否包含空格字符
indexOfAny(CharSequence,String)	在字符串中查找任意字符序列的首次出现位置
containsAny(CharSequence,CharSequence…)	判断字符串是否包含任意字符序列
indexOfAnyBut(CharSequence,char…)	在字符串中查找除指定字符序列外的任意字符首次出现位置
containsOnly(CharSequence,char…)	判断字符串是否只包含指定字符序列中的字符
containsNone(CharSequence,char…)	判断字符串是否不包含指定字符序列中的字符
lastIndexOfAny(CharSequence,CharSequence…)	在字符串中查找任意字符序列的最后一次出现位置
substring(CharSequence,int)	截取字符串从指定位置到末尾
left(CharSequence,int)	获取字符串左边指定长度的子字符串
right(CharSequence,int)	获取字符串右边指定长度的子字符串
mid(CharSequence,int,int)	获取字符串的指定范围子字符串
substringBefore(String,String)	获取字符串中指定子字符串之前的部分
substringAfter(String,String)	获取字符串中指定子字符串之后的部分
substringBeforeLast(String,String)	获取字符串中最后一个指定子字符串之前的部分
substringAfterLast(String,String)	获取字符串中最后一个指定子字符串之后的部分
substringBetween(String,String)	获取两个指定子字符串之间的部分
substringsBetween(String,String,String)	获取所有两个指定子字符串之间的部分
split(String,String)	使用指定的分隔符拆分字符串成数组
splitByWholeSeparator(String,String)	使用指定的完整分隔符拆分字符串成数组
splitByWholeSeparatorPreserveAllTokens(String,String)	使用指定的完整分隔符拆分字符串成数组，并保留所有的分隔符
splitPreserveAllTokens(String,char)	使用指定的字符拆分字符串成数组，并且保留所有的分隔符
splitByCharacterType(String)	使用字符类型拆分字符串成数组
splitByCharacterTypeCamelCase(String)	使用驼峰式字符类型拆分字符串成数组
join(Iterable<?>,String)	将Iterable对象中的字符串连接成一个字符串，使用指定分隔符
joinWith(String,Object…)	将多个字符串使用指定的分隔符连接成一个字符串
deleteWhitespace(String)	删除字符串中的所有空白字符
removeStart(String,String)	去除字符串开头的指定前缀
removeStartIgnoreCase(String,String)	去除字符串开头的指定前缀（忽略大小写）
removeEnd(String,String)	去除字符串结尾的指定后缀
removeEndIgnoreCase(String,String)	去除字符串结尾的指定后缀（忽略大小写）
removeIgnoreCase(String,String)	去除字符串中所有指定子字符串（忽略大小写）
remove(String,String)	去除字符串中所有指定子字符串
replaceOnce(String,String,String)	字符串替换，替换第一次出现的指定子字符串
replaceOnceIgnoreCase(String,String,String)	忽略大小写，替换第一次出现的指定子字符串
replace(String,String,String)	替换字符串中所有匹配的部分
replaceIgnoreCase(String,String,String)	忽略大小写，替换字符串中所有匹配的部分
overlay(String,String,int,int)	在指定位置覆盖字符串的一部分
chomp(String)	去除字符串末尾的回车符和换行符
chop(String)	去除字符串末尾的最后一个字符
repeat(String,int)	重复指定字符串多次
rightPad(String,int)	将字符串右侧填充指定数量的空格字符
rightPad(String,int,char)	将字符串右侧填充指定数量的指定字符
leftPad(String,int)	将字符串左侧填充指定数量的空格字符
leftPad(String,int,char)	将字符串左侧填充指定数量的指定字符
center(String,int)	将字符串居中并用空格字符填充两侧
center(String,int,char)	将字符串居中并用指定字符填充两侧
capitalize(String)	将字符串第一个字符大写
uncapitalize(String)	将字符串第一个字符小写
swapCase(String)	大小写互换
countMatches(CharSequence)	统计字符串中指定子字符串的出现次数
isAlpha(CharSequence)	判断字符串是否只包含字母
isAlphaSpace(CharSequence)	判断字符串是否只包含字母和空格
isAlphanumeric(CharSequence)	判断字符串是否只包含字母和数字
isAlphanumericSpace(CharSequence)	判断字符串是否只包含字母、数字和空格
isNumeric(CharSequence)	判断字符串是否只包含数字
isNumericSpace(CharSequence)	判断字符串是否只包含数字和空格
isWhitespace(CharSequence)	判断字符串是否只包含空白字符
isAsciiPrintable(CharSequence)	判断字符串是否只包含可打印的ASCII字符
isMixedCase(CharSequence)	判断字符串是否既有字母又有数字
defaultString(String)	如果字符串为null，则返回空字符串
defaultString(String,String)	如果字符串为null，则返回指定的默认字符串
defaultIfBlank(T,T)	如果字符串为空白（包括空字符串、只包含空白字符）或null，则返回指定的默认字符串
defaultIfEmpty(T,T)	如果字符串为空（包括空字符串）或null，则返回指定的默认字符串
wrap(String,String)	在字符串两侧添加指定的前缀和后缀
wrapIfMissing(String,String)	如果字符串没有以指定的前缀开头或以指定的后缀结尾，则在两侧添加指定的前缀和后缀
unwrap(String,String)	去除字符串两侧的指定前缀和后缀
unwrap(String,char)	去除字符串两侧的指定前缀和后缀，用于多个字符串
toCodePoints(CharSequence)	将字符串转换为Unicode码点数组
toEncodedString(byte[],Charset)	将字符串转换为使用指定字符集编码的字节数组，并转换为字符串

日期工具：DateUtils

方法名	方法描述
isSameDay(Date,Date)	比较两个日期对象是否在同一天
isSameInstant(Date,Date)	比较两个日期对象是否表示同一时刻
isSameLocalTime(Calendar,Calendar)	比较两个日期对象的时分秒是否相同
parseDate(String,String…)	将字符串解析为日期对象
parseDateStrictly(String,String…)	将字符串解析为日期对象，如果格式不正确则抛出异常
addYears(Date,int)	给日期对象加上指定年数
addMonths(Date,int)	给日期对象加上指定月数
addWeeks(Date,int)	给日期对象加上指定周数
addDays(Date,int)	给日期对象加上指定天数
addHours(Date,int)	给日期对象加上指定小时数
addMinutes(Date,int)	给日期对象加上指定分钟数
addSeconds(Date,int)	给日期对象加上指定秒数
addMilliseconds(Date,int)	给日期对象加上指定毫秒数
setYears(Date,int)	设置日期对象的年份
setMonths(Date,int)	设置日期对象的月份
setDays(Date,int)	设置日期对象的天数
setHours(Date,int)	设置日期对象的小时数
setMinutes(Date,int)	设置日期对象的分钟数
setSeconds(Date,int)	设置日期对象的秒数
setMilliseconds(Date,int)	设置日期对象的毫秒数
toCalendar(Date)	将日期对象转换为日历对象
round(Date,int)	将日期对象按照指定精度进行舍入
truncate(Date,int)	将日期对象按照指定精度进行舍去
ceiling(Date,int)	将日期对象按照指定精度进行进一取整
iterator(Date,int,int)	返回一个日期对象的迭代器，以指定精度和范围进行迭代
getFragmentInDays(Date,int)	获取日期对象中指定精度的片段，以天为单位
getFragmentInMilliseconds(Date,int)	获取日期对象中指定精度的片段，以毫秒为单位
getFragmentInSeconds(Date,int)	获取日期对象中指定精度的片段，以秒为单位
getFragmentInMinutes(Date,int)	获取日期对象中指定精度的片段，以分钟为单位
getFragmentInHours(Date,int)	获取日期对象中指定精度的片段，以小时为单位
truncatedEquals(Calendar,Calendar,int)	比较两个日期对象在指定精度下是否相等
truncatedCompareTo(Calendar,Calendar,int)	比较两个日期对象在指定精度下的顺序

数值工具：NumberUtils

方法名	方法描述
toInt(Stringstr)	将指定的字符串转换为整数值。
toInt(Stringstr,int)	将指定的字符串转换为整数值，为空时使用默认值
toLong(Stringstr,long)	将指定的字符串转换为长整数值。
toLong(Stringstr)	将指定的字符串转换为长整数值，为空时使用默认值
toFloat(Stringstr)	将指定的字符串转换为单精度浮点数值。
toFloat(Stringstr,float)	将指定的字符串转换为单精度浮点数值，为空时使用默认值
toDouble(Stringstr)	将指定的字符串转换为双精度浮点数值。
toDouble(Stringstr,double)	将指定的字符串转换为双精度浮点数值，为空时使用默认值
toByte(Stringstr)	将指定的字符串转换为字节值。
toByte(Stringstr,byte)	将指定的字符串转换为字节值，为空时使用默认值
toShort(Stringstr)	将指定的字符串转换为短整数值。
toShort(Stringstr,short)	将指定的字符串转换为短整数值，为空时使用默认值
toScaledBigDecimal(Stringstr)	将指定的字符串转换为精确浮点数BigDecimal。
toScaledBigDecimal(Stringstr,int,RoundingMode)	将指定的字符串转换为精确浮点数BigDecimal。可指定小数位数及舍入模式
createNumber(Stringstr)	将指定的字符串转换为对应的数字类型。
createFloat(Stringstr)	将指定的字符串转换为Float对象。
createDouble(Stringstr)	将指定的字符串转换为Double对象。
createInteger(Stringstr)	将指定的字符串转换为Integer对象。
createLong(Stringstr)	将指定的字符串转换为Long对象。
createBigInteger(Stringstr)	将指定的字符串转换为BigInteger对象。
createBigDecimal(Stringstr)	将指定的字符串转换为BigDecimal对象。
min(long…)	返回给定数字数组中的最小值。
min(int…)	返回给定数字数组中的最小值。
min(short…)	返回给定数字数组中的最小值。
min(byte…)	返回给定数字数组中的最小值。
min(double…)	返回给定数字数组中的最小值。
min(float…)	返回给定数字数组中的最小值。
max(long…)	返回给定数字数组中的最大值。
max(int…)	返回给定数字数组中的最大值。
max(short…)	返回给定数字数组中的最大值。
max(byte…)	返回给定数字数组中的最大值。
max(double…)	返回给定数字数组中的最大值。
max(float…)	返回给定数字数组中的最大值。
compare(int,int)	比较两个数字的大小。
compare(long,long)	比较两个数字的大小。
compare(short,short)	比较两个数字的大小。
compare(byte,byte)	比较两个数字的大小。
isDigits(Stringstr)	判断指定的字符串是否为数字格式。
isNumber(Stringstr)	判断指定的字符串是否为数字类型。
isCreatable(Stringstr)	判断指定的字符串是否可转换为数字。
isParsable(Stringstr)	判断指定的字符串是否可解析为数字。

对象工具：ObjectUtils

方法名	方法描述
isEmpty(Object)	判断指定对象是否为空。
isNotEmpty(Object)	判断指定对象是否不为空。
defaultIfNull(T,T)	如果指定对象为空则返回默认值。
firstNonNull(T…)	返回第一个非空的对象。
anyNotNull(T…)	判断给定对象数组中是否存在非空对象。
allNotNull(T…)	判断给定对象数组中是否所有对象均非空。
notEqual(T,T)	判断两个对象是否不相等。
identityToString(T)	返回对象的identity的字符串表示。
identityToString(T,String)	返回对象的identity的字符串表示，可指定空对象的字符串表示。
min(T…)	返回给定对象数组中的最小值。
max(T…)	返回给定对象数组中的最大值。
compare(T,T)	比较两个对象的大小。
compare(T,T,boolean)	使用指定比较器比较两个对象的大小。
median(T…)	返回给定对象数组的中位数。
median(Comparator<T>,T…)	返回给定对象数组的中位数，自定义比较器
mode(T…)	返回给定对象数组中的众数。

数组工具：ArrayUtils

方法	描述
toString(Object)	将数组转换为字符串。
toStringArray(Object[])	将数组转换为字符串数组。
toMap(Object[])	将键数组转换为Map。
toArray(T…)	将集合转换为数组。
clone(T[])	克隆一个数组。
nullToEmpty(Object[])	将null数组转换为空数组。
subarray(T[],int,int)	获取数组的子数组。
isSameLength(Object[],Object[])	检查两个数组是否具有相同的长度。
getLength(Object)	获取数组的长度。
isSameType(Object,Object)	检查两个对象数组是否具有相同的类型。
reverse(Object[])	反转数组。
reverse(Object[],int,int)	反转数组,指定起始截止位置
swap(Object[],int,int)	交换数组中两个元素的位置。
shift(Object[],int)	将数组中的元素向左或向右移动。
indexOf(Object[],Object)	获取元素在数组中的第一个匹配位置。
lastIndexOf(Object[],Object)	获取元素在数组中的最后一个匹配位置。
contains(Object[],Object)	检查数组是否包含某元素。
toPrimitive(Object)	将包装类型数组转换为原始类型数组。
toObject(Object)	将原始类型数组转换为包装类型数组。
isEmpty(Object[])	检查数组是否为空。
isNotEmpty(Object[])	检查数组是否不为空。
addAll(T[],T…)	向数组中添加多个元素。
add(T[],T)	向数组中添加一个元素。
remove(T[],int)	移除数组中指定位置的元素。
removeElement(T[],Object)	移除数组中指定元素的第一个匹配项。
removeAll(T[],int…)	移除数组中的多个元素。
removeElements(T[],T…)	移除数组中的多个元素，并保持顺序不变。
isSorted(T[])	检查数组是否已排序。
isSorted(T[],Comparator<T>)	检查数组是否已排序，指定比较器
removeAllOccurences(T[],T)	移除数组中的所有匹配项。
toStringArray(Object[])	将对象数组转换为字符串数组。
insert(int,T[],T…)	在数组中的指定位置插入元素。
shuffle(Object[])	随机重排数组中的元素。
shuffle(Object[],int,int)	随机重排数组中的元素，指定起始截止位置
isArrayIndexValid(T[],int)	检查数组索引是否在有效范围内。

异常工具：ExceptionUtils

方法	描述
getMessage(Throwable)	返回throwable的详细消息字符串
getRootCause(Throwable)	返回throwable的根本原因throwable
getRootCauseMessage(Throwable)	返回根throwable的详细消息字符串
getRootCauseStackTrace(Throwable)	获取根throwable的堆栈跟踪
getStackFrames(Throwable)	获取throwable的堆栈帧
getStackTrace(Throwable)	获取throwable的堆栈跟踪
getThrowableCount(Throwable)	获取throwable的可抛出对象数量
getThrowableList(Throwable)	获取throwable及其嵌套的可抛出对象列表
getThrowables(Throwable)	获取throwable及其嵌套的可抛出对象数组
hasCause(Throwable)	检查throwable是否有根本原因
indexOfThrowable(Throwable,Class<?extendsThrowable>)	获取指定类型的可抛出对象索引
indexOfType(Throwable,Class<?extendsThrowable>)	获取指定类型的可抛出对象索引
printRootCauseStackTrace(Throwable)	打印根throwable的堆栈跟踪
removeCommonFrames(List<String>,List<String>)	从第一个列表中删除与第二个列表中相同的元素
rethrow(Throwable)	如果throwable是Error、RuntimeException或Throwable的实例，则将其重新抛出
wrapAndThrow(Throwable)	包装并抛出throwable

枚举工具：EnumUtils

方法	描述
generateBitVector(Class<?extendsEnum<?>>)	为给定枚举类型生成一个位向量
generateBitVector(Class<?extendsEnum<?>>,Iterable<?extendsEnum<?>>)	为给定枚举类型生成一个位向量
generateBitVectors(Class<T>)	为给定枚举类型生成一组位向量
generateBitVectors(Class<T>,Iterable<?extendsT>)	为给定枚举类型生成一组位向量
getEnum(Class<E>,String)	返回指定名称的枚举常量
getEnumIgnoreCase(Class<E>,String)	返回以不区分大小写方式匹配指定名称的枚举常量
getEnumList(Class<E>)	返回指定枚举类型的枚举常量列表
getEnumMap(Class<E>)	返回指定枚举类型的枚举常量映射
isValidEnum(Class<E>,String)	检查指定名称是否是指定枚举类型的有效枚举常量
isValidEnumIgnoreCase(Class<E>,String)	以不区分大小写方式检查指定名称是否是指定枚举类型的有效枚举常量
processBitVector(Class<E>,long,EnumUtils.Processor<E>)	使用处理器处理位向量
processBitVectors(Class<E>,long,EnumUtils.Processor<E>)	使用处理器处理一组位向量

字符串随机数工具：RandomStringUtils

方法	方法描述
random(int count, String chars)	生成指定长度的随机字符串，可以指定字符集。
random(int count, char… chars)	生成指定长度的随机字符串，可以指定是否包含字母和数字
random(int count, boolean letters, boolean numbers)	生成指定长度的随机字符串。
randomAlphabetic(int count)	生成指定长度的随机字母字符串。
randomNumeric(int count)	生成指定长度的随机数字字符串。
randomAlphanumeric(int count)	生成指定长度的随机字母和数字字符串。
randomAscii(int count)	生成指定长度的随机ASCII字符串。
randomGraph(int count)	生成指定长度的随机可打印图形字符字符串。
randomPrint(int count)	生成指定长度的随机可打印字符字符串。

- commons-io

maven依赖：

<dependency>
   <groupId>commons-io</groupId>
   <artifactId>commons-io</artifactId>
   <version>2.11.0</version>
</dependency>

文件工具：FileUtils

提供了一系列的文件操作方法，包括复制、移动、删除、比较文件内容等。

I/O工具：IOUtils

包含了一些常见的 I/O 操作方法，用于简化流的打开、关闭和读写，以及处理流的复制、转换等操作。

文件名工具：FilenameUtils

用于处理文件名的工具类，包括路径和文件名的解析、提取文件扩展名、路径合并等操作。

- commons-pool2

是一个用于管理对象池的工具库。对象池是一种常见的设计模式，用于管理可重复使用的对象，以减少对象的创建和销毁开销，同时提高对象的利用率。Commons Pool 2 提供了一套通用的对象池实现，可以用于管理任意类型的对象。如数据库连接池、线程池等。

maven依赖：

<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-pool2</artifactId>
   <version>2.11.1</version>
</dependency>

对象池核心组件

Commons Pool2 的核心组件：

• GenericObjectPool：通用的对象池实现，是 Commons Pool 2 的核心类。它可以管理任意类型的对象，并提供了一系列的配置选项，如最大对象数量、最大空闲对象数量、对象生命周期管理等。

• PooledObjectFactory：对象工厂接口，定义了对象的创建、销毁、验证等方法。每个对象池都需要实现这个接口来管理对象的生命周期。

• BasePooledObjectFactory：提供了一些方法的默认实现，简化了自定义对象工厂的实现。

• PooledObject：表示被对象池管理的对象，提供了对对象的状态信息和操作方法，如获取对象、释放对象等。

• EvictionPolicy：用于定义对象池中对象的驱逐策略，决定哪些对象应该被驱逐出池。

使用示例：

// 自定义的对象类
class MyObject {
    private String name;

    public MyObject(String name) {
        this.name = name;
        System.out.println("Creating object: " + name);
    }

    public void doSomething() {
        System.out.println("Doing something with object: " + name);
    }
}

// 自定义的对象工厂
class MyObjectFactory extends BasePooledObjectFactory<MyObject> {
    @Override
    public MyObject create() throws Exception {
        return new MyObject("Object");
    }

    @Override
    public PooledObject<MyObject> wrap(MyObject obj) {
        return new DefaultPooledObject<>(obj);
    }
}


public class CommonsPoolTest {

    public static void main(String[] args) throws Exception {
        // 创建对象工厂
        MyObjectFactory factory = new MyObjectFactory();

        // 创建对象池
        GenericObjectPool<MyObject> objectPool = new GenericObjectPool<>(factory);

        // 从对象池获取对象
        MyObject obj1 = objectPool.borrowObject();
        obj1.doSomething();

        // 归还对象到对象池
        objectPool.returnObject(obj1);

        // 再次从对象池获取对象
        MyObject obj2 = objectPool.borrowObject();
        obj2.doSomething();

        // 关闭对象池
        objectPool.close();
    }
}

- commons-codec

提供了一组用于编码和解码数据的通用工具类。它支持各种常见的编码算法，如 Base64、URL 编码、十六进制编码、MD5、SHA 等，以及一些其他常见的编码和散列算法。

maven依赖：

<dependency>
   <groupId>commons-codec</groupId>
   <artifactId>commons-codec</artifactId>
   <version>1.15</version>
</dependency>

Base64编解码：Base64

org.apache.commons.codec.binary.Base64

public static void main(String[] args) {
        // 原始字符串
        String originalString = "Hello, Base64!";

        // Base64 编码
        byte[] encodedBytes = Base64.encodeBase64(originalString.getBytes());
        String encodedString = new String(encodedBytes);
        System.out.println("Base64 编码: " + encodedString);

        // Base64 解码
        byte[] decodedBytes = Base64.decodeBase64(encodedBytes);
        String decodedString = new String(decodedBytes);
        System.out.println("Base64 解码: " + decodedString);
    }

URL编解码：URLCodec

org.apache.commons.codec.net.URLCodec

public static void main(String[] args) throws Exception {
        // 原始URL
        String originalUrl = "http://127.0.0.1:8888/?username=哈哈";

        // URL 编码
        URLCodec codec = new URLCodec();
        String encodedUrl = codec.encode(originalUrl);
        System.out.println("URL 编码: " + encodedUrl);

        String decodeUrl = codec.decode(encodedUrl);
        System.out.println("URL 解码: " + decodeUrl);
    }

十六进制编解码：Hex

org.apache.commons.codec.binary.Hex

public static void main(String[] args) throws DecoderException {
        // 原始字符串
        String originalString = "Hex Example";

        // 十六进制编码
        String encodedString = Hex.encodeHexString(originalString.getBytes());
        System.out.println("十六进制编码: " + encodedString);

        // 十六进制解码
        byte[] decodedBytes = Hex.decodeHex(encodedString);
        String decodedString = new String(decodedBytes);
        System.out.println("十六进制解码: " + decodedString);
    }

加密工具：DigestUtils

主要方法：

方法	描述
md2(String)	计算字符串的MD2摘要并以byte数组形式返回结果
md5(String)	计算字符串的MD5摘要并以byte数组形式返回结果
sha1(String)	计算字符串的SHA-1摘要并以byte数组形式返回结果
sha256(String)	计算字符串的SHA-256摘要并以byte数组形式返回结果
sha384(String)	计算字符串的SHA-384摘要并以byte数组形式返回结果
sha512(String)	计算字符串的SHA-512摘要并以byte数组形式返回结果
sha3_224(String)	计算字符串的SHA-3-224摘要并以byte数组形式返回结果
sha3_256(String)	计算字符串的SHA-3-256摘要并以byte数组形式返回结果
sha3_384(String)	计算字符串的SHA-3-384摘要并以byte数组形式返回结果
sha3_512(String)	计算字符串的SHA-3-512摘要并以byte数组形式返回结果
sha512_224(String)	计算字符串的SHA-512/224摘要并以byte数组形式返回结果
sha512_256(String)	计算字符串的SHA-512/256摘要并以byte数组形式返回结果
md2Hex(String)	计算字符串的MD2摘要并以十六进制字符串形式返回结果
md5Hex(String)	计算字符串的MD5摘要并以十六进制字符串形式返回结果
sha1Hex(String)	计算字符串的SHA-1摘要并以十六进制字符串形式返回结果
sha256Hex(String)	计算字符串的SHA-256摘要并以十六进制字符串形式返回结果
sha384Hex(String)	计算字符串的SHA-384摘要并以十六进制字符串形式返回结果
sha512Hex(String)	计算字符串的SHA-512摘要并以十六进制字符串形式返回结果
sha3_224Hex(String)	计算字符串的SHA-3-224摘要并以十六进制字符串形式返回结果
sha3_256Hex(String)	计算字符串的SHA-3-256摘要并以十六进制字符串形式返回结果
sha3_384Hex(String)	计算字符串的SHA-3-384摘要并以十六进制字符串形式返回结果
sha3_512Hex(String)	计算字符串的SHA-3-512摘要并以十六进制字符串形式返回结果
sha512_224Hex(String)	计算字符串的SHA-512/224摘要并以十六进制字符串形式返回结果
sha512_256Hex(String)	计算字符串的SHA-512/256摘要并以十六进制字符串形式返回结果
getMd2Digest()	获取一个新的MD2MessageDigest实例
getMd5Digest()	获取一个新的MD5MessageDigest实例
getSha1Digest()	获取一个新的SHA-1MessageDigest实例
getSha256Digest()	获取一个新的SHA-256MessageDigest实例
getSha384Digest()	获取一个新的SHA-384MessageDigest实例
getSha512Digest()	获取一个新的SHA-512MessageDigest实例
getSha3_224Digest	获取一个新的SHA-3-224MessageDigest实例
getSha3_256Digest	获取一个新的SHA-3-256MessageDigest实例
getSha3_384Digest	获取一个新的SHA-3-384MessageDigest实例
getSha3_512Digest	获取一个新的SHA-3-512MessageDigest实例
getSha512_224Digest	获取一个新的SHA-512/224MessageDigest实例
getSha512_256Digest	获取一个新的SHA-512/256MessageDigest实例
digest(MessageDigest,byte[])	对字节数组进行摘要计算，使用指定的MessageDigest
digest(MessageDigest,InputStream)	对输入流进行摘要计算，使用指定的MessageDigest
digest(MessageDigest,File)	对文件进行摘要计算，使用指定的MessageDigest
digestAsHex(byte[])	计算byte数组摘要并以十六进制字符串的形式返回结果
digestAsHex(File)	计算文件摘要并以十六进制字符串的形式返回结果
digestAsHex(InputStream)	计算输入流摘要并以十六进制字符串的形式返回结果
digestAsHex(String)	计算字符串摘要并以十六进制字符串的形式返回结果

使用示例：

    public static void main(String[] args) {
        // 原始字符串
        String originalString = "Hello";

        // 计算MD5摘要
        String md5Hex = DigestUtils.md5Hex(originalString);
        System.out.println("MD5摘要: " + md5Hex);

        // 计算SHA-256摘要
        String sha256Hex = DigestUtils.sha256Hex(originalString);
        System.out.println("SHA-256摘要: " + sha256Hex);

        // 计算SHA-512摘要
        String sha512Hex = DigestUtils.sha512Hex(originalString);
        System.out.println("SHA-512摘要: " + sha512Hex);
    }

- commons-collections4

提供了一组扩展和增强了 Java 标准集合框架的工具类和数据结构。提供了更多功能和更丰富的选项，例如扩展的集合、映射、迭代器等。

maven依赖：

<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-collections4</artifactId>
   <version>4.4</version>
</dependency>

主要功能：

• 集合操作：CollectionUtils 类包含了许多静态方法，用于各种常见的集合操作，如查找、过滤、转换等。

• 集合扩展：Apache Commons Collections4 提供了一些有用的集合类，如 ListUtils、SetUtils 和 MapUtils 等。这些类通过静态方法提供了一系列的集合操作，如合并、交集、差集、过滤等。

• 高效实现：Commons Collections4 提供了许多高效的集合实现，比如 LinkedMap、TreeBag、FixedSizeList 等。这些实现在特定场景下可以提供更好的性能和功能。

• 装饰器模式：Commons Collections4 还提供了一系列装饰器类，用于扩展或修改现有的集合类。通过装饰器模式，可以在不改变现有代码的情况下增加或修改集合的功能，如 SynchronizedCollection、UnmodifiableMap 等。

• 迭代器和迭代器：Commons Collections4 提供了许多增强的迭代器和迭代器工具类，如 IteratorUtils、IterableUtils 和 EnumerationUtils 等。这些工具类可以简化集合的遍历和操作。

• 转换器和变形器：Commons Collections4 提供了一些转换器和变形器，用于在集合元素之间进行转换或变换，如 TransformerUtils 和 PredicateUtils 等。这些工具类可以方便地进行元素的转换、过滤及其他操作。

• 额外的数据结构：Commons Collections4 还提供了一些额外的数据结构，如 BidiMap、MultiMap、Bag 等。这些数据结构可以满足一些特定的需求，如双向映射、多值映射和可重复的元素计数等。

集合操作

CollectionUtils主要方法：

集合扩展

• 合并两个列表：

  List<String> list1 = Arrays.asList("apple", "banana");
  List<String> list2 = Arrays.asList("banana", "orange");
  List<String> mergedList = ListUtils.union(list1, list2);
  System.out.println("Merged List: " + mergedList);
  

• 计算两个集合的交集：

  Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3));
  Set<Integer> set2 = new HashSet<>(Arrays.asList(3, 4, 5));
  Set<Integer> intersection = SetUtils.intersection(set1, set2);
  System.out.println("Intersection: " + intersection);
  

• 过滤Map中满足条件的条目：

  Map<String, Integer> map = new HashMap<>();
  map.put("apple", 3);
  map.put("banana", 2);
  map.put("orange", 5);
  Map<String, Integer> filteredMap = MapUtils.predicatedMap(map, (key, value) -> value > 2);
  System.out.println("Filtered Map: " + filteredMap);
  

高效实现

• 使用 LinkedMap 保持键值对的插入顺序：

  Map<String, Integer> linkedMap = new LinkedMap<>();
  linkedMap.put("apple", 3);
  linkedMap.put("banana", 2);
  linkedMap.put("orange", 5);
  System.out.println("Linked Map: " + linkedMap);
  

• 使用 TreeBag 对元素进行排序和计数：

  Bag<String> treeBag = new TreeBag<>(Arrays.asList("apple", "banana", "banana", "orange"));
  System.out.println("Tree Bag: " + treeBag);
  

• 创建固定大小的列表：

  List<String> fixedSizeList = FixedSizeList.decorate(new ArrayList<>(Arrays.asList("apple", "banana", "orange")));
  System.out.println("Fixed Size List: " + fixedSizeList);
  

装饰器模式

• 创建一个线程安全的集合：

  Collection<String> synchronizedCollection = SynchronizedCollection.synchronizedCollection(new ArrayList<>());
  

• 创建一个不可修改的映射：

  Map<String, Integer> unmodifiableMap = UnmodifiableMap.unmodifiableMap(new HashMap<>());
  

迭代器和迭代器

• 使用 IteratorUtils 迭代器工具类来操作集合：

  List<String> list = Arrays.asList("apple", "banana", "orange");
  Iterator<String> iterator = IteratorUtils.filteredIterator(list.iterator(), s -> s.startsWith("a"));
  while (iterator.hasNext()) {
      System.out.println(iterator.next());
  }
  

转换器和变形器

• 使用 Transformer 对集合元素进行转换：

  List<String> list = Arrays.asList("apple", "banana", "orange");
  Transformer<String, Integer> transformer = input -> input.length();
  Collection<Integer> transformedCollection = CollectionUtils.collect(list, transformer);
  System.out.println("Transformed Collection: " + transformedCollection);
  

额外的数据结构

• 使用 BidiMap 进行双向映射：

  BidiMap<String, String> bidiMap = new DualHashBidiMap<>();
  bidiMap.put("apple", "red");
  bidiMap.put("banana", "yellow");
  System.out.println("Value for key 'banana': " + bidiMap.get("banana"));
  System.out.println("Key for value 'yellow': " + bidiMap.inverseBidiMap().get("yellow"));
  

• 使用 MultiMap 存储多个值的映射：

  MultiValuedMap<String, String> multiMap = new ArrayListValuedHashMap<>();
  multiMap.put("fruits", "apple");
  multiMap.put("fruits", "banana");
  System.out.println("All fruits: " + multiMap.get("fruits"));
  

• 使用 Bag 对元素进行计数：

  Bag<String> bag = new HashBag<>(Arrays.asList("apple", "banana", "banana", "orange"));
  System.out.println("Count of 'banana': " + bag.getCount("banana"));
  

- commons-math3

maven依赖：

<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-math3</artifactId>
   <version>3.6.1</version>
</dependency>

- commons-compress

提供了对各种压缩格式的支持和处理。它提供了一组用于处理压缩文件和流的工具和类。

• 支持的压缩格式：Commons Compress支持许多常见的压缩格式，例如ZIP、GZIP、BZIP2、TAR等。它允许你对这些格式的文件进行压缩、解压缩和存储操作。

• 压缩和解压缩功能：Commons Compress提供了用于压缩和解压缩文件和流的API和类。你可以使用这些类来创建、读取和写入压缩文件，并对其进行解压缩操作。

• 支持多种压缩算法：Commons Compress支持多种压缩算法，包括Deflate（在ZIP和GZIP中使用）、BZIP2、LZMA等。它通过提供不同的压缩器和解压缩器类来处理不同的算法。

• 文件和目录的压缩：Commons Compress允许你对单个文件或整个目录进行压缩和解压缩操作。你可以递归地压缩目录中的所有文件和子目录，并选择性地包含或排除特定的文件。

• 流式压缩和解压缩：除了处理文件和目录外，Commons Compress还允许你对输入流和输出流进行压缩和解压缩操作。这使得你可以在不创建实际文件的情况下对数据进行压缩和解压缩。

注意事项：

1. GZIP命令本身只能压缩单个文件，无法直接压缩多个文件或压缩整个文件夹。要压缩多个文件或压缩整个文件夹，你可以使用TAR命令结合GZIP命令来完成。

maven依赖：

<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-compress</artifactId>
   <version>1.21</version>
</dependency>

常用压缩解压方式：ZIP、GZIP、TAR、TARGZ

常见压缩解压

使用工具：

@Slf4j
public class CompressUtil {

    private static final int BUFFER_SIZE = 4096;

    /**
     * ZIP压缩
     *
     * @param files   待压缩文件列表
     * @param zipFile 压缩文件
     */
    public static void zip(List<File> files, File zipFile) {
        if (zipFile.isDirectory()) {
            throw new IllegalArgumentException("zipFile is not a directory");
        }
        if (!zipFile.getParentFile().exists()) {
            zipFile.getParentFile().mkdirs();
        }
        try (ArchiveOutputStream outputStream = new ArchiveStreamFactory().createArchiveOutputStream(ArchiveStreamFactory.ZIP, new FileOutputStream(zipFile))) {
            for (File file : files) {
                addEntry(outputStream, file, "");
            }
        } catch (Exception e) {
            log.error("ZIP压缩出错", e);
        }
    }

    private static void addEntry(ArchiveOutputStream outputStream, File file, String basePath) throws IOException {
        String entryName = basePath + file.getName();
        if (file.isDirectory()) {
            File[] nestedFiles = file.listFiles();
            for (File nestedFile : nestedFiles) {
                addEntry(outputStream, nestedFile, entryName + "/");
            }
        } else {
            ArchiveEntry entry = outputStream.createArchiveEntry(file, entryName);
            outputStream.putArchiveEntry(entry);
            IOUtils.copy(new FileInputStream(file), outputStream);
            outputStream.closeArchiveEntry();
        }
    }

    /**
     * ZIP解压
     *
     * @param zipFile   解压文件
     * @param directory 解压目录
     */
    public static void unzip(File zipFile, File directory) {
        if (directory.isFile()) {
            throw new IllegalArgumentException("directory is not a file");
        }
        if (!directory.exists()) {
            directory.mkdirs();
        }
        try (ArchiveInputStream inputStream = new ArchiveStreamFactory().createArchiveInputStream(new BufferedInputStream(new FileInputStream(zipFile)))) {
            ArchiveEntry entry;
            while ((entry = inputStream.getNextEntry()) != null) {
                if (!inputStream.canReadEntryData(entry)) continue;
                File currentFile = new File(directory, entry.getName());
                if (entry.isDirectory()) {
                    currentFile.mkdirs();
                } else {
                    currentFile.getParentFile().mkdirs();
                    try (OutputStream outputFileStream = new FileOutputStream(currentFile)) {
                        IOUtils.copy(inputStream, outputFileStream);
                    }
                }
            }
        } catch (Exception e) {
            log.error("ZIP解压出错", e);
        }
    }

    /**
     * GZIP压缩
     *
     * @param file     待压缩文件
     * @param gzipFile 压缩文件
     */
    public static void gzip(File file, File gzipFile) {
        if (gzipFile.isDirectory()) {
            throw new IllegalArgumentException("gzipFile is not a directory");
        }
        if (!gzipFile.getParentFile().exists()) {
            gzipFile.getParentFile().mkdirs();
        }
        try (FileInputStream fis = new FileInputStream(file);
             FileOutputStream fos = new FileOutputStream(gzipFile);
             GzipCompressorOutputStream gzos = new GzipCompressorOutputStream(fos)) {

            byte[] buffer = new byte[BUFFER_SIZE];
            int len;
            while ((len = fis.read(buffer)) > 0) {
                gzos.write(buffer, 0, len);
            }
        } catch (Exception e) {
            log.error("GZIP压缩出错", e);
        }
    }

    /**
     * GZIP解压
     *
     * @param gzipFile 待解压文件
     * @param file     解压文件
     */
    public static void ungzip(File gzipFile, File file) {
        if (file.isDirectory()) {
            throw new IllegalArgumentException("file is not a directory");
        }
        if (!file.getParentFile().exists()) {
            file.getParentFile().mkdirs();
        }
        try (FileInputStream fis = new FileInputStream(gzipFile);
             GzipCompressorInputStream gzis = new GzipCompressorInputStream(fis);
             FileOutputStream fos = new FileOutputStream(file)) {

            byte[] buffer = new byte[BUFFER_SIZE];
            int len;
            while ((len = gzis.read(buffer)) > 0) {
                fos.write(buffer, 0, len);
            }
        } catch (Exception e) {
            log.error("GZIP解压出错", e);
        }
    }

    /**
     * TAR压缩
     *
     * @param files   待压缩文件列表
     * @param tarFile 压缩文件
     */
    public static void tar(List<File> files, File tarFile) {
        if (tarFile.isDirectory()) {
            throw new IllegalArgumentException("tarFile is not a directory");
        }
        if (!tarFile.getParentFile().exists()) {
            tarFile.getParentFile().mkdirs();
        }
        try (TarArchiveOutputStream tarOut = new TarArchiveOutputStream(new FileOutputStream(tarFile))) {
            for (File inputFile : files) {
                addFileToTar(tarOut, inputFile, "");
            }
        } catch (Exception e) {
            log.error("TAR压缩出错", e);
        }
    }

    /**
     * 将文件添加到tar压缩包中
     *
     * @param tarOut
     * @param file
     * @param parentEntryName
     * @throws IOException
     */
    private static void addFileToTar(TarArchiveOutputStream tarOut, File file, String parentEntryName) throws IOException {
        String entryName = parentEntryName + file.getName();
        TarArchiveEntry tarEntry = new TarArchiveEntry(file, entryName);
        tarOut.putArchiveEntry(tarEntry);
        if (file.isFile()) {
            try (InputStream in = new FileInputStream(file)) {
                IOUtils.copy(in, tarOut);
            }
            tarOut.closeArchiveEntry();
        } else if (file.isDirectory()) {
            tarOut.closeArchiveEntry();
            File[] children = file.listFiles();
            if (children != null) {
                for (File child : children) {
                    addFileToTar(tarOut, child, entryName + "/");
                }
            }
        }
    }

    /**
     * TAR解压
     *
     * @param tarFile   待解压文件
     * @param directory 解压目录
     */
    public static void untar(File tarFile, File directory) {
        if (directory.isFile()) {
            throw new IllegalArgumentException("file is not a file");
        }
        try (TarArchiveInputStream tarIn = new TarArchiveInputStream(new FileInputStream(tarFile))) {
            ArchiveEntry entry;
            while ((entry = tarIn.getNextEntry()) != null) {
                if (!tarIn.canReadEntryData(entry)) {
                    continue;
                }
                File entryFile = new File(directory, entry.getName());
                if (entry.isDirectory()) {
                    if (!entryFile.exists()) {
                        entryFile.mkdirs();
                    }
                } else {
                    File parent = entryFile.getParentFile();
                    if (!parent.exists()) {
                        parent.mkdirs();
                    }
                    try (OutputStream out = new FileOutputStream(entryFile)) {
                        IOUtils.copy(tarIn, out);
                    }
                }
            }
        } catch (Exception e) {
            log.error("TAR解压出错", e);
        }
    }

    /**
     * TARGZ压缩
     *
     * @param files     待压缩文件列表
     * @param targzFile 压缩文件
     */
    public static void targz(List<File> files, File targzFile) {
        if (targzFile.isDirectory()) {
            throw new IllegalArgumentException("targzFile is not a directory");
        }
        if (!targzFile.getParentFile().exists()) {
            targzFile.getParentFile().mkdirs();
        }
        try (FileOutputStream fos = new FileOutputStream(targzFile);
             BufferedOutputStream bos = new BufferedOutputStream(fos);
             GzipCompressorOutputStream gzos = new GzipCompressorOutputStream(bos);
             TarArchiveOutputStream tarOutput = new TarArchiveOutputStream(gzos)) {
            for (File file : files) {
                addFileToTar(tarOutput, file, "");
            }
            tarOutput.finish();
        } catch (Exception e) {
            log.error("TARGZ压缩出错", e);
        }
    }

    /**
     * TARGZ解压
     *
     * @param targzFile 待解压文件
     * @param directory 解压目录
     */
    public static void untargz(File targzFile, File directory) {
        if (directory.isFile()) {
            throw new IllegalArgumentException("directory is not a file");
        }
        try (FileInputStream fis = new FileInputStream(targzFile);
             BufferedInputStream bis = new BufferedInputStream(fis);
             GzipCompressorInputStream gzis = new GzipCompressorInputStream(bis);
             TarArchiveInputStream tarInput = new TarArchiveInputStream(gzis)) {
            TarArchiveEntry entry;
            while ((entry = tarInput.getNextTarEntry()) != null) {
                File outputFile = new File(directory, entry.getName());
                if (entry.isDirectory()) {
                    if (!outputFile.exists()) {
                        outputFile.mkdirs();
                    }
                } else {
                    outputFile.getParentFile().mkdirs();
                    try (FileOutputStream fos = new FileOutputStream(outputFile);
                         BufferedOutputStream bos = new BufferedOutputStream(fos)) {
                        byte[] buffer = new byte[BUFFER_SIZE];
                        int bytesRead;
                        while ((bytesRead = tarInput.read(buffer)) != -1) {
                            bos.write(buffer, 0, bytesRead);
                        }
                    }
                }
            }
        } catch (Exception e) {
            log.error("TARGZ解压出错", e);
        }
    }

    public static void main(String[] args) {
        List<File> sourceFiles = Arrays.asList(new File("E:\\test\\a.txt"), new File("E:\\test\\b.txt"), new File("E:\\test\\aaa"));
        File compressFile;
        File decompresDir;

        File sourceFile;
        File decompresFile;

        // zip
        compressFile = new File("E:\\test\\zip\\zip\\hhhh.zip");
        CompressUtil.zip(sourceFiles, compressFile);
        decompresDir = new File("E:\\test\\zip\\unzip");
        CompressUtil.unzip(compressFile, decompresDir);

        // gzip
        sourceFile = new File("E:\\test\\a.txt");
        compressFile = new File("E:\\test\\gzip\\gzip\\a.txt.gz");
        CompressUtil.gzip(sourceFile, compressFile);
        decompresFile = new File(("E:\\test\\gzip\\ungzip\\a.txt"));
        CompressUtil.ungzip(compressFile, decompresFile);

        // tar
        compressFile = new File("E:\\test\\tar\\tar\\hhhh.tar");
        CompressUtil.tar(sourceFiles, compressFile);
        decompresDir = new File("E:\\test\\tar\\untar");
        CompressUtil.untar(compressFile, decompresDir);

        // targz
        compressFile = new File("E:\\test\\targz\\targz\\hhhh.tar.gz");
        CompressUtil.targz(sourceFiles, compressFile);
        decompresDir = new File("E:\\test\\targz\\untargz");
        CompressUtil.untargz(compressFile, decompresDir);
    }
}

- commons-net

提供了一套用于网络协议的API，包括FTP、SMTP、POP3、IMAP等。使用Apache Commons Net库可以简化Java程序对网络协议的处理，实现FTP、SMTP等协议的功能，并且在这些协议的基础上可以进行更高层次的封装，实现更复杂的网络应用。

maven依赖：

<dependency>
   <groupId>commons-net</groupId>
   <artifactId>commons-net</artifactId>
   <version>3.8.0</version>
</dependency>

常见组件：

FTP

Apache Commons Net提供了FTP协议的API，实现了FTP的各种功能，如登陆、上传下载、创建文件夹、删除文件、列举目录等。如需使用FTP连接，可以使用FTPClient类。

    private static void ftpTest() throws IOException {
        FTPClient ftpClient = new FTPClient();
        // 设置控制编码为UTF-8
        ftpClient.setControlEncoding("UTF-8");
        // 创建连接
        ftpClient.connect("127.0.0.1", 21);
        // 登录
        ftpClient.login("anonymous", "");
        // 设置数据编码为UTF-8
        ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
        ftpClient.setFileTransferMode(FTPClient.STREAM_TRANSFER_MODE);
        ftpClient.setCharset(Charset.forName("UTF-8"));
        // 当前目录
        System.out.println(ftpClient.printWorkingDirectory());
        // cd /upload目录
        ftpClient.changeWorkingDirectory("/upload");
        System.out.println(ftpClient.printWorkingDirectory());
        // 上传文件
        boolean flag = ftpClient.storeFile("/upload/a.txt", new FileInputStream(new File("E:\\test\\a.txt")));
        System.out.println(String.format("上传文件：%s", flag));
        // 关闭连接
        ftpClient.disconnect();
    }

SMTP

Apache Commons Net提供了SMTP协议的API，实现了SMTP的各种功能，如发送邮件、附件，对邮件进行编码、解码等。如需使用SMTP协议进行发送邮件，可以使用SMTPClient类。

POP3

Apache Commons Net提供了POP3协议的API，实现了POP3的各种功能，如接收邮件，查看邮件，删除邮件等。如需使用POP3协议接收邮件，可以使用POP3Client类。

IMAP

Apache Commons Net提供了IMAP协议的API，实现了IMAP的各种功能，如接收邮件，查看邮件，删除邮件等。如需使用IMAP协议接收邮件，可以使用IMAPClient类。

- commons-csv

Apache Commons CSV 是一个 Java 库，用于解析和生成以逗号分隔的值（CSV）格式的数据。它提供了简单易用的 API，可以方便地读取和写入 CSV 文件。

maven依赖：

<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-csv</artifactId>
   <version>1.9.0</version>
</dependency>

CSV读取写入

使用示例：

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {


    public String userId;

    public String userName;

    public String sex;
}

public class CsvTest {

    public static void main(String[] args) throws Exception {
        String fileName = "E:\\test\\user.csv";

        // 写入
        List<User> data = new ArrayList<>();
        data.add(new User("111", "哈^哈", "男"));
        data.add(new User("222", "呵呵", "男"));
        data.add(new User("333", "嘻\"嘻", "女"));
        PrintWriter printWriter = new PrintWriter(fileName);
        CSVPrinter printer = CSVFormat.DEFAULT.builder()
                .setHeader("userId", "userName", "sex")
                .setDelimiter("^")
                .setQuoteMode(QuoteMode.MINIMAL)
                .setQuote('"')
                .build()
                .print(printWriter);
        for (User user : data) {
            printer.printRecord(user.getUserId(), user.getUserName(), user.getSex());
        }
        printer.flush();
        printer.close();

        // 读取
        FileReader fileReader=new FileReader(fileName);
        CSVParser parser = CSVFormat.DEFAULT.builder()
                .setHeader("userId", "userName", "sex")
                .setSkipHeaderRecord(true)
                .setDelimiter('^')
                .setQuoteMode(QuoteMode.MINIMAL)
                .setQuote('"')
                .build()
                .parse(fileReader);
        List<User> list = new LinkedList<>();
        for (CSVRecord record : parser.getRecords()) {
            list.add(new User(record.get("userId"), record.get("userName"), record.get("sex")));
        }
        System.out.println(String.format("读取到的数据：%s", JSON.toJSONString(list)));
        fileReader.close();
        parser.close();
    }
}

user.csv

日志

读取到的数据：[{"sex":"男","userId":"111","userName":"哈^哈"},{"sex":"男","userId":"222","userName":"呵呵"},{"sex":"女","userId":"333","userName":"嘻\"嘻"}]

- commons-configuration2

Apache Commons Configuration 是 Apache 软件基金会下的一个开源项目，提供了一套用于处理配置信息的工具库。

maven依赖：

<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-configuration2</artifactId>
   <version>2.7</version>
</dependency>

主要功能：

• 支持读取和保存多种配置格式，如 properties、XML、JSON、YAML 等。
• 提供了配置值的类型转换功能，允许配置值被解释成程序中的合适的数据类型。
• 支持对配置文件进行动态更新，当配置文件发生改变时，能够自动重新加载最新的配置信息。
• 提供了支持表达式和变量替换的功能，在配置文件中可以使用变量和动态表达式。

功能分类：

• 配置文件的加载和管理：

  使用 Commons Configuration 2 可以轻松地加载和管理配置文件。它提供了一种统一的接口，可以方便地加载和获取各种格式的配置信息，并支持跨多种配置格式的无缝切换。

• 类型转换：

  Commons Configuration 2 具有强大的类型转换功能，可以自动将配置值转换成需要的数据类型。这使得开发者在读取配置值时无需手动进行类型转换，简化了代码逻辑。

• 动态更新：

  该库支持动态更新配置信息，当配置文件发生变化时，应用程序可以自动重新加载最新的配置信息，而无需重启应用程序。

• 表达式和变量替换：

  Commons Configuration 2 支持在配置文件中使用表达式和变量替换，这使得配置文件中的值更加灵活和动态化。

- commons-text

Apache Commons Text 是 Apache Commons 项目下的一个子项目，旨在提供一组文本处理相关的实用工具类。

maven依赖：

<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-text</artifactId>
   <version>1.10.0</version>
</dependency>

主要功能：

• 字符串操作：提供了字符串操作的工具类，例如字符串切割、字符串连接、字符串替换等。

• 格式化和解析：提供了各种文本格式化和解析的工具类，例如数字格式化、日期格式化、货币格式化等。

• 字符串转义：提供了字符串转义的工具类，例如Unicode转义、HTML实体转义等。

• 字符串生成：提供了生成随机字符串、密码等的工具类。

单词处理工具：WordUtils

WordUtils 是一个用于处理单词的工具类，提供了一些常见的文本操作，特别是对单词进行格式化和修正。

方法	方法描述
capitalize(String str)	将字符串中所有分隔符分隔的每个单词的首字母大写
capitalize(String str, char… delimiters)	将字符串中所有分隔符分隔的每个单词的首字母大写，可指定分隔符
capitalizeFully(String str)	将字符串中所有分隔符分隔的每个单词的首字母大写，其余小写。
capitalizeFully(String str, char… delimiters)	将字符串中所有分隔符分隔的每个单词的首字母大写，其余小写。，可指定分隔符
uncapitalize(String str)	将字符串中所有分隔符分隔的每个单词的首字母小写
uncapitalize(String str, char… delimiters)	将字符串中所有分隔符分隔的每个单词的首字母小写，可指定分隔符
swapCase(String str)	将字符串中大写字母转换为小写，小写字母转换为大写。
initials(String str)	获取字符串中每个单词的首字母，并返回它们的组合。
wrap(String str,int wrapLength)	将字符串按照指定的长度进行换行。

大小写转换工具：CaseUtils

CaseUtils 是一个用于处理字符串大小写的工具类，提供了多种方法来改变字符串的大小写格式，特别是在不同的命名约定之间转换时非常有用。

方法	方法描述
toCamelCase(String str, boolean capitalizeFirstLetter, char… delimiters)	将字符串转换为驼峰命名法形式的字符串。可以指定是否将首字母大写以及分隔符的字符数组。

转义工具：StringEscapeUtils

StringEscapeUtils 是一个用于处理字符串转义和反转义的工具类，主要用于处理与 HTML、XML、Java 字符串等相关的转义和反转义操作。

字符串转义工具类。

方法	方法描述
escapeCsv(String str)	将字符串中的CSV特殊字符进行转义，例如逗号、双引号等。
escapeEcmaScript(String str)	将字符串中的ECMAScript/JavaScript特殊字符进行转义，例如双引号、反斜线等。
escapeHtml4(String str)	将字符串中的HTML4特殊字符进行转义，例如小于号、大于号等。
escapeJava(String str)	将字符串中的Java特殊字符进行转义，例如双引号、反斜线等。
escapeJson(String str)	将字符串中的JSON特殊字符进行转义，例如引号、反斜线等。
escapeSql(String str)	将字符串中的SQL特殊字符进行转义，例如引号、单引号等。
escapeXml(String str)	将字符串中的XML特殊字符进行转义，例如小于号、大于号等。
escapeXSI(String str)	将字符串中的XSI(XMLSchemaInstance)特殊字符进行转义。
unescapeCsv(String str)	将字符串中的CSV转义字符还原为原始字符。
unescapeEcmaScript(String str)	将字符串中的ECMAScript/JavaScript转义字符还原为原始字符。
unescapeHtml4(String str)	将字符串中的HTML4转义字符还原为原始字符。
unescapeJava(String str)	将字符串中的Java转义字符还原为原始字符，例如将"\n"转换为换行符。
unescapeJson(String str)	将字符串中的JSON转义字符还原为原始字符。
unescapeSql(String str)	将字符串中的SQL转义字符还原为原始字符。
unescapeXml(String str)	将字符串中的XML转义字符还原为原始字符。
unescapeXSI(String str)	将字符串中的XSI(XMLSchemaInstance)转义字符还原为原始字符。

使用示例：

public class TextTest {

    public static void main(String[] args) {
        System.out.println("---------------------------------------------------------");
        String str = "HellO worlD";
        System.out.println("原字符串：" + str);

        // 单词首字母大写
        System.out.println("单词首字母大写：" + WordUtils.capitalize(str));

        // 单词首字母大写，其它小写
        System.out.println("单词首字母大写，其它小写：" + WordUtils.capitalizeFully(str));

        // 单词首字母大写
        System.out.println("单词首字母小写：" + WordUtils.uncapitalize(str));
        System.out.println("---------------------------------------------------------");

        String input = "user_type-desc";
        System.out.println("原字符串：" + input);

        // 字符串转驼峰，首字母小写，指定分隔符为_、-
        String camelCase = CaseUtils.toCamelCase(input, false, '_','-');
        System.out.println("字符串转驼峰，首字母小写：" + camelCase);

        // 字符串转驼峰，首字母大写，指定分隔符为_、-
        String camelCaseCapitalized = CaseUtils.toCamelCase(input, true, '_','-');
        System.out.println("字符串转驼峰，首字母大写：" + camelCaseCapitalized);
        System.out.println("---------------------------------------------------------");

        String htmlString = "<div>Hello, world!</div>";
        System.out.println("原字符串：" + htmlString);

        // HTML实体转义
        String escapedHtml = StringEscapeUtils.escapeHtml4(htmlString);
        System.out.println("转义后的HTML字符串：" + escapedHtml);

        // HTML实体反转义
        String unescapedHtml = StringEscapeUtils.unescapeHtml4(escapedHtml);
        System.out.println("反转义后的HTML字符串：" + unescapedHtml);
        System.out.println("---------------------------------------------------------");

        // 生成随机字符串
        RandomStringGenerator generator = new RandomStringGenerator.Builder()
                .withinRange('0', 'z')
                .filteredBy(Character::isLetter)
                .build();
        String randomString = generator.generate(10);
        System.out.println("生成的随机字符串：" + randomString);
        System.out.println("---------------------------------------------------------");
    }
}

日志：

---------------------------------------------------------
原字符串：HellO worlD
单词首字母大写：HellO WorlD
单词首字母大写，其它小写：Hello World
单词首字母小写：hellO worlD
---------------------------------------------------------
原字符串：user_type-desc
字符串转驼峰，首字母小写：userTypeDesc
字符串转驼峰，首字母大写：UserTypeDesc
---------------------------------------------------------
原字符串：<div>Hello, world!</div>
转义后的HTML字符串：&lt;div&gt;Hello, world!&lt;/div&gt;
反转义后的HTML字符串：<div>Hello, world!</div>
---------------------------------------------------------
生成的随机字符串：zEkAgsMDiQ
---------------------------------------------------------

原文地址：https://blog.csdn.net/JokerLJG/article/details/135511686

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！