StringUtils，NumberUtils

21.public static int ordinalIndexOf(String str, String searchStr, int ordinal)
返回字符串searchStr在字符串str中第ordinal次出现的位置。
如果str=null或searchStr=null或ordinal<=0则返回-1
举例(*代表任意字符串)：
StringUtils.ordinalIndexOf(null, *, *) = -1
StringUtils.ordinalIndexOf(*, null, *) = -1
StringUtils.ordinalIndexOf("", "", *) = 0
StringUtils.ordinalIndexOf("aabaabaa", "a", 1) = 0
StringUtils.ordinalIndexOf("aabaabaa", "a", 2) = 1
StringUtils.ordinalIndexOf("aabaabaa", "b", 1) = 2
StringUtils.ordinalIndexOf("aabaabaa", "b", 2) = 5
StringUtils.ordinalIndexOf("aabaabaa", "ab", 1) = 1
StringUtils.ordinalIndexOf("aabaabaa", "ab", 2) = 4
StringUtils.ordinalIndexOf("aabaabaa", "bc", 1) = -1
StringUtils.ordinalIndexOf("aabaabaa", "", 1) = 0
StringUtils.ordinalIndexOf("aabaabaa", "", 2) = 0
22. public static int indexOf(String str, String searchStr, int startPos)
返回字符串searchStr从startPos开始在字符串str中第一次出现的位置。
举例(*代表任意字符串)：
StringUtils.indexOf(null, *, *) = -1
StringUtils.indexOf(*, null, *) = -1
StringUtils.indexOf("", "", 0) = 0
StringUtils.indexOf("aabaabaa", "a", 0) = 0
StringUtils.indexOf("aabaabaa", "b", 0) = 2
StringUtils.indexOf("aabaabaa", "ab", 0) = 1
StringUtils.indexOf("aabaabaa", "b", 3) = 5
StringUtils.indexOf("aabaabaa", "b", 9) = -1
StringUtils.indexOf("aabaabaa", "b", -1) = 2
StringUtils.indexOf("aabaabaa", "", 2) = 2
StringUtils.indexOf("abc", "", 9) = 3
23.public static int lastIndexOf(String str, char searchChar)
基本原理同18。
24.public static int lastIndexOf(String str, char searchChar, int startPos)
基本原理同19。
25.public static int lastIndexOf(String str, String searchStr)
基本原理同20。
26.public static int lastIndexOf(String str, String searchStr, int startPos)

基本原理同22。

/*1.字符串以prefix开始*/StringUtils.startsWith("sssdf","");//结果是：trueStringUtils.startsWith("sssdf","");//结果是：trueStringUtils.startsWith("sssdf","s");//结果是：trueStringUtils.startsWith("sssdf","ss");//结果是：trueStringUtils.startsWith("sssdf","sss");//结果是：trueStringUtils.startsWith("sssdf","sssdf");//结果是：trueStringUtils.startsWith("sssdf","f");//结果是：falseStringUtils.startsWith("sssdf","sssdf");//结果是：true/*2.字符串以prefix开始,不区分大小写*/StringUtils.startsWithIgnoreCase("sssdf","Sssdf");//结果是：true/*3.字符串以数组中的字符串开始*/StringUtils.startsWithAny("aabcde",newString[]{"g","f"});//结果是：falseStringUtils.startsWithAny("aabcde",newString[]{"g","a"});//结果是：true/*4.字符串以suffix结束*/StringUtils.endsWith("aabcde","d");//结果是：falseStringUtils.endsWith("aabcde","e");//结果是：falseStringUtils.endsWithIgnoreCase("","");//结果是：false/*5.替换字符串:把text中的searchString替换成replacement，max是最大替换次数，默认是替换所有*/StringUtils.replaceOnce("sshhhss","ss","p");//只替换一次-->结果是：phhhssStringUtils.replace("sshhhs","ss","p");//全部替换--->结果是：phhhsStringUtils.replace("sshhhsshss","ss","7777",2);//max：最大替换次数-->结果是：7777hhh7777hssStringUtils.replaceChars("sshhhs","ss","p");//替换所有字符，区别于replace--->结果是：pphhhp而不是pphhhs/*6.按照数组进行替换，位置要匹配，数组长度要相等;暂时没发现下面replaceEach和replaceEachRepeatedly二者的区别*/StringUtils.replaceEach("www.baidu.com",newString[]{"baidu","com"},newString[]{"taobao","net"});//结果是：www.taobao.netStringUtils.replaceEach("www.baidu,baidu.com",newString[]{"baidu","com"},newString[]{"taobao","net"});//结果是：www.taobao,taobao.netStringUtils.replaceEachRepeatedly("www.baidu.com",newString[]{"baidu","com"},newString[]{"taobao","net"});//结果是：www.taobao.net/*7.比较两个字符串是否相等,如果两个均为null，则也认为相等*/StringUtils.equals("","");//结果是trueStringUtils.equals(null,null);//结果是trueStringUtils.equals("",null);//结果是falseStringUtils.equals(null,"");//结果是falseStringUtils.equalsIgnoreCase("ss","Ss");//不区分大小写--结果是true/*8.返回searchChar在字符串中第一次出现的位置,如果searchChar没有在字符串中出现，则返回-1*/StringUtils.indexOf("sdfsfsfdsf","4");/*结果是-1*/StringUtils.indexOf("sdfsfsfdsf","f");/*结果是2*///查找searchChar在字符串中最后一次出现的索引*/StringUtils.lastIndexOf("aFkyk","k");//结果是4StringUtils.lastIndexOf("aFkyk","");//结果是1/*9.找出字符数组searChars第一次出现在字符串中的位置*/StringUtils.indexOfAny("sdsfhhl0","f");//结果是3StringUtils.indexOfAny("sdsfhhl0",newString[]{"f","0"});//结果是3StringUtils.indexOfAny("sdsfhhl0",newString[]{"t","j"});//结果是-1StringUtils.indexOfAny("sdsfhhl0",newString[]{"t","j",""});//结果是3StringUtils.lastIndexOfAny("aFkyk",newString[]{"aFkyk","k"});//找出字符数组searChars最后一次出现在字符串中的位置--结果是5/*10.找出字符串中不在字符数组searchars中的第一个字符出现的位置(从0位开始)*如果都在，返回-1**/StringUtils.indexOfAnyBut("sdsfhhl0","h");//结果是0StringUtils.indexOfAnyBut("sdsfhhl0","s");//结果是1StringUtils.indexOfAnyBut("aa","aa");//结果是-1/*11.统计参数1和参数2开始部分共有的字符个数*/StringUtils.indexOfDifference("sdsfdsf","s");//结果是1StringUtils.indexOfDifference(newString[]{"sdsfdsf","s"});//结果是1/*12.去掉参数2在参数1开始部分共有的字符串*/StringUtils.difference("灌灌灌灌","灌灌灌灌啊啊");//结果是：啊啊/*13.查找，不区分大小写,没有找到返回-1*/StringUtils.indexOfIgnoreCase("aFabbSSdd","f");//返回1StringUtils.indexOfIgnoreCase("aFabbSSdd","f",2);//从指定位置开始查找，不区分大小写--返回-1StringUtils.indexOfIgnoreCase("aFabbSSdd","f",1);//返回1StringUtils.lastIndexOfIgnoreCase("","");StringUtils.lastIndexOfIgnoreCase("","",2);/*14.截取指定位置的字符串*/StringUtils.substring("dskabcee",3);/*结果是：abcee*/StringUtils.substring("dskabcee",3,5);/*结果是：ab*//*15.截取指定字符串之前的内容*/StringUtils.substringBefore("dskeabcee","e");/*结果是：dskeabce*/StringUtils.substringBeforeLast("dskeabcee","e");//一直找到最后一个指定的字符串/*结果是：dskeabce*/StringUtils.substringAfter("dskeabcedeh","");/*结果是：dskeabcedeh*/StringUtils.substringAfterLast("dskeabcedeh","");/*结果是：*//*16.截取参数2和参数3中间的字符*/StringUtils.substringBetween("dskeabcedeh","ds");/*结果是：null*/StringUtils.substringBetween("dskeabcedeh","ds","e");/*结果是：k*/StringUtils.substringsBetween("dskeabcedeh","ds","e");//以数组方式返回参数2和参数3中间的字符串/*结果是：[keabce]*//*1.分割字符串,可以设定得到数组的长度，但一般情况下不要设定，这样会发生冲突*/StringUtils.split("y5y,4454,545");//默认是按，来分割StringUtils.split("aaaa#sss","#");/*结果是：[aaaa,sss]*/StringUtils.split("aaaa#sss#","#",2);/*2.按不同类型进行分割字符串*/StringUtils.splitByCharacterType("aa3444张三Bcss");/*结果是：[aa,3444,张三,a,B,css,B]*/StringUtils.splitByCharacterTypeCamelCase("");/*结果是：[aa,3444,张三,a,Bcss,B]*//*3.分割字符串，""不会被忽略,可以设置分割字符串的数组长度*/StringUtils.splitByWholeSeparator("aaaa#sss#","#");//""不会被忽略/*结果是：[aaaa,sss,]StringUtils.split结果是：[aaaa,sss]*/StringUtils.splitByWholeSeparator("aaaa#sss#ggg","#");///*结果是：[aaaa,sss,ggg]*/StringUtils.splitByWholeSeparator("aaaa#sss#ggg","");//按空格分割/*结果是：[aaaa#,sss#ggg]*/StringUtils.splitByWholeSeparator("aaaa#sss#","#",2);//2设定返回数组的最大长度/*结果是：[aaaa,sss#]*//*4.分割字符串，""不会被忽略,可以设置分割字符串的数组长度*/StringUtils.splitByWholeSeparatorPreserveAllTokens("sddssfsfasfsaf",null);/*结果是：[sddssf,sfasfsaf,]*/StringUtils.splitByWholeSeparatorPreserveAllTokens("sddssfsfasfsaf","");/*结果是：[sddssf,sfasfsaf,]*//*5.同上*/StringUtils.splitPreserveAllTokens("");StringUtils.splitPreserveAllTokens("","");StringUtils.splitPreserveAllTokens("","",3);

一、NumberUtils工具类
/*1.NumberUtils.isNumber():判断字符串是否是数字*/
NumberUtils.isNumber("5.96");//结果是true
NumberUtils.isNumber("s5");//结果是false
NumberUtils.isNumber("0000000000596");//结果是true


/*2.NumberUtils.isDigits():判断字符串中是否全为数字*/
NumberUtils.isDigits("0000000000.596");//false
NumberUtils.isDigits("0000000000596");//true


/*3.NumberUtils.toInt():字符串转换为整数*/
NumberUtils.toInt("5");
NumberUtils.toLong("5");
NumberUtils.toByte("3");
NumberUtils.toFloat("3.2");
NumberUtils.toDouble("4");
NumberUtils.toShort("3");


/*4.NumberUtils.max():找出最大的一个*/
NumberUtils.max(newint[]{3,5,6});//结果是6
NumberUtils.max(3,1,7);//结果是7


/*5.NumberUtils.min():找出最小的一个*/
NumberUtils.min(newint[]{3,5,6});//结果是6
NumberUtils.min(3,1,7);//结果是7


/*6.NumberUtils.createBigDecimal()通过字符串创建BigDecimal类型，支持long、int、float、double、number等数值*/
NumberUtils.createBigDecimal("1");
NumberUtils.createLong("1");
NumberUtils.createInteger("1");


二、ArrayUtils工具类
/*1.ArrayUtils.isEmpty(strs):判断数组是否为空, 不为空返回false, 为空true*/
ArrayUtils.isEmpty(new String[]{"21","是"});//结果是false
ArrayUtils.isEmpty(new String[]{""});//结果是false
ArrayUtils.isEmpty(new String[]{null});//结果是false
ArrayUtils.isEmpty(new String[]{});//结果是true


/*2.ArrayUtils.isNotEmpty(strs):判断数组是否不为空,不为空返回true,为空false*/
ArrayUtils.isNotEmpty(new String[]{"21","是"});//结果是true
ArrayUtils.isNotEmpty(new String[]{""});//结果是true
ArrayUtils.isNotEmpty(new String[]{});//结果是false


/*3.ArrayUtils.isSameLength(strs,strs2):判断两个数组长度是否相等,长度相等返回true,否则返回false。相比较的两个数组类型必须相同*/
ArrayUtils.isSameLength(new String[]{"21","是"},new String[]{"21","是"});//返回false


/*4.ArrayUtils.isSameType(strs,strs2):判断两个数组的类型是否相同,相同返回true,否则返回false*/
ArrayUtils.isSameType(new String[]{"21","是"},newInteger[]{3});


/*5.ArrayUtils.isEquals(strs,strs2)判断两个数组是否相等*/
ArrayUtils.isEquals(strs,strs);//结果是true


/*6.ArrayUtils.toString()将一个数组转换成String,用于打印*/
ArrayUtils.toString(new String[]{"21","是"});//结果是：{21,是}


/*7.ArrayUtils.clone赋值（克隆）数组*/
Object[]s=ArrayUtils.clone(newObject[]{"33","yy"});


/*8.ArrayUtils.subarray截取子数组：根据起始索引startIndexInclusive到结束索引startIndexInclusive*/
Object[]s1=ArrayUtils.subarray(newObject[]{"33","yy","uu"},0,1);//结果是返回数组：[33]
Object[]s2=ArrayUtils.subarray(newObject[]{"33","yy","uu"},0,2);//结果是返回数组：[33,yy]


/*9.ArrayUtils.indexOf查询某个object在数组中的位置，可是指定起始搜索位置*/
intindex=ArrayUtils.indexOf(newObject[]{"33","yy","uu"},"uu");//结果是2
intindex1=ArrayUtils.indexOf(newObject[]{"33","yy","uu"},"uu",2);//结果是2
intindex3=ArrayUtils.indexOf(newObject[]{"33","yy","uu"},"uu",3);//结果是-1


/*10.ArrayUtils.lastIndexOf反向查询某个object在数组中的位置，可以指定起始搜索位置*/
intindex11=ArrayUtils.lastIndexOf(newObject[]{"33","yy","uu"},"33");//结果是0
intindex22=ArrayUtils.lastIndexOf(newObject[]{"33","yy","uu"},"33",2);


/*11.ArrayUtils.contains查询某个object是否在数组中*/
ArrayUtils.contains(new String[]{"1", "2", "3"}, "11");


/*12.ArrayUtils.reverse反转数组*/
ArrayUtils.reverse(new String[]{"22","yy"});//结果是：{"yy"，"22"}


/*13.ArrayUtils.add添加一object到数组*/
String[] t={"22","yy"};
String[] gg=(String[])ArrayUtils.add(t,"jj");//{"22","yy","jj"}


/*14.ArrayUtils.addAll合并两个数组*/
String[]ggo=(String[])ArrayUtils.addAll(new String[]{"22","yy"},new String[]{"jj"});//结果是：[22,yy,jj]
ArrayUtils.addAll(new String[]{"22","yy"},new String[]{"jj", "jj"}); //结果是：[22,yy,jj,jj]


/*15.ArrayUtils.remove删除数组某个位置的元素*/
String[]gg4=(String[])ArrayUtils.remove(new String[]{"22","yy"},1);


/*16.ArrayUtils.removeElement删除数组中某个对象*/
String[]ggpp=(String[])ArrayUtils.removeElement(new String[]{"22","yy"},"yy");


三、RandomUtils工具类
RandomUtils帮助我们产生随机数，不止是数字类型，连boolean类型都可以通过RandomUtils产生，RandomStringUtils生成字符随机数。
RandomUtils.nextBoolean();  
RandomUtils.nextDouble();  
RandomUtils.nextLong();  
// 注意这里传入的参数不是随机种子,而是在0~1000之间产生一位随机数  
RandomUtils.nextInt(1000);