概述
一.Apache的Jakarta commons工程下具有一系列公共基础类。例如Lang,IO,Pool,BeanUtils等等。
Apache的Jakarta commons工程项目列表路径：http://commons.apache.org
Commons基础类包基本上是基于JDK API开发而来，依赖微小，可重用性是Jakarta commons的灵魂所在。
Lang组件主要是一些工具类，涉及到数组工具类，字符串工具类，字符工具类，数学方面，时间日期工具类，异常，事件等工具类。
阅读Apache-Commons-Lang包下常用的数组，字符串，字符工具类的实现，能在实际开发中避免过多的写相关字符串处理，数组处理的通用方法。很多时候，已经重复做了好多本不需要做的工作，在一个项目中字符串，数组的处理是相当频繁的。
得益于亲身体会，截取字符串，替换字符串，字符串字符排序，查找各式各样的操作，每次到要针对一个问题去处理，反反复复编写着相似的代码，一直有些反感，这一点我们并没有采用拿来主义，我也看到好多项目中有一些成为utils或者tools的子包，里面放置这一些字符串处理，数据格式转换等工具类，事实上，这些工作已经有人做了，而且做很很好的封装，组织。
Lang组件中的工具类的方法是静态方法，直接使用，命名清晰明了，能够很好的解决问题。有时候，拿来主义是必须了，Lang包下的工具类实现并非有什么高超的编码技巧，实现方式，其有效的组织和归纳一些列工具类型的方法，具备高可重用性是其价值的体现。
通过阅读Commons-Lang下的几个常用，频繁涉及的工具类，总结一点就是工具类的组织，归纳，公共特性是其核心价值。
下面是四篇关于Commons-Lang下几个工具类的说明：
CharUtils CharSequenceUtils：
ObjectUtils Range：
ArrayUtils ：
StringUtils, RandomStringUtils:
一次尝试阅读开源组件的源代码，感受其组织代码，归纳特性，实现方法的原理，能够宏观的看公共类设计的方法，方式。另外，熟悉开源组件代码，能够将其投入到实际的工作，从而提高的生产效率，减轻编码负担。这将是软件可重新为我带来的一个切身可以享受到的好处。
------------------------------------------------------------------------------------------------------------------------------
二.Apache-commons-lang3包中提供了一系列static的方法Utils类。
ArrayUtils类使的数组操作更像String,或者Map的操作一样。
1.ArrayUtils类的基本方法
| EMPTY_OBJECT_ARRAY : Object[] | 长度为0的数组，每一种基本类型都有此对象 |
| toString(Object) | 指定对象转化为默认格式的字符串 |
| toString(Object, String) | 指定对象转化为指定风格的字符串 |
| isEquals(Object, Object) | 判读两个对象是否相相等 |
| toMap(Object[]) | 数组对象转化为Map对象 |
| toArray(T...) | 动态参数转化为数组 |
| | |
| | |
| clone(T[]) | toPrimitive(Integer[]) |
| nullToEmpty(Object[]) | toPrimitive(Integer[], int) |
| subarray(T[], int, int) | toObject(int[]) |
| isSameLength(Object[], Object[]) | isEmpty(Object[]) |
| getLength(Object) | isNotEmpty(T[]) |
| isSameType(Object, Object) | addAll(T[], T...) |
| reverse(Object[]) | add(T[], T) |
| indexOf(Object[], Object) | add(T[], int, T) |
| indexOf(Object[], Object, int) | remove(T[], int) |
| lastIndexOf(Object[], Object) | removeElement(T[], Object) |
| lastIndexOf(Object[], Object, int) | removeAll(T[], int...) |
| contains(Object[], Object) | removeElements(T[], T...) |
上面例如：subarray,clone,nullToEmpty, indexOf, lastIndexOf更加类似字符串的操作，addAll,add,remove,removeAll,removeElement等像操作Map.
这些方法有大量的重载用来实现不同类型的数组。例如int[]数组重载reverse(int []).
2.ArrayUtils.toMap(Object[] array)方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
public
static
Map<Object, Object> toMap(Object[] array) {
if
(array ==
null
) {
return
null
;
}
final
Map<Object, Object> map =
new
HashMap<Object, Object>((
int
) (array.length *
1.5
));
for
(
int
i =
0
; i < array.length; i++) {
Object object = array[i];
if
(object
instanceof
Map.Entry<?, ?>) {
Map.Entry<?,?> entry = (Map.Entry<?,?>) object;
map.put(entry.getKey(), entry.getValue());
}
else
if
(object
instanceof
Object[]) {
Object[] entry = (Object[]) object;
if
(entry.length <
2
) {
throw
new
IllegalArgumentException(
"Array element "
+ i +
", '"
+ object
+
"', has a length less than 2"
);
}
map.put(entry[
0
], entry[
1
]);
}
else
{
throw
new
IllegalArgumentException(
"Array element "
+ i +
", '"
+ object
+
"', is neither of type Map.Entry nor an Array"
);
}
}
return
map;
}
|
toMap方法的实现，让二维数组以Key-Value的形式转化为Map，从源代码中的map.put(entry[0],entry[1]);可以看出一个数组元素长度为2，多出部分不作为转化Map的一部分。
如图下解释：
测试实例：
|
1
2
3
4
5
6
7
|
Object[][] array =
new
String[
2
][
2
];
array[
0
] =
new
String[] {
"k0"
,
"v0"
,
"e0"
};
array[
1
] =
new
String[] {
"k1"
,
"v1"
,
"e1"
};
Map<Object, Object> map = ArrayUtils.toMap(array);
for
(Object obj : map.keySet()) {
System.out.println(map.get(obj));
}
|
上面使用toMap(Object[])方法的后输出的结果是：v0 n v1.说明转化Map的时候仅仅截取数组的前两个元素，第一个作为Key，第二个作为Value.
3.关注基本类型数组和包装类型数组之间转换的方法
基本类型和引用类型之间的转换（AutoBoxing和UnBoxing），即基本类型数组和基本类型对应的引用类型之间的转换
toPrimitive(Integer[]) : int []
toPrimitive(Integer[], int) int[];特别说明：int参数是对Integer[]数组中为null的元素的替换值。
toObject(int[]) Integer[]
同样，ArrayUtils对基本类型都提供了对象的重载方法。
ArrayUtils提供的方法使数组的操作更加便捷，功能更加强大，特别是截取，查找，包装等常用方法的实现有很高的重用性。
------------------------------------------------------------------------------------------------------------------------------
三.ObjectUtils类重新实现了toString,equals，hashcode生成策略等方法，增加了null对象的处理，对象的比较，一组对象中对象的频繁出现，最佳猜测策略，克隆的方法。
ObjectUtils类的基本static方法：
| defaultIfNull(T, T) | 参数1为null,用参数2代替 |
| firstNonNull(T...) | 获取指定参数列表中第一个不为null的元素 |
| equals(Object, Object) | |
| notEqual(Object, Object) | |
| hashCode(Object) | |
| hashCodeMulti(Object...) | 多对象hashcode生成策略 |
| identityToString(Object) | |
| identityToString(StringBuffer, Object) | |
| toString(Object) | |
| toString(Object, String) | |
| min(T...) | 获取指定参数列表中最小的元素 |
| max(T...) | 获取指定参数列表中最大的元素 |
| compare(T, T) | 比较两个参数大小，默认null小于任何不为null的值 |
| compare(T, T, boolean) | 比较两个参数大小，参数3设置null的大小，false为小于任何不为null的值true相反 |
| median(T...) | 以最佳猜测的方式获取参数列表中的中间值，如果列表数为偶数，则中间值取低位的值 |
| median(Comparator<T>, T...) | 重载方法，提供最佳猜测的排序策略 |
| mode(T...) | 获取参数列表中最频繁出现的项 |
| clone(T) | |
| cloneIfPossible(T) |
1.compare(T,T,boolean)对象比较的新策略。
compare是静态方法，则ObjectUtils.compare(a, b, false)做比较。
源代码：
|
1
2
3
4
5
6
7
8
9
10
11
|
public
static
<T
extends
Comparable<?
super
T>>
int
compare(T c1, T c2,
boolean
nullGreater) {
if
(c1 == c2) {
return
0
;
}
else
if
(c1 ==
null
) {
return
nullGreater ?
1
: -
1
;
}
else
if
(c2 ==
null
) {
return
nullGreater ? -
1
:
1
;
}
return
c1.compareTo(c2);
}
|
从源代码上分析，参数nullGreater为true时null大于任何不为null的对象，false时null小于任何不为null的对象。
2.median(Comparator<T>, T...)和median(T...)
这两个方法重载，第一个方法提供了参数列表对象的排序策略，第二个方法采用了Java中Tree的默认排序策略。目的是找出参数序列的中间元素，如果参数序列元素数为偶数个则中间元素取低位的。
Range类，具有范围的对象。适合可比较对象，Range范围不可变，可以存在任意类型对象范围，范围内的元素类型应该保持一致。
Range类的基本静态方法：
| 访问方法 | |
| getMinimum() | 获取最小元素 |
| getMaximum() | 获取最大元素 |
| getComparator() | 获取比较器对象 |
| isNaturalOrdering() | 判断是否是自然排序 |
| | |
| 元素类方法 | |
| contains(T) | 判断T元素是否在对象访问类 |
| isBefore(T) | 判断T元素是否在对象最大范围之后 |
| isAfter(T) | 判断T元素是否在对象最小范围之前 |
| isStartedBy(T) | 判断T元素是否是对象范围开始元素，即T==minElement |
| isEndedBy(T) | 判断T元素是否是对象范围结束元素，即T==maxElement |
| elementCompareTo(T) | 判断T元素在对象访问的位置，返回int值，位置如：-1[minElement 0 maxElement]1 |
| | |
| | |
| 范围方法 | 下面方法的执行条件是范围元素类型一致且比较策略一致（compare） |
| containsRange(Range<T>) | 参数范围对象是否包含在对象范围 |
| isAfterRange(Range<T>) | 参数范围对象是否在对象范围之前 |
| isBeforeRange(Range<T>) | 参数范围对象是否在对象范围之后 |
| isOverlappedBy(Range<T>) | 参数范围对象是否和对象范围有交集 |
| intersectionWith(Range<T>) | 求参数范围对象和对象范围的交集范围对象 |
1.Range类有一个final类型的Comparator<T> comparator属性对象，即一个不可变的范围对象需要提供一个比较策略。
2.Range类默认的比较策略为自然比较
源代码如下：
|
1
2
3
|
public
int
compare(Object obj1, Object obj2) {
return
((Comparable) obj1).compareTo(obj2);
}
|
Range类和ObjectUtils类都是基于Object的实现，在管理对象方面有极大便利。
------------------------------------------------------------------------------------------------------------------------------
四.Apacehe-commons-lang中提供了ChartUtils这个以关键性的工具类，充分的对字符转换字符串，字符转换字符对象，转换整型，字符串转换，null和空字符串等提供了处理。
1.ChartUtils提供的方法
| toCharacterObject(char) | 将参数字符转换为字符对象 |
| toCharacterObject(String) | 将参数字符串的第一个字符转换为字符对象 |
| toChar(Character) | 将参数字符对象转换为字符 |
| toChar(Character, char) | 将第一个参数字符对象转换为字符，若为null则用第二个参数代替 |
| toChar(String) | 将参数字符串的第一个字符转换为字符 |
| toChar(String, char) | 将第一个参数字符串的第一个字符转换为字符，若为null或者长度为0则用第二个参数代替 |
| toIntValue(char) | 字符转换整型 |
| toIntValue(char, int) | |
| toIntValue(Character) | |
| toIntValue(Character, int) | |
| toString(char) | 字符转换字符串 |
| toString(Character) | |
| unicodeEscaped(char) | 对字符进行unicode编码转换 |
| unicodeEscaped(Character) | |
| isAscii(char) | |
| isAsciiPrintable(char) | 判断参数字符是否为打印字符[32,127) |
| isAsciiControl(char) | 判断参数字符是否为控制字符,小于32或者等于127 |
| isAsciiAlpha(char) | 对字符进行字母，大小写字母，数字等进行判断 |
| isAsciiAlphaUpper(char) | |
| isAsciiAlphaLower(char) | |
| isAsciiNumeric(char) | |
| isAsciiAlphanumeric(char) |
2.关于toChar(String, char)方法
|
1
2
3
4
5
6
|
public
static
char
toChar(String str,
char
defaultValue) {
if
(StringUtils.isEmpty(str)) {
return
defaultValue;
}
return
str.charAt(
0
);
}
|
说明：字符串的第一个字符作为转换后的char,当字符串为null或者长度为0的时候，将用第二个参数defaultvalue替代作为返回字符。
在1.中个各方法相关的第二个参数通常作为替代值出现。
3.ChartUtils工具类实现对字符的判断，例如，数子，大小写字母，控制字符。
以isAscii(char)代表的一系列isXXX(char)方法实现了这些功能。内部实现主要是基于字符与ASCII码之间的对应关系。
Apache-commons-lang提供的CharSequenceUtils类对字符序列进行处理。字符序列处理和字符串处理有着极大的相似之处。
4.CharSequenceUtils类提供的基本方法
| subSequence(CharSequence, int) | 截取字符序列 |
| indexOf(CharSequence, int, int) | 从前往后判断第二个参数值在字符序列中的位置 |
| indexOf(CharSequence, CharSequence, int) | |
| lastIndexOf(CharSequence, int, int) | 从后往前判断第二个参数值在字符序列中的位置 |
| lastIndexOf(CharSequence, CharSequence, int) | |
| toCharArray(CharSequence) | 字符序列转换为字符数组 |
| regionMatches(CharSequence, boolean, int, CharSequence, int, int) | 字符序列匹配，第二个参数大小写处理方式true忽略大小写，false反之 |
5.提供的Char相关的类有ChartUtils，CharSequenceUtils,CharSet,ChartSetUtils,CharEncoding,CharRange类对字符和字符对象进行了相关处理，提供了一套完整的字符处理工具集合。
参见其他工具类：
ObjectUtils Range：
http://aiilive.blog.51cto.com/1925756/1282061
ArrayUtils ：
http://aiilive.blog.51cto.com/1925756/1282062
StringUtils, RandomStringUtils:
http://aiilive.blog.51cto.com/blog/1925756/1282146
个人认为字符工具了能在字符流的处理中能给解决问题带来很大的方便。字符串的转换，字符和整型的转换，字符集合，字符编码，字符序列的处理都可能在处理字符流过程中的细节问题上发挥很大的功效。
----------------------------------------------------------------------------------------------------------------------------
五.Apache-commons-lang中的StringUtils工具类中提供了相当丰富的方法，涉及到判断，截取，排序，选择，查找，计算，替换，转换等方面。
1.StringUtils工具类的一些方法
| isEmpty(CharSequence) | 判断字符序列是否为null,或者长度为0 |
| isBlank(CharSequence) | 判读字符序列是否为null,或者长度为0，或者为空字符 |
| trim(String) | 两种去除字符串前后空字符方法，各自有不同实现的 重载方法 |
| strip(String) | |
| equals(CharSequence, CharSequence) | 比较连个字符序列 |
| indexOf(CharSequence, int) | 字符串自身方法的包装，调用 CharSequenceUtils类中的方法 |
| lastIndexOf(CharSequence, int) | |
| contains(CharSequence, int) | |
| indexOfAny(CharSequence, char...) | 返回第二个参数中任意字符在第一个参数字符序列中存在的第一个下标 |
| containsAny(CharSequence, char...) | 第一个参数字符序列中是否存在第二个参数字符中的任意字符 |
| substring(String, int) | |
| left(String, int) | 从左，中，右获取指定长度的字符串 |
| right(String, int) | |
| mid(String, int, int) | |
| substringBetween(String, String) | 获取第一个参数中，左右都是第二个参数的字符串 |
| split(String) | 指定字符串来分割字符串为字符串数组 |
| join(T...) | 连接数组元素为字符串 |
| deleteWhitespace(String) | 删除字符串中的空白字符 |
| replace(String, String, String) | 字符串替换 |
| overlay(String, String, int, int) | 将字符串指定部分换成另外的字符串 |
| chomp(String) | 剔除指定字符串的换行符 |
| chop(String) | 剔除指定字符串的最后一个字符，如果最后两个字符是n和r一起剔除 |
| repeat(String, int) | 重复指定字符串 |
| rightPad(String, int) | 字符串左，右不空字符 |
| leftPad(String, int) | |
| center(String, int) | 两边补空白字符 |
| upperCase(String) | 字符串转为大写字母 |
| capitalize(String) | 字符串第一个字符转为大写 |
| swapCase(String) | 字符串小写字母转大写，大写字母转小写 |
| reverse(String) | 字符串反转 |
| abbreviate(String, int) | 字符串简略，常用于外国人名的简写，书籍作者信息等 |
| difference(String, String) | 比较两个字符串，返回不同部分，不同部分来自第二个字符串 |
| getCommonPrefix(String...) | 获取字符串数组中字符串前缀相同的部分 |
| getLevenshteinDistance(CharSequence, CharSequence) | 字符串相似度 |
| startsWith(CharSequence, CharSequence) | 指定字符串是否以第二个参数字符序列结束 |
| endsWith(CharSequence, CharSequence) | 指定字符串是否以第二个参数字符序列结束 |
2.StringUtils类中方法说明
在1中的方法仅仅是StringUtils类中的一部分方法，涉及各方面的方法，每一个方法基本上都有其重载方法，用来实现更强大，更特殊的功能。
3.使用StringUtils工具类，其中有用到CharUtils工具类的属性，方法等。工具类不依赖第三方包，充分利用了Java自有的特性，功能实现各种字符，字符串，字符序列的操作。
RandomStringUtils工具类用来生成随机的字符串序列。
4.RandomStringUtils类的基本方法
| random(int) | 随机生成指定长度的字符串，字符来自所有字符 |
| randomAscii(int) | 随机生成指定长度的字符串，字符ASCII码范围[37,127） |
| randomAlphabetic(int) | 随机生成指定长度的字符串，字符为字母 |
| randomAlphanumeric(int) | 随机生成指定长度的字符串，字符为字母和数字 |
| randomNumeric(int) | 随机生成指定长度的字符串，字符为数字 |
| random(int, boolean, boolean) | 重载方法： 参数解释（指定长度，字符集开始位置，字符集结束位置，是否字母，是否数子，指定字符集，随机对象） |
| random(int, int, int, boolean, boolean) | |
| random(int, int, int, boolean, boolean, char...) | |
| random(int, int, int, boolean, boolean, char[], Random) | |
| random(int, String) | 随机生成指定长度的字符串，字符为第二个参数中字符串中的字符 |
| random(int, char...) | 随机生成指定长度的字符串，字符为第二个参数中的字符 |
5.随机生成字符串工具类提供了多种重载方法，可以自由选择生成字符序列的策略。
关于字符串，字符，字符序列处理用用到apache-commmons-lang包下已经实现的方法，可以参考这些工具类的介绍。
最后
以上就是刻苦花瓣为你收集整理的Apache-commons-lang3方法应用的全部内容，希望文章能够帮你解决Apache-commons-lang3方法应用所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
发表评论 取消回复