commons-lang3 常用工具类api整理
根据公司老员工的建议，把org.apache.commons.lang3下的一些常用工具类通读了下。下面进行了简单的整理。
文章目录
- 1. ArrayUtils
- 2. CharUtils
- 3. ClassUtils
- 4. EnumUtils
- 5. ObjectUtils
- 6. RandomUtils
- 7. StringUtils
public static final int[] INT_ARRAY = {1,2,3,4};
public static final String[] STRING_ARRAY = {"tom","jack","lucy"};
1. ArrayUtils
public static String toString(final Object array): 数组转换为字符串
public static String toString(final Object array, final String stringIfNull): 数组转换为字符串，当数组为null的时候，返回第二个参数。
int[] nums = {1,2,3,4};
int[] nums2 = null;
String s = ArrayUtils.toString(nums);//{1,2,3,4}
String s2 = ArrayUtils.toString(nums2);//{}
int[] nums = {1,2,3,4};
int[] nums2 = null;
String s = ArrayUtils.toString(nums,"[]");//{1,2,3,4}注意不是[1,2,3,4]
String s2 = ArrayUtils.toString(nums2,"[]");//[]
public static : 可变参数转数组，其实可变参数实质上就是个数组
public static Map:数组转map，要求数组元素要么为java.util.Map.Entry对象，要么为至少包含两个元素的数组。这鬼东西要求有点多，本人平常似乎用的也不多
String[] array = ArrayUtils.toArray("tom", "jack", "lucy");
Integer[][] nums = {{1,2},{2,3},{5,6}};//使用int[][]是不行的，对象{1,2}既不是Entry对象也不认为是个数组
Map<Object, Object> map = ArrayUtils.toMap(nums);
public static ：对象元素克隆，还有常见的参数和返回类型为int[],long[]等类型的。
int[] nums = ArrayUtils.clone(INT_ARRAY);//{1,2,3,4}
public static int[] nullToEmpty(final int[] array):保护方法，如果数组为空，返回{},否则返回原数组的引用。 此外还有long[],char[]，String[]等常用类型也有该方法。
int[] nums = {};
int[] nums2 = ArrayUtils.nullToEmpty(nums);//{}
public static : 泛型类型数组截取，返回一个新数组，包含了原数组中startIndexInclusive到endIndexExclusive之间的元素左闭右开. 同样int[],double[]等也有这样的方法。很多方法都是重载的，后面就不再一一点出了
int[] nums = ArrayUtils.subarray(INT_ARRAY, 0, INT_ARRAY.length);//{1,2,3,4}
public static boolean isSameLength(final long[] array1, final long[] array2): 判断两个数组长度是否一样
boolean isSameLength = ArrayUtils.isSameLength(new int[]{1, 2, 3, 4}, new int[]{1, 2, 3, 4});
public static void reverse(final int[] array): 反转数组
public static void reverse(final int[] array, final int startIndexInclusive, final int endIndexExclusive): 从下标startIndexInclusive到endIndexExclusive之间的元素进行反转，左闭右开
ArrayUtils.reverse(INT_ARRAY);//{4,3,2,1}
public static void swap(final int[] array, int offset1, int offset2)： 交换两个位置的元素
ArrayUtils.swap(INT_ARRAY,0,INT_ARRAY.length-1);//{4,2,3,1}
public static void shift(final int[] array, int offset): 移动数组，往右移动offset位，用leetcode上的话来说，叫旋转数组可能更合适。
ArrayUtils.shift(INT_ARRAY,2);//{3,4,1,2}
public static int indexOf(final Object[] array, final Object objectToFind):查看数组中元素objectToFind的下标，默认从0为止开始找 找到第一个
public static int indexOf(final Object[] array, final Object objectToFind, int startIndex):查看数组中元素objectToFind的下标，从startIndex 位置开始找。
public static int lastIndexOf(final Object[] array, final Object objectToFind): 也是找元素下标，不过这里是最后出现的下标位置。默认从int最大值位置开始找
public static int lastIndexOf(final Object[] array, final Object objectToFind, int startIndex):同上
public static boolean contains(final Object[] array, final Object objectToFind):查看数组中是否包含元素objectToFind，调用了第一个方法。
int index = ArrayUtils.indexOf(STRING_ARRAY, "jack");//1
public static int[] toPrimitive(final Integer[] array): 将包装类型转基本类型（对象类型转原始类型），当数组中包含null值的话会抛出空指针异常。可以使用下面的重载方法
public static int[] toPrimitive(final Integer[] array, final int valueForNull): 将数组中的null值转为valueForNull存入到新的数组中
public static Integer[] toObject(final int[] array): 基本类型转包装类型（原始类型转对象类型）
Integer[] nums = ArrayUtils.toObject(INT_ARRAY);
int[] ints = ArrayUtils.toPrimitive(nums);
public static boolean isEmpty(final int[] array): 判断数组是否为空
public static boolean isNotEmpty(final int[] array): 判断数组是否不为空
public static : 将两个数组合并成一个新数组，即将两个数组中的原始都放入到一个新数组中返回
public static : 同上，末尾插入
public static int[] add(final int[] array, final int index, final int element)：在数组指定位置插入元素
* ArrayUtils.addAll(null, null) = null
* ArrayUtils.addAll(array1, null) = cloned copy of array1
* ArrayUtils.addAll(null, array2) = cloned copy of array2
* ArrayUtils.addAll([], []) = []
* ArrayUtils.addAll([null], [null]) = [null, null]
* ArrayUtils.addAll(["a", "b", "c"], ["1", "2", "3"]) = ["a", "b", "c", "1", "2", "3"]
* ArrayUtils.add(null, null) = [null]
* ArrayUtils.add(null, "a") = ["a"]
* ArrayUtils.add(["a"], null) = ["a", null]
* ArrayUtils.add(["a"], "b") = ["a", "b"]
* ArrayUtils.add(["a", "b"], "c") = ["a", "b", "c"]
* ArrayUtils.add([1], 0, 2) = [2, 1]
* ArrayUtils.add([2, 6], 2, 10) = [2, 6, 10]
* ArrayUtils.add([2, 6], 0, -4) = [-4, 2, 6]
* ArrayUtils.add([2, 6, 3], 2, 1) = [2, 6, 1, 3]
int[] nums = ArrayUtils.addAll(INT_ARRAY, 4, 5, 6);//{1,2,3,4,4,5,6}
int[] nums2 = ArrayUtils.add(INT_ARRAY, 0, -10);//{-10,1,2,3,4}
public static : 移除指定位置的元素
public static :移除指定元素，所有的该元素都移除，而不说只移除第一个
public static :移除多个指定位置的元素
public static : 移除多个元素
int[] nums = ArrayUtils.remove(INT_ARRAY, 1);//{1,3,4}
int[] arr = {1,2,3,3,3,4};
int[] nums = ArrayUtils.removeElement(INT_ARRAY, 3);//{1,2,4}
int[] nums2 = ArrayUtils.removeAll(nums, 0, 1);//{4}
public static :判断数组是否排好序了。
public static :根据自定义排序规则，判断数组是否已经排序。基本类型没有这个重载的方法
Integer[] arr = {3,2,1};
boolean isSorted = ArrayUtils.isSorted(arr);//false
boolean isSorted2 = ArrayUtils.isSorted(arr, (x,y)->y.compareTo(x));//true
此外还有一些常量，都是空数组，类似下面的样子
public static final Integer[] EMPTY_INTEGER_OBJECT_ARRAY = new Integer[0];
2. CharUtils
public static char toChar(final Character ch): char的包装类型转基本类型，ch==null的时候会抛出异常。
public static char toChar(final Character ch, final char defaultValue): char的包装类型转基本类型，ch==null的时候会返回默认值defaultValue。
public static char toChar(final String str): 字符串转char，其实是使用字符串中第一个字符去转char,如果字符串为null或者""（不包括" "）那么会抛出异常。
public static char toChar(final String str, final char defaultValue): 同上，会返回默认值。
public static int toIntValue(final char ch): char转int值，实际上就是char的值减去48，要求char属于[1,9]，否则抛出异常
public static int toIntValue(final char ch, final int defaultValue):同上，不抛出异常，但是会返回默认值 另外这两个方法还可以传入参数为Character类型
int i = CharUtils.toIntValue('1');//1
public static String toString(final char ch): char转String 或者参数为Character类型
String a = CharUtils.toString('a');//a
public static int compare(char x, char y):比较大小，就是x-y
3. ClassUtils
public static String getShortClassName(String className): 获取类名称获得类简单名，也就是去掉了包名
public static String getShortClassName(final Object object, final String valueIfNull)：根据对象，获得类简单名称，为空则返回默认值valueIfNull
public static String getShortClassName(final Class cls): 根据Class类获得类简单名
这三种方法也是获得反射中获取类名称的三中方式。
public static String getSimpleName(final Class cls):同上
public static String getSimpleName(final Object object, final String valueIfNull):同上
其实两类方法还是有点区别的，比如前面处理数组的时候，但是这里不打算探讨实现。
//使用com.scu.ArrayUtilsTest也能正确输出
ClassUtils.getShortClassName("com.scu.utils.ArrayUtilsTest");// ArrayUtilsTest
ClassUtils.getSimpleName(ArrayUtilsTest.class);// ArrayUtilsTest
public static String getPackageName(final Object object, final String valueIfNull)
public static String getPackageName(final Class cls)
public static String getPackageName(String className) 三个方法均为获得包名
ClassUtils.getPackageName("com.scu.utils.ArrayUtilsTest");// com.scu.utils
ClassUtils.getPackageName(ArrayUtilsTest.class);// com.scu.utils
public static List: 获取所有的父类Class
public static List: 获得所有的父接口Class
private static void getAllInterfaces(Class cls, final HashSet:获得所有的父接口，放入到HashSet 中
//[class java.lang.Object]
List<Class<?>> className = ClassUtils.getAllSuperclasses(StudentDaoImpl.class);
//[interface com.scu.dao.StudentDao, interface java.io.Serializable]
List<Class<?>> className2 = ClassUtils.getAllInterfaces(StudentDaoImpl.class);
public static List：根据类名集合获得Class类集合
public static List: 根据Class类集合获得类名集合
List<String> names = new ArrayList<>();
names.add("com.scu.dao.StudentDao");
names.add("com.scu.dao.StudentDaoImpl");
//[interface com.scu.dao.StudentDao, class com.scu.dao.StudentDaoImpl]
List<Class<?>> classList = ClassUtils.convertClassNamesToClasses(names);
public static boolean isPrimitiveOrWrapper(final Class type): 判断rype是否为基本类型或者基本类型的包装类型（文档中说了是8种）
public static boolean isPrimitiveWrapper(final Class type): 判断type是否为基本类的包装类型
public static Class primitiveToWrapper(final Class cls): 基本类型转包装类型
public static Class[] primitivesToWrappers(final Class... classes): 同上，批量转
public static Class wrapperToPrimitive(final Class cls): 包装类型转基本类型
public static Class[] wrappersToPrimitives(final Class... classes): 同上，批量转
boolean a1 = int.class.isPrimitive();// true
boolean a2 = Integer.class.isPrimitive();// false
boolean b1 = ClassUtils.isPrimitiveOrWrapper(int.class);// true
boolean b2 = ClassUtils.isPrimitiveOrWrapper(Integer.class);// true
boolean c1 = ClassUtils.isPrimitiveWrapper(Integer.class);//true
boolean c2 = ClassUtils.isPrimitiveWrapper(String.class);//false
//class java.lang.Integer
Class<?> cls = ClassUtils.primitiveToWrapper(int.class);
//int 注意基本类型的样子
Class<?> cls2 = ClassUtils.wrapperToPrimitive(Integer.class);
public static boolean isInnerClass(final Class cls): 是否为内部类
ClassUtils.isInnerClass(Inner.class);
public static Class[] toClass(final Object... array): 将Object数组转换为Class数组对象
Object[] objs = new Object[3];
objs[0] = Integer.valueOf(3);
objs[1] = "123";
objs[2] = new Student();
// {class java.lang.Integer,class java.lang.String,class com.scu.test.Student}
Class<?>[] classes = ClassUtils.toClass(objs);
public static String getShortCanonicalName(final Class cls): 获取规范类名称
public static String getShortCanonicalName(final String canonicalName): 根据名称获取规范类名
String s = ClassUtils.getShortCanonicalName(UserDao.class);// UserDao
String s2 = ClassUtils.getShortCanonicalName("com.scu.test.UserDao");// UserDao
public static Iterable:获得类的层级，不包括接口
public static Iterable:Interfaces 是个枚举，传入Interfaces.INCLUDE就可以包含接口了
public enum Interfaces {
INCLUDE, EXCLUDE
}
//////////////////////////////////
Iterable<Class<?>> classes = ClassUtils.hierarchy(Integer.class);
for (Class<?> cls : classes) {
System.out.println(cls);
}
// 输出
class java.lang.Integer
class java.lang.Number
class java.lang.Object
4. EnumUtils
方法很少，对于个人来说能用的更少，都不需要解释了
// enumClass的枚举实例转map，key为实例名
public static <E extends Enum<E>> Map<String, E> getEnumMap(final Class<E> enumClass);
//实例都放到list中
public static <E extends Enum<E>> List<E> getEnumList(final Class<E> enumClass);
//判断string代表的枚举名称对应的枚举实例是否正确
public static <E extends Enum<E>> E getEnum(final Class<E> enumClass, final String enumName);
//根据名称获取枚举实例，获取不到返回null
public static <E extends Enum<E>> boolean isValidEnum(final Class<E> enumClass, final String enumName);
测试:
//{SMALL=SMALL, MEDIUM=MEDIUM, LARGE=LARGE}
Map<String, Size> map = EnumUtils.getEnumMap(Size.class);
//[SMALL, MEDIUM, LARGE]
List<Size> list = EnumUtils.getEnumList(Size.class);
Size large = EnumUtils.getEnum(Size.class, "LARGE");
boolean b = EnumUtils.isValidEnum(Size.class, "LONG");// false
5. ObjectUtils
这个就几个方法，介绍能经常用到的
public static :如果object为null则返回默认值，否则返回原值（引用）。
public static : 找到第一个部位null的元素
public static boolean anyNotNull(final Object... values):是否存在部位null的元素，是的话返回true，否则返回false
public static boolean allNotNull(final Object... values): 是否所有元素都不为null
public static boolean notEqual(final Object object1, final Object object2): 判断两个元素是否不相等。注意下面的特殊情况。 这么麻烦还不如不用
* ObjectUtils.notEqual(null, null) = false
* ObjectUtils.notEqual(null, "") = true
* ObjectUtils.notEqual("", null) = true
* ObjectUtils.notEqual("", "") = false
* ObjectUtils.notEqual(Boolean.TRUE, null) = true
* ObjectUtils.notEqual(Boolean.TRUE, "true") = true
* ObjectUtils.notEqual(Boolean.TRUE, Boolean.TRUE) = false
* ObjectUtils.notEqual(Boolean.TRUE, Boolean.FALSE) = true
public static String identityToString(final Object object):Object转String，和Object默认的toString方法类型，返回 类名@哈希码16进制 即使重写了对象的toString方法也没用，还有几个重载的就不谈了。感觉我现在用不上。
//com.scu.utils.BooleanUtilsTest$User@1376c05c 其实是重写了User的toString方法的
ObjectUtils.identityToString(new User(10, "tom"));
public static : 最小值
public static : 最大值
public static : 比较
还有两个用不上的就不说了。
6. RandomUtils
public static boolean nextBoolean():返回一个boolean类型的随机数
public static int nextInt(): 返回一个范围在[0,Integer.MAX_VALUE)之间的随机int类型整数
public static int nextInt(final int startInclusive, final int endExclusive): 返回一个范围在[startInclusive,endExclusive)之间的随机int类型整数
public static long nextLong(): 同上
public static long nextLong(final long startInclusive, final long endExclusive): 同上
public static double nextDouble(): 同上
public static double nextDouble(final double startInclusive, final double endInclusive): 同上
public static float nextFloat(): 同上
public static float nextFloat(final float startInclusive, final float endInclusive): 同上
public static byte[] nextBytes(final int count): 返回一个长度为count的随机byte数组
7. StringUtils
StringUtils用的应该是最多的，方法也很多，有的也很容易弄混淆，尤其是对 " “,”",null
对于实现了CharSequence接口的实现类常见的是String,StringBuilder,StringBuffer，下面就全当作String来看了。 虽然文档中给了很多例子，但是下面还是会自己写一遍加深点印象。
public static boolean isEmpty(final CharSequence cs): 判断是否为空，针对 null和""不包括" ". " "指的是空格，可以是一个或者多个空格。
public static boolean isNotEmpty(final CharSequence cs): 判断是否不为空，即!isEmpty(s).
public static boolean isAnyEmpty(final CharSequence... css): 判断是存在一个String是否为空，也是针对 null和""不包括" ".
public static boolean isNoneEmpty(final CharSequence... css): 判断是否所有的String都不为空，也是针对 null和""不包括" ".
boolean b = StringUtils.isEmpty("");// true
boolean b2 = StringUtils.isEmpty(null);// true
boolean b3 = StringUtils.isEmpty(" ");// false
boolean b = StringUtils.isNotEmpty("");// false
boolean b2 = StringUtils.isNotEmpty(null);// false
boolean b3 = StringUtils.isNotEmpty(" ");// true
注意到上面4个方法都是针对 null和""不包括" "。但是，下面4个判空的方法则是同时针对 null和""以及" ". 同时，这四个方法分别对应上面四个方法。
public static boolean isBlank(final CharSequence cs)
public static boolean isNotBlank(final CharSequence cs)
public static boolean isAnyBlank(final CharSequence... css)
public static boolean isNoneBlank(final CharSequence... css)
举个最常用的例子
boolean b = StringUtils.isNotBlank("");// false
boolean b2 = StringUtils.isNotBlank(null);// false
boolean b3 = StringUtils.isNotBlank(" ");// false
public static String trim(final String str): 去除字符串两端的控制符(char<=32),null使用后还是null
public static String trimToEmpty(final String str): 同上，但是null使用后返回的是"".
public static String trimToNull(final String str): 去除两端的控制符(char<=32)，如果去除后只剩""或者null那么就返回null。
String s = StringUtils.trim(" ");// ""
String s2 = StringUtils.trim(" abc ");// abc
String s3 = StringUtils.trim(null);// null
String s4 = StringUtils.trim(" \b\t\n ");// "" 注意这里
String s5 = StringUtils.trimToNull(" ");// null
String s6 = StringUtils.trimToEmpty(null);// ""
public static String truncate(final String str, int maxWidth): 截取字符串，从第一个字符开始截取，maxWidth截取的长度
public static String truncate(final String str, int offset, int maxWidth): offset表示截取的位置，maxWidth截取的长度.
对于这两个方法：如果null进行截取那么还是null,""进行截取还是"".
String str = "helloworld";
String s1 = StringUtils.truncate(str, 2);// he 第一个位置开始截取，取两个字符
String s2 = StringUtils.truncate(str, 1, 2);// el
public static String strip(final String str):从字符串左右两端去除空格（注意与trim的区别），可以认为trim包含了该功能
public static String stripToEmpty(final String str): 如果字符串为null那么返回空串""
public static String stripToNull(String str): 首先去除两端空格，如果去除后得到""或者null那么就返回null
还有几个重载的，感觉不会用很多就不例举了
* StringUtils.strip(null) = null
* StringUtils.strip("") = ""
* StringUtils.strip(" ") = ""
* StringUtils.strip("abc") = "abc"
* StringUtils.strip(" abc") = "abc"
* StringUtils.strip("abc ") = "abc"
* StringUtils.strip(" abc ") = "abc"
* StringUtils.strip(" ab c ") = "ab c"
public static boolean equals(final CharSequence cs1, final CharSequence cs2): 判断字符串是否相等，注意，任何字符串都不会和null相等
public static boolean equalsIgnoreCase(final CharSequence str1, final CharSequence str2):同上，但是忽略大小写。
public static boolean equalsAny(final CharSequence string, final CharSequence... searchStrings): string是否与searchStrings中任意一个字符串相等
public static boolean equalsAnyIgnoreCase(final CharSequence string, final CharSequence...searchStrings)：同上，忽略大小写
* StringUtils.equals(null, null) = true
* StringUtils.equals(null, "abc") = false
* StringUtils.equals("abc", null) = false
* StringUtils.equals("abc", "abc") = true
* StringUtils.equals("abc", "ABC") = false
* StringUtils.equalsIgnoreCase("abc", "ABC") = true
public static int compare(final String str1, final String str2):字符串比较
public static int compare(final String str1, final String str2, final boolean nullIsLess): 字符串比较，nullIsLess是否考虑(认为)null值小于非null值
public static int compareIgnoreCase(final String str1, final String str2): 忽略大小写的字符串比较
public static int compareIgnoreCase(final String str1, final String str2, final boolean nullIsLess):忽略大小写的字符串比较,nullIsLess是否考虑(认为)null值小于非null值
public static int indexOf(final CharSequence seq, final int searchChar): 查找searchChar在字符串seq中的下标，只找第一个满足条件的下标
public static int indexOf(final CharSequence seq, final int searchChar, final int startPos): 同上，指定从startPos位置开始找
public static int indexOf(final CharSequence seq, final CharSequence searchSeq): 查找字符串searchSeq在字符串seq中的下标
public static int indexOf(final CharSequence seq, final CharSequence searchSeq, final int startPos): 同上，指定从startPos位置开始查找
此外还有两个类似上面的indexOfIgnoreCase方法，会忽略大小写；
还有几个lastIndexOf方法，都是差不多的用法就不都列举了。没找到就返回-1
StringUtils.indexOf("aabaabaa", 'b') = 2
StringUtils.indexOf("aabaabaa", 'b', 3) = 5
StringUtils.indexOf("aabaabaa", 'b', 9) = -1
StringUtils.indexOf("aabaabaa", "b") = 2
StringUtils.indexOf("aabaabaa", "ab") = 1
StringUtils.indexOf("aabaabaa", "") = 0
StringUtils.indexOf("aabaabaa", "ab", 0) = 1
关于contains方法其实也没啥要说的
public static boolean contains(final CharSequence seq, final int searchChar): 字符串中是包含字符
public static boolean containsIgnoreCase(final CharSequence str, final CharSequence searchStr): 同上，忽略大小写
public static boolean containsWhitespace(final CharSequence seq): 是否包含空格
public static boolean containsAny(final CharSequence cs, final char... searchChars): 是否包含其中一个字符
public static boolean containsAny(final CharSequence cs, final CharSequence searchChars): 是否包含字符串searchChars中的一个字符
public static boolean containsAny(CharSequence cs, CharSequence... searchCharSequences: 是否包含字符串数组中，其中一个字符串中的一个字符
public static boolean containsNone(final CharSequence cs, final char... searchChars): 是否字符数组中的所有字符在字符串cs中都不含有
public static boolean containsNone(final CharSequence cs, final String invalidChars): 同上类似
char[] cs = {'a','d','c'};
boolean b = StringUtils.containsAny("1aa", cs);// true
StringUtils.containsAny("1aa", "ac")// true
StringUtils.containsNone("ab1", 'xyz') = true
StringUtils.containsNone("abz", 'xyz') = false
substring也有对应的很多substringXX方法，这里只说几个常见的
public static String substring(final String str, int start): start位置开始截取字符串，可以为负数（倒着数），也可以大于字符串长度(到了末尾空串)
public static String substring(final String str, int start, int end): 指定位置范围内截取字符串
public static String substringBefore(final String str, final String separator): 从左边开始截取，截取到第一个遇到的字符串separator为止，不包含separator，如果字符串中没有该字符，那么全部截取
public static String substringAfter(final String str, final String separator): 从separator(不包含)开始截取到最后
public static String substringBetween(final String str, final String open, final String close): 将第一个open,close（不包含这两个串）之间的字符串全部截取
StringUtils.substring("abc", 0) = "abc"
* StringUtils.substring("abc", 2) = "c"
* StringUtils.substring("abc", 4) = ""
* StringUtils.substring("abc", -2) = "bc"
* StringUtils.substring("abc", -4) = "abc"
* StringUtils.substring("abc", 2, 4) = "c"
* StringUtils.substring("abc", 4, 6) = ""
* StringUtils.substring("abc", 2, 2) = ""
* StringUtils.substring("abc", -2, -1) = "b"
* StringUtils.substring("abc", -4, 2) = "ab"
* StringUtils.substringBefore("abcba", "b") = "a"
* StringUtils.substringBefore("abc", "c") = "ab"
* StringUtils.substringBefore("abc", "d") = "abc"
* StringUtils.substringBefore("abc", "") = ""
* StringUtils.substringBefore("abc", null) = "abc"
* StringUtils.substringAfter("abc", "a") = "bc"
* StringUtils.substringAfter("abcba", "b") = "cba"
* StringUtils.substringAfter("abc", "c") = ""
* StringUtils.substringAfter("abc", "d") = ""
* StringUtils.substringAfter("abc", "") = "abc"
public static String left(final String str, final int len): 从左边开始截取字符串，len为截取长度，len>str.length()表示到了str最右边的空串
public static String right(final String str, final int len): 从右边开始截取字符串，len为截取长度，len>str.length()表示到了str最左边的空串
* StringUtils.left("abc", 0) = ""
* StringUtils.left("abc", 2) = "ab"
* StringUtils.left("abc", 4) = "abc"
* StringUtils.right("abc", 0) = ""
* StringUtils.right("abc", 2) = "bc"
* StringUtils.right("abc", 4) = "abc"
split也有很多splitXXX方法，但是暂时使用到的还是下面这个
public static String[] split(final String str, final char separatorChar)
* StringUtils.split("a..b.c", '.') = ["a", "b", "c"]
* StringUtils.split("a:b:c", '.') = ["a:b:c"]
* StringUtils.split("a b c", ' ') = ["a", "b", "c"]
public static : 泛型类型拼接，返回拼接后是字符串，不要传[1,2,3]基本类型数组，否则得到的肯定不是你想要的，因为基本类型并没有泛型类型这一说
public static String join(final Object[] array, final char separator): 对象类型的拼接，separator为拼接的符号，此外参数还可以为int[],double[]...等基本类型数组
public static String join(final Iterator iterator, final char separator): 迭代器中元素进行拼接,第二个参数也可以为 String,有重载方法
public static String join(final Iterable iterable, final char separator): Iterable也行,第二个参数也可以为 String,有重载方法
需要之间拼接，传入null即可
* StringUtils.join(null) = null
* StringUtils.join([]) = ""
* StringUtils.join([null]) = ""
* StringUtils.join(["a", "b", "c"]) = "abc"
* StringUtils.join([null, "", "a"]) = "a"
* StringUtils.join([1, 2, 3], ';') = "1;2;3"
* StringUtils.join([1, 2, 3], null) = "123"
Integer[] nums = {1,2,3};
List<Integer> list = Arrays.asList(nums);
String s = StringUtils.join(list,":");// 1:2:3
Iterator<Integer> iterator = list.iterator();
String s2 = StringUtils.join(iterator,":");// 1:2:3
public static String deleteWhitespace(final String str): 删除空格
* StringUtils.deleteWhitespace(null) = null
* StringUtils.deleteWhitespace("") = ""
* StringUtils.deleteWhitespace("abc") = "abc"
* StringUtils.deleteWhitespace(" ab c ") = "abc"
public static String removeStart(final String str, final String remove): 移除str中以remove开头的字符串
public static String removeStartIgnoreCase(final String str, final String remove): 同上，忽略大小写
public static String removeEnd(final String str, final String remove)
public static String removeEndIgnoreCase(final String str, final String remove)这两个就不解释了
public static String remove(final String str, final String remove): 移除子串
public static String removeIgnoreCase(String str, String remove): 同上，忽略大小写
public static String remove(final String str, final char remove): 移除字符
public static String removeAll(final String text, final String regex): 移除所有满足正则表达式的子串
* StringUtils.removeStart("www.domain.com", "www.") = "domain.com"
* StringUtils.removeStart("domain.com", "www.") = "domain.com"
* StringUtils.removeStart("www.domain.com", "domain") = "www.domain.com"
* StringUtils.removeStart("abc", "") = "abc"
* StringUtils.remove("queued", "ue") = "qd"
* StringUtils.remove("queued", "zz") = "queued"
* StringUtils.remove("queued", 'u') = "qeed"
* StringUtils.remove("queued", 'z') = "queued"
* StringUtils.removeAll("abc", ".?") = ""
* StringUtils.removeAll("A<__>\n<__>B", "<.*>") = "A\nB"
* StringUtils.removeAll("A<__>\n<__>B", "(?s)<.*>") = "AB"
* StringUtils.removeAll("ABCabc123abc", "[a-z]") = "ABC123"
public static String replaceOnce(final String text, final String searchString, final String replacement): 字符串替换，只替换第一个找到的。
public static String replaceOnceIgnoreCase(String text, String searchString, String replacement): 同上，忽略大小写
public static String replace(final String text, final String searchString, final String replacement): 替换所有
public static String replaceIgnoreCase(String text, String searchString, String replacement): 替换所有，忽略大小写
public static String replacePattern(final String source, final String regex, final String replacement): 满足正则表达式的字符串给替换掉
public static String replaceAll(final String text, final String regex, final String replacement): 同上，但是会全部替换掉
public static String replaceChars(final String str, final char searchChar, final char replaceChar): 替换所有字符
public static String replaceChars(final String str, final String searchChars, String replaceChars): 将searchChars在str中的所有字符替换掉
* StringUtils.replaceOnce("aba", "a", null) = "aba"
* StringUtils.replaceOnce("aba", "a", "") = "ba"
* StringUtils.replaceOnce("aba", "a", "z") = "zba"
public static String repeat(final String str, final int repeat): 将str串重复repeat次连接起来，可以是负数
public static String repeat(final char ch, final int repeat):字符重复
* StringUtils.repeat("a", 3) = "aaa"
* StringUtils.repeat("ab", 2) = "abab"
* StringUtils.repeat("a", -2) = ""
public static int length(final CharSequence cs): 计算字符串长度，如果为null那么长度算作0
public static String upperCase(final String str): 转大写，如果是null就返回null
public static String lowerCase(final String str): 转小写，如果是null就返回null
public static String center(final String str, final int size): 获取新的字符串长度为size，让str位于中间，不足的补空格
public static String center(String str, final int size, final char padChar):同上，但是上面使用空格填充，这里使用padChar填充
* StringUtils.center("ab", 4) = " ab "
* StringUtils.center("abcd", 2) = "abcd"
* StringUtils.center("a", 4) = " a "
* StringUtils.center("a", 4, ' ') = " a "
* StringUtils.center("a", 4, 'y') = "yayy"
public static String capitalize(final String str): 使首字母大写
public static String uncapitalize(final String str): 使首字母小写
public static String swapCase(final String str):字串串中的小写字母转小写，小写转大写
* StringUtils.capitalize("cat") = "Cat"
* StringUtils.capitalize("cAt") = "CAt"
* StringUtils.capitalize("'cat'") = "'cat'"
* StringUtils.uncapitalize("Cat") = "cat"
* StringUtils.uncapitalize("CAT") = "cAT"
* StringUtils.swapCase("The dog has a BONE") = "tHE DOG HAS A bone"
public static int countMatches(final CharSequence str, final CharSequence sub): 字符串str中有多少个子串sub
public static int countMatches(final CharSequence str, final char ch): 字符串str中有多少个子字符ch
* StringUtils.countMatches("abba", "a") = 2
* StringUtils.countMatches("abba", "ab") = 1
* StringUtils.countMatches("abba", "xxx") = 0
* StringUtils.countMatches("abba", 'a') = 2
* StringUtils.countMatches("abba", 'b') = 2
* StringUtils.countMatches("abba", 'x') = 0
public static boolean isAlpha(final CharSequence cs): 判断字符串是否由Unicode字母组成
public static boolean isAlphaSpace(final CharSequence cs): 判断字符串是否由Unicode字母和空格组成
public static boolean isAlphanumeric(final CharSequence cs): 判断字符串是否由Unicode字母和数字组成
public static boolean isAlphanumericSpace(final CharSequence cs): 判断字符串是否由Unicode字母和数字以及空格组成
* StringUtils.isAlpha(" ") = false
* StringUtils.isAlpha("abc") = true
* StringUtils.isAlpha("ab2c") = false
* StringUtils.isAlpha("ab-c") = false
* StringUtils.isAlphaSpace("ab c") = true
* StringUtils.isAlphaSpace("ab2c") = false
* StringUtils.isAlphaSpace("ab-c") = false
* StringUtils.isAlphanumeric("ab c") = false
* StringUtils.isAlphanumeric("ab2c") = true
* StringUtils.isAlphanumeric("ab-c") = false
* StringUtils.isAlphanumericSpace("ab c") = true
* StringUtils.isAlphanumericSpace("ab2c") = true
* StringUtils.isAlphanumericSpace("ab-c") = false
public static boolean isNumeric(final CharSequence cs):判断字符串是否都由数字(Unicode digits)组成,.不算数字
public static boolean isNumericSpace(final CharSequence cs)
public static boolean isWhitespace(final CharSequence cs):判断字符串是否只由空格组成
public static boolean isAllLowerCase(final CharSequence cs):判断字串串是否只包含小写字母
public static boolean isAllUpperCase(final CharSequence cs):判断字串串是否只包含大写字母
* StringUtils.isNumeric("12 3") = false
* StringUtils.isNumeric("12.3") = false
* StringUtils.isNumeric("-123") = false
* StringUtils.isNumeric("+123") = false
* StringUtils.isNumeric("\u0967\u0968\u0969") = true
* StringUtils.isNumericSpace("12 3") = true
* StringUtils.isWhitespace(null) = false
* StringUtils.isWhitespace("") = true
* StringUtils.isWhitespace(" ") = true
* StringUtils.isWhitespace("abc") = false
* StringUtils.isAllLowerCase("abc") = true
* StringUtils.isAllLowerCase("abC") = false
* StringUtils.isAllLowerCase("ab c") = false
* StringUtils.isAllLowerCase("ab1c") = false
* StringUtils.isAllUpperCase("ABC") = true
* StringUtils.isAllUpperCase("aBC") = false
* StringUtils.isAllUpperCase("A C") = false
public static String defaultString(final String str): 如果字符串为null那么返回""，否则返回原字符串
public static String defaultString(final String str, final String defaultStr): 如果字符串为null那么返回defaultStr，否则返回原字符串
public static : 如果字符串为""," ",null那么返回defaultStr,否则返回原字符串
public static :如果字符串为"",null那么返回defaultStr,否则返回原字符串
public static String rotate(String str, int shift): 将字符串往右旋转shift位
public static String reverse(final String str): 翻转字符串
* StringUtils.rotate("abcdefg", 2) = "fgabcde"
* StringUtils.rotate("abcdefg", -2) = "cdefgab"
* StringUtils.reverse(null) = null
* StringUtils.reverse("") = ""
* StringUtils.reverse("bat") = "tab"
different感觉解释不清楚，觉得自己也不会用到，略过。
public static String getCommonPrefix(final String... strs): 获取字符串数组中相同的前缀
* StringUtils.getCommonPrefix(new String[] {"abc", "a"}) = "a"
* StringUtils.getCommonPrefix(new String[] {"ab", "abxyz"}) = "ab"
* StringUtils.getCommonPrefix(new String[] {"abcde", "abxyz"}) = "ab"
* StringUtils.getCommonPrefix(new String[] {"abcde", "xyz"}) = ""
* StringUtils.getCommonPrefix(new String[] {"xyz", "abcde"}) = ""
* StringUtils.getCommonPrefix(new String[] {"i am a machine", "i am a robot"}) = "i am a "
public static boolean startsWith(final CharSequence str, final CharSequence prefix): 判断prefix是否为str的前缀
public static boolean startsWithIgnoreCase(final CharSequence str, final CharSequence prefix): 同上，忽略大小写
public static boolean startsWithAny(final CharSequence sequence, final CharSequence... searchStrings): 是否其中一个字符串为str的前缀
public static boolean endsWith(final CharSequence str, final CharSequence suffix)
public static boolean endsWithIgnoreCase(final CharSequence str, final CharSequence suffix)
public static boolean endsWithAny(final CharSequence sequence, final CharSequence... searchStrings)这三个就同startsWith
* StringUtils.startsWith("abcdef", "abc") = true
* StringUtils.startsWith("ABCDEF", "abc") = false
* StringUtils.startsWithIgnoreCase("abcdef", "abc") = true
* StringUtils.startsWithIgnoreCase("ABCDEF", "abc") = true
* StringUtils.startsWithAny("abcxyz", null, "xyz", "ABCX") = false
* StringUtils.startsWithAny("ABCXYZ", null, "xyz", "abc") = false
public static String toEncodedString(final byte[] bytes, final Charset charset): new String(bytes,charset)
public static String wrap(final String str, final char wrapWith): 使用字符wrapWith对字符串进行包裹
public static String wrap(final String str, final String wrapWith):使用字符串wrapWith对字符串进行包裹
* StringUtils.wrap("ab", '\0') = "ab"
* StringUtils.wrap("ab", 'x') = "xabx"
* StringUtils.wrap("ab", '\'') = "'ab'"