StringUtils工具类常用方法汇总(判空、转换、移除、替换、反转)

 

 

Apache commons lang3包下的StringUtils工具类中封装了一些字符串操作的方法，非常实用，使用起来也非常方便。最近自己也经常在项目中使用到了里面的一些方法，在这里将常用的方法总结了一下，方便以后查阅，大家有兴趣也可以看一下。

  首先需要说明的一点是，StringUtils类在操作字符串时，即使操作的为null值也是安全的，不会报NullPointerException，这一点在后面的例子中再具体说明。因此，在操作字符串时使用StringUtils相比使用原生的String会更加安全。

一、判空（这应该是最常用的）

  StringUtils中判断字符串是否为空的方法主要有以下几个：

1. 1）boolean StringUtils.isBlank(String str)

2. 2）boolean StringUtils.isEmpty(String str)

3. 3）boolean StringUtils.isNotBlank(String str)

4. 4）boolean StringUtils.isNotEmpty(String str)

5. 5）boolean StringUtils.isAnyBlank(CharSequence… css)

6. 6）boolean StringUtils.isAnyEmpty(CharSequence… css)

7. 7）boolean StringUtils.isNoneBlank(CharSequence… css)

8. 8）boolean StringUtils.isNoneEmpty(CharSequence… css)

9. 9）boolean StringUtils.isWhitespace(CharSequence cs)

  很显然上面的方法很多都是是非的关系，isBlank与isNotBlank，isEmpty与isNotEmpty，isAnyBlank与isNoneBlank，isAnyEmpty与isNoneEmpty都是如此。

  但是blank与empty以及whitesapce它们之间有何区别呢？看下面的对比就很清楚了：

1. StringUtils.isBlank(""); // true

2. StringUtils.isBlank(" "); // true

3. StringUtils.isBlank(" "); // true

4. StringUtils.isBlank("\t"); // true

5. StringUtils.isBlank("\r"); // true

6. StringUtils.isBlank("\n"); // true

7. StringUtils.isBlank(null); // true

8.  

9. StringUtils.isEmpty(""); // true

10. StringUtils.isEmpty(" "); // false

11. StringUtils.isEmpty(" "); // false

12. StringUtils.isEmpty("\t"); // false

13. StringUtils.isEmpty("\r"); // false

14. StringUtils.isEmpty("\n"); // false

15. StringUtils.isEmpty(null); // true

16.  

17. StringUtils.isWhitespace(""); // true

18. StringUtils.isWhitespace(" "); // true

19. StringUtils.isWhitespace(" "); // true

20. StringUtils.isWhitespace("\t"); // true

21. StringUtils.isWhitespace("\r"); // true

22. StringUtils.isWhitespace("\n"); // true

23. StringUtils.isWhitespace(null); // false

  从上面的结果可以看出，
    blank：代表的是空串("")、空白符(空格""，" "，制表符"\t"，回车符"\r"，"\n"等)以及null值；
    empty：代表的是空串("")和null值，不包含空白符；
    whitespace：包含空串("")和空白符，不包含null值.

  isBlank，isNotBlank，isEmpty，isNotEmpty四个方法都是用于判断单个字符串是否为空，这个可以参见上面的几个例子。

  isAnyBlank，isNoneBlank，isAnyEmpty，isNoneEmpty四个方法是用于判断多个字符串是否为空；
  对于isAnyBlank和isAnyEmpty来说，只要有一个字符串为空，结果即为true；
对于isNoneBlank和isNoneEmpty，只要存在一个字符串为空，结果即为false，具体参见下面的例子：

1. StringUtils.isAnyBlank("titanic", "jack", "rose")); // false

2. StringUtils.isAnyBlank("", "jack", "rose")); // true

3. StringUtils.isAnyBlank(" ", "jack", "rose")); // true

4. StringUtils.isAnyBlank(null, "jack", "rose")); // true

5.  

6. StringUtils.isAnyEmpty("titanic", "jack", "rose")); // false

7. StringUtils.isAnyEmpty("", "jack", "rose")); // true

8. StringUtils.isAnyEmpty(" ", "jack", "rose")); // false

9. StringUtils.isAnyEmpty(null, "jack", "rose")); // true

10.  

11. StringUtils.isNoneBlank("titanic", "jack", "rose")); // true

12. StringUtils.isNoneBlank("", "jack", "rose")); // false

13. StringUtils.isNoneBlank(" ", "jack", "rose")); // false

14. StringUtils.isNoneBlank(null, "jack", "rose")); // false

15.  

16. StringUtils.isNoneEmpty("titanic", "jack", "rose")); // true

17. StringUtils.isNoneEmpty("", "jack", "rose")); // false

18. StringUtils.isNoneEmpty(" ", "jack", "rose")); // true

19. StringUtils.isNoneEmpty(null, "jack", "rose")); // false

二、转换

  StringUtils中涉及大小写转换以及判断字符串大小写的方法如下：

1. 1）StringUtils.capitalize(String str)

2. 2）StringUtils.uncapitalize(String str)

3. 3）StringUtils.upperCase(String str)

4. 4）StringUtils.upperCase(String str,Locale locale)

5. 5）StringUtils.lowerCase(String str)

6. 6）StringUtils.lowerCase(String str,Locale locale)

7. 7）StringUtils.swapCase(String str)

8. 8）StringUtils.isAllUpperCase(CharSequence cs)

9. 9）StringUtils.isAllLowerCase(CharSequence cs)

  （1）字符串首字母大小写转换

1. StringUtils.capitalize(null)); // null (注意此处不会报异常)

2. StringUtils.capitalize("china")); // China (首字母转大写)

3. StringUtils.uncapitalize(null)); // null

4. StringUtils.uncapitalize("CHINA")); // cHINA (首字母转小写)

  （2）字符串整体大小写转换

1. StringUtils.upperCase(null)); // null

2. StringUtils.upperCase("china")); // CHINA (全部转为大写)

3. StringUtils.upperCase("china", Locale.ENGLISH)); // CHINA (按照指定规则转换为大写)

4. StringUtils.lowerCase(null)); // null

5. StringUtils.lowerCase("CHINA")); // china (全部转换为小写)

6. StringUtils.lowerCase("CHINA", Locale.ENGLISH)); // china (按照指定转换规则转换为小写)

  （3）字符串大小写互换

1. StringUtils.swapCase(null)); // null

2. StringUtils.swapCase("chINA")); // CHina

  （4）判断字符串是否全部是大写或小写(空或空白符均为false)

1. StringUtils.isAllUpperCase(null)); // false

2. StringUtils.isAllUpperCase("")); // false

3. StringUtils.isAllUpperCase(" ")); // false

4. StringUtils.isAllUpperCase("CHINA")); // true

5. StringUtils.isAllLowerCase(null)); // false

6. StringUtils.isAllLowerCase("")); // false

7. StringUtils.isAllLowerCase(" ")); // false

8. StringUtils.isAllLowerCase("china")); // true

三、移除

  从字符串中移除匹配的字符或字符序列，如果要移除的字符或字符序列在字符串中不存在，即无匹配，则不进行移除

1. 1）StringUtils.remove(String str, char remove)

2. 2）StringUtils.remove(String str, String remove)

3. 3）StringUtils.removeStart(String str, String remove)

4. 4）StringUtils.removeStartIgnoreCase(String str, String remove)

5. 5）StringUtils.removeEnd(String str, String remove)

6. 6）StringUtils.removeEndIgnoreCase(String str, String remove)

7. 7）StringUtils.deleteWhitespace(String str)

  （1）移除单个字符

1. StringUtils.remove(null, 'a')); // null (注意此处及下一行为null)

2. StringUtils.remove('china', null) // china

3. StringUtils.remove("china", 'i')); // chna

4. StringUtils.remove("china", 'b')); // china (如果要移除的字符不存在，则返回原字符串)

  （2）移除指定字符序列

1. StringUtils.remove("china", "in")); // cha

2. StringUtils.remove("china", "nin")); // china

  （3）移除开头匹配的字符序列

1. StringUtils.removeStart("china", "ch")); // ina

2. StringUtils.removeStartIgnoreCase("china", "CHI")); // na (忽略大小写)

  （4）移除结尾匹配的字符序列

1. StringUtils.removeEnd("china", "na")); // chi

2. StringUtils.removeEndIgnoreCase("china", "NA")); // chi (忽略大小写)

  （5）移除空白字符

1. StringUtils.deleteWhitespace(null)); //null

2. StringUtils.deleteWhitespace(" c h i\tn\ra")); // china

四、替换

  StringUtils中常用的替换方法有如下几种

1. 1）replace(String text, String searchString, String replacement)

2. 2）replace(String text, String searchString, String replacement, int max)

3. 3）replaceChars(String str, char searchChar, char replaceChar)

4. 4）replaceChars(String str, String searchChars, String replaceChars)

5. 5）replaceOnce(String text, String searchString, String replacement)

6. 6）overlay(String str,String overlay,int start,int end)

7. 7）replaceEach(String text, String[] searchList, String[] replacementList)

8. 8）replaceEachRepeatedly(String text, String[] searchList, String[]replacementList)

  需要注意的是，若被替换的字符串为null，或者被替换的字符或字符序列为null，又或者替换的字符或字符序列为null，那么此次替换都会被忽略，返回原字符串

  （1）替换单个字符或字符序列

    （a）replace方法

      replace方法可以替换单个字符序列

1. StringUtils.replace("china", null, "z")); // china (此处被替换字符序列为null，因此替换会被忽略，返回原字符串)

2. StringUtils.replace("china", "c", null)); // china (此处替换字符序列为null，因此替换也被忽略，返回原字符串)

3. StringUtils.replace("china", "a", "ese")); // chinese

4. StringUtils.replace("china", "a", "")); // chin

      replace方法还可以指定最大替换的个数

1. StringUtils.replace("aabaaa", "a", "z", 0)); // aabaaa (0表示替换的个数为0，也就是不替换)

2. StringUtils.replace("aabaaa", "a", "z", 1)); // zabaaa (1表示最多替换1个)

3. StringUtils.replace("aabaaa", "a", "z", 2)); // zzbaaa (2表示最多替换2个)

4. StringUtils.replace("aabaaa", "a", "z", 3)); // zzbzaa (3表示最多替换3个)

5. StringUtils.replace("aabaaa", "a", "z", -1)); // zzbzaa (-1表示全部替换)

    （b）replaceChars方法

      replaceChars方法可以替换单个字符或者单个字符序列

1. StringUtils.replaceChars("china", 'a', 'z')); // chinz

2. StringUtils.replaceChars("china", "a", "z")); // chinz

    （c）replaceOnce方法

      replaceOnce方法只会替换一次，也就是只会替换第一个要替换的字符序列，后面即使有匹配的字符序列也不会被替换

        StringUtils.replaceOnce("abaa", "a", "z")); // zbaa

    （d）overlay方法

      overlay(String str,String overlay,int start,int end)方法可以在指定位置进行字符序列替换，从start索引处开始(包含)到end-1索引处为止进行替换

         StringUtils.overlay("abcdef", "zzzz", 2, 4)); // abzzzzef

      这里有一些特殊情况：

      1）起始索引start小于结束索引end，这时会将end作为起始索引，start作为结束索引

1. StringUtils.overlay("abcdef", "zzzz", 4, 2)); // abzzzzef

2. StringUtils.overlay("abcdef", "zzzz", 4, 3)); // abczzzzef

3. StringUtils.overlay("abcdef", "zzzz", 4, 4)); // abcdzzzzef

4. StringUtils.overlay("abcdef", "zzzz", 4, 5)); // abcdzzzzf

      2）起始索引start为负数，这时start会被当作0处理

1. StringUtils.overlay("abcdef", "zzzz", -1, 2)); // abcdzz

2. StringUtils.overlay("abcdef", "zzzz", -2, -3)); // zzzzabcdef

      3）结束索引end大于原始字符串的长度，这时end会被当作原始字符串长度处理

         StringUtils.overlay("abcdef", "zzzz", 8, 10)); // abcdefzzzz

  （2）同时替换多个字符序列

    （a）replaceEach方法

      replaceEach(String text, String[] searchList, String[] replacementList)方法可以同时替换多个字符序列，但被替换和替换的字符序列的个数应该对应，否则会报IllegalArgumentException

1. StringUtils.replaceEach("china", new String[] { "ch", "a" }, new String[] { "x", "z" })); // xhinz (将ch和a分别替换为x和z)

2. StringUtils.replaceEach("china", null, new String[] { "x", "z" })); // china (存在null，不进行替换)

3. StringUtils.replaceEach("china", new String[] { "ch", "a" }, new String[] { "x", "z", "y" })); // IllegalArgumentException (被替换和替换的个数不对应)

    （b）replaceEachRepeatedly方法

      replaceEachRepeatedly(String text, String[] searchList, String[] replacementList)方法可以循环进行替换，具体见下面的例子：

           StringUtils.replaceEachRepeatedly("china", new String[] { "c", "x" }, new String[] { "x", "z" })); // zhina (c被替换为x，x又被替换为z)

      但如果替换是一个死循环，则会报IllegalStateException：

           StringUtils.replaceEachRepeatedly("china", new String[] { "c", "x" }, new String[] { "x", "c" })); // IllegalStateException (c被替换为x，x又被替换为c)

五、反转

  StringUtils中有关反转的方法如下：

1. 1）reverse(String str)

2. 2）reverseDelimited(String str, char separatorChar)

  （1）简单反转

  reverse(String str)方法

    StringUtils.reverse("china")); // anihc

  （2）根据指定分隔符进行反转，分隔符之间的字符不进行反转

1. StringUtils.reverseDelimited("china", ',')); // china

2. StringUtils.reverseDelimited("cxhinxa", 'x')); // axhinxz

3. StringUtils.reverseDelimited("c.hin.a", '.')); // a.hin.c

4. StringUtils.reverseDelimited("c.hina", '.')); // hina.c

这次再汇总一下其它常用的方法。

一、截取

  StringUtils中常用的截取字符串的方法如下：

1. substring(String str,int start)

2. substring(String str,int start, int end)

3. substringAfter(String str,String separator)

4. substringAfterLast(String str,String separator)

5. substringBefore(String str,String separator)

6. substringBeforeLast(String str,String separator)

7. substringBetween(String str,String tag)

  需要注意的是，截取字符串时，若被截取的字符串为null或""，则截取之后的返回的字符串也为null和""。

  （1）根据指定位置截取字符串，当指定的截取位置为非负数时，则从左往右开始截取，第一位为0，后面依次类推，但当索引值为负数时，则从右往左截取，注意此时右侧第一位为-1：

    a）只指定了起始位置，则截取至字符串末尾：

1. StringUtils.substring(null, 2); // "" null和""截取后都返回null和""

2. StringUtils.substring(null, 2); // null

3. StringUtils.substring("china", 0); // china 指定的起始截取位置为0，则从第一位开始截取，也就是不截取

4. StringUtils.substring("china", 2); // ina 指定的截取位置为2，则从左往右第三位开始截取

5. StringUtils.substring("china", -2); // na 指定的截取位置为-2，则从右往左第二位开始截取

    b）指定了起始位置和结束位置，则从起始位置开始截取到结束位置（但不包含结束位置）：

1. StringUtils.substring(null, 2, 4); // null null和""截取后都返回null和""

2. StringUtils.substring("", 2, 4); // ""

3. StringUtils.substring("china", 0, 0); // ""

4. StringUtils.substring("china", 2, 4); // in

5. StringUtils.substring("china", -2, -4); // in

6. StringUtils.substring("china", 2, -3); // ""

7. StringUtils.substring("china", 2, -1); // in

    （2）根据指定的分隔符进行截取（不包含该分隔符）：
      a）从分隔符第一次出现的位置向后截取：

1. StringUtils.substringAfter("china", "i"); // na 从第一次出现"i"的位置向后截取，不包含第一次出现的"i"

2. StringUtils.substringAfter("china", "hi"); // na

3. StringUtils.substringAfter("chinachina","h")); // inachina

4. StringUtils.substringAfter("china", "a"); // ""

5. StringUtils.substringAfter("china", "d"); // "" 分隔符在要截取的字符串中不存在，则返回""

6. StringUtils.substringAfter("china", "")); // china 分隔符为""，则返回原字符串

7. Stringtils.substringAfter("china", null); // "" 分隔符为null，则返回""

      b）从分隔符最后一次出现的位置向后截取：

1. StringUtils.substringAfterLast("china", "i"); // na

2. StringUtils.substringAfterLast("chinachina", "i"); // na "i"最后出现的位置向后截取

      c）从分隔符第一次出现的位置向前截取：

1. StringUtils.substringBefore("china", "i"); // ch

2. StringUtils.substringBefore("chinachina", "i"); // ch 从"i"第一次出现的位置向前截取

      d）从分隔符最后一次出现的位置向前截取：

1. StringUtils.substringBeforeLast("china", "i");

2. StringUtils.substringBeforeLast("chinachina", "i"); // chinach

      e）截取指定标记字符串之间的字符序列：

1. StringUtils.substringBetween(null, "ch") // null

2. StringUtils.substringBetween("", "") // ""

3. StringUtils.substringBetween("tagabctag", "") // "" 标记字符串为""，则截取后返回""

4. StringUtils.substringBetween("", "tag") // null // 注意此处返回的是null

5. StringUtils.substringBetween("tagabctag", null) // null 标记字符串为null，则截取后返回null

6. StringUtils.substringBetween("tagabctag", "tag") // "abc"

二、去除空白：

  去除字符串中的空白符是我们在处理字符串时经常遇到的问题，StringUtils中也封装了一些非常好用的方法来帮助我们解决这个问题：

1. trim(String str)

2. trimToEmpty(String str)

3. trimToNull(String str)

4. strip(String str)

5. stripToEmpty(String str)

6. stripToNull(String str)

7. deleteWhitespace(String str)

  （1）去除字符串首尾的控制符（char ≤ 32）
    a）trim(String str)：如果被去除的字符串的为null或""，则返回null和"":

1. StringUtils.trim(null); // null

2. StringUtils.trim(""); // ""

3. StringUtils.trim(" ");// ""

4. StringUtils.trim("abc"); // abc

5. StringUtils.trim(" abc "); // abc

6. StringUtils.trim(" a b c "); // "a b c" 注意此处字符串内部的控制符是不去除的

    b）trimToEmpty(String str)：如果被去除的字符串的为null或""，则都返回"":

1. StringUtils.trimToEmpty(null); // "" 此处返回的是""

2. StringUtils.trimToEmpty(""); // ""

3. StringUtils.trimToEmpty(" ");// ""

4. StringUtils.trimToEmpty("abc"); // abc

5. StringUtils.trimToEmpty(" abc "); // abc

6. StringUtils.trimToEmpty(" a b c "); // a b c

    c）trimToNull(String str)：如果被去除的字符串的为null或""，则都返回null:

1. StringUtils.trimToNull(null); // null

2. StringUtils.trimToNull(""); // null

3. StringUtils.trimToNull(" ");// null

4. StringUtils.trimToNull("abc"); // abc

5. StringUtils.trimToNull(" \t\r\nabc "); // abc

6. StringUtils.trimToNull(" a b c "); // "a b c"

  （2）去除字符串首尾的空白符(空白符主要包括' '，'\t'，'\r'，'\n'等等，具体的空白符可以参考Java API中Character类中isWhiteSpace()方法中的描述)：
    a）trim(String str)：如果被去除的字符串的为null或""，则返回null和"":

1. StringUtils.strip(null); // null

2. StringUtils.strip(""); // ""

3. StringUtils.strip(" ");// ""

4. StringUtils.strip("abc"); // abc

5. StringUtils.strip(" \t\r\n abc "); // abc

6. StringUtils.strip(" a b c "); // a b c

    b）trimToEmpty(String str)：如果被去除的字符串的为null或""，则都返回"":

1. StringUtils.stripToEmpty(null); // null

2. StringUtils.stripToEmpty(""); // nulld

3. StringUtils.stripToEmpty(" ");// null

4. StringUtils.stripToEmpty("abc"); // abc

5. StringUtils.stripToEmpty(" \t\r\n abc "); // abc

6. StringUtils.stripToEmpty(" a b c "); // "a b c"

    c）trimToNull(String str)：如果被去除的字符串的为null或""，则都返回null:

1. StringUtils.stripToNull(null); // null

2. StringUtils.stripToNull(""); // nulld

3. StringUtils.stripToNull(" ");// null

4. StringUtils.stripToNull("abc"); // abc

5. StringUtils.stripToNull(" \t\r\n abc "); // abc

6. StringUtils.stripToNull(" a b c "); // "a b c"

  （2）去除字符串中所有的空白符：

1. StringUtils.deleteWhitespace(null); // null

2. StringUtils.deleteWhitespace(""); // ""

3. StringUtils.deleteWhitespace("abc"); // "abc"

4. StringUtils.deleteWhitespace(" ab c "); // "abc"

三、包含：

  StringUtils中判断是否包含的方法主要有：

1. contains(CharSequence seq, int searchChar)

2. contains(CharSequence seq, CharSequence searchSeq)

3. containsIgnoreCase(CharSequence str, CharSequence searchStr)

4. containsAny(CharSequence cs, char... searchChars)

5. containsAny(CharSequence cs, CharSequence searchChars)

6. containsOnly(CharSequence cs,char… valid)

7. containsOnly(CharSequence cs, String validChars)

8. containsNone(CharSequence cs,char… searchChars)

9. containsNone(CharSequence cs, String invalidChars)

10. startsWith(CharSequence str,CharSequence prefix)

11. startsWithIgnoreCase(CharSequence str,CharSequence prefix)

12. startsWithAny(CharSequence string,CharSequence… searchStrings)

  （1）判断字符串中是否包含指定的字符或字符序列：
    a）区分大小写：

1. StringUtils.contains(null, 'a'); // false

2. StringUtils.contains("china", null); // false

3. StringUtils.contains("", 'a'); // false

4. StringUtils.contains("china", 'a');// true

5. StringUtils.contains("china", 'z');//false

6. StringUtils.contains(null, "a"); // false

7. StringUtils.contains("china", null); // false

8. StringUtils.contains("", ""); // true

9. StringUtils.contains("abc", "");// true

10. StringUtils.contains("china", "na");// true

11. StringUtils.contains("abc", "z"); // false

    b）不区分大小写：

1. StringUtils.containsIgnoreCase("china", 'a');// true

2. StringUtils.containsIgnoreCase("china", 'A');// true

3. StringUtils.containsIgnoreCase("china", 'Z');//false

4. StringUtils.containsIgnoreCase(null, "A"); // false

5. StringUtils.containsIgnoreCase("china", null); // false

6. StringUtils.containsIgnoreCase("", ""); // true

7. StringUtils.containsIgnoreCase("abc", "");// true

8. StringUtils.containsIgnoreCase("china", "na");// true

9. StringUtils.containsIgnoreCase("china", "Na");// true

10. StringUtils.containsIgnoreCase("abc", "Z"); // false

  （2）判断字符串中是否包含指定字符集合中或指定字符串中任一字符，区分大小写：

1. StringUtils.containsAny(null, 'a', 'b');// false

2. StringUtils.containsAny("", 'a', 'b');// false

3. StringUtils.containsAny("abc", 'a', 'z');// true

4. StringUtils.containsAny("abc", 'x', 'y');// false

5. StringUtils.containsAny("abc", 'A', 'z');// false

6. StringUtils.containsAny(null, "a");// false

7. StringUtils.containsAny("", "a");// false

8. StringUtils.containsAny("abc", "ab");// true

9. StringUtils.containsAny("abc", "ax");// true

10. StringUtils.containsAny("abc", "xy");// false

11. StringUtils.containsAny("abc", "Ax");// false

  （3）判断字符串中是否不包含指定的字符或指定的字符串中的字符，区分大小写：

1. StringUtils.containsNone(null, 'a'); // true

2. StringUtils.containsNone("", 'a'); // true 注意这里，空串总是返回true

3. StringUtils.containsNone("china", ' '); // true 注意包含空白符为true

4. StringUtils.containsNone("china", '\t'); // true

5. StringUtils.containsNone("china", '\r'); // true

6. StringUtils.containsNone("china", 'x', 'y', 'z'); // true

7. StringUtils.containsNone("china", 'c', 'y', 'z'); // false

8. StringUtils.containsNone("china", 'C', 'y', 'z'); // true

9. StringUtils.containsNone(null, "a"); // true

10. StringUtils.containsNone("", "a"); // true

11. StringUtils.containsNone("china", ""); // true

12. StringUtils.containsNone("china", "xyz"); // true

13. StringUtils.containsNone("china", "cyz"); // false

14. StringUtils.containsNone("china", "Cyz"); // true

  （4）判断字符串中的字符是否都是出自所指定的字符数组或字符串，区分大小写：

1. StringUtils.containsOnly(null, 'a');// false

2. StringUtils.containsOnly("", "a");// true

3. StringUtils.containsOnly("ab", ' ');// false

4. StringUtils.containsOnly("abab", 'a', 'b', 'c');// true

5. StringUtils.containsOnly("abcd", 'a', 'b', 'c');// false

6. StringUtils.containsOnly("Abab", 'a', 'b', 'c');// false

7. StringUtils.containsOnly(null, "a");// false

8. StringUtils.containsOnly("", "a"); // true

9. StringUtils.containsOnly("abab", "abc));// true

10. StringUtils.containsOnly("abcd", "abc"); // false

11. StringUtils.containsOnly("Abab", "abc");// false

  （5）判断字符串是否以指定的字符序列开头：
    a）区分大小写：

1. StringUtils.startsWith(null, null); // true

2. StringUtils.startsWith(null, "abc"); // false

3. StringUtils.startsWith("abcdef", null); // false

4. StringUtils.startsWith("abcdef", "abc"); // true

5. StringUtils.startsWith("ABCDEF", "abc"); // false

    b）不区分大小写：

1. StringUtils.startsWithIgnoreCase(null, null);// true

2. StringUtils.startsWithIgnoreCase(null, "abc");// false

3. StringUtils.startsWithIgnoreCase("abcdef", null);// false

4. StringUtils.startsWithIgnoreCase("abcdef", "abc");// true

5. StringUtils.startsWithIgnoreCase("ABCDEF", "abc");// true

  （6）判断字符串是否以指定的字符序列数组中任意一个开头，区分大小写：

1. StringUtils.startsWithAny(null, null);// false

2. StringUtils.startsWithAny(null, new String[] { "abc" });// false

3. StringUtils.startsWithAny("abcxyz", null);// false

4. StringUtils.startsWithAny("abcxyz", new String[] { "" });// true

5. StringUtils.startsWithAny("abcxyz", new String[] { "abc" });// true

6. StringUtils.startsWithAny("abcxyz", new String[] { null, "xyz", "abc" });// true

7. StringUtils.startsWithAny("abcxyz", null, "xyz", "ABCX");// false

8. StringUtils.startsWithAny("ABCXYZ", null, "xyz", "abc");// false

四、查询索引：

  StringUtils中获取字符或字符序列在字符串中出现的索引下标的方法主要有：

1. indexOf(CharSequence seq, int searchChar)

2. indexOf(CharSequence seq,CharSequence searchSeq)

3. indexOfIgnoreCase

4. indexOf(CharSequence seq,CharSequence searchSeq,int startPos)

5. lastIndexOf(CharSequence seq,int searchChar)

6. lastIndexOfIgnoreCase(CharSequence str,CharSequence searchStr)

  （1）获取指定字符或字符序列在字符串中第一次出现的索引，若字符串中不包含该字符或字符序列，则返回-1，若字符串或字符序列为""或null，也返回-1（（但字符串和字符序列都为""的情况下，则返回0））：
    a）区分大小写：

1. StringUtils.indexOf(null, 'a');// -1

2. StringUtils.indexOf("", 'a');// -1

3. StringUtils.indexOf("abca", 'a');// 0

4. StringUtils.indexOf("abca", 'b');// 1

5. StringUtils.indexOf("abca", 'A');// -1

6. StringUtils.indexOf(null, "a"); // -1

7. StringUtils.indexOf("abc", null); // -1

8. StringUtils.indexOf("", ""); // 0

9. StringUtils.indexOf("", "a"); // -1 注意这里第二个参数为""时则为0

10. StringUtils.indexOf("abc", "a"); // 0

11. StringUtils.indexOf("abc", "b"); // 1

12. StringUtils.indexOf("abc", "ab"); // 0

13. StringUtils.indexOf("abc", ""); // 0

    b）不区分大小写：

1. StringUtils.indexOfIgnoreCase(null, "a"); // -1

2. StringUtils.indexOfIgnoreCase("abc", null); // -1

3. StringUtils.indexOfIgnoreCase("", ""); // 0

4. StringUtils.indexOfIgnoreCase("", "a");// -1

5. StringUtils.indexOfIgnoreCase("abc", "b));// 1

6. StringUtils.indexOfIgnoreCase("abc", "B"); // 1

  （1）获取字符序列在字符串中指定位置之后第一次出现的索引，若字符串中指定位置之后不包含该字符序列，则返回-1，若字符串或字符序列为""或null，也返回-1（但字符串和字符序列都为""的情况下，结果就有点怪异，有时返回0，有时返回1，有时返回-1，根据指定的起始位置会有变化）：
    a）区分大小写：

1. StringUtils.indexOf(null, "a", 2); // -1

2. StringUtils.indexOf("abc", null, 2); // -1

3. StringUtils.indexOf("", "", 0); // 0 注意此处和下一行都返回0，对比忽略大小写的情形，就有点不一样

4. StringUtils.indexOf("", "", 1); // 0

5. StringUtils.indexOf("", "", 2); // 0

6. StringUtils.indexOf("", "a", 0); // -1 不包括第二个参数为""的情况

7. StringUtils.indexOf("abac", "a", 1); // 2

8. StringUtils.indexOf("abcab", "ab", 2); // 3

9. StringUtils.indexOf("abc", "a", -1); // 0 -1被当作是0

10. StringUtils.indexOf("abc", "a", 2); // -1

    b）不区分大小写：

1. StringUtils.indexOfIgnoreCase("", "", 0)); // 0

2. StringUtils.indexOfIgnoreCase("", "", 0)); // 1 与不忽略大小写的情况不同，下面也是

3. StringUtils.indexOfIgnoreCase("", "", 0)); //-1

4. StringUtils.indexOfIgnoreCase("abac", "A", 1)); // 2

5. StringUtils.indexOfIgnoreCase("abcab", "AB", 2)); // 3

6. StringUtils.indexOfIgnoreCase("abc", "B", -1)); // 1 -1被当作是0

  （2）获取指定字符或字符序列在字符串中最后一次出现的索引，若字符串中不包含该字符序列，则返回-1，若字符串或字符序列为""或null，也返回-1（但字符串和字符序列都为""的情况下，返回0）：
    a）区分大小写：

1. StringUtils.lastIndexOf(null, 'a'));// -1

2. StringUtils.lastIndexOf("", 'a'));// -1

3. StringUtils.lastIndexOf("abccba", 'a'));// 5

4. StringUtils.lastIndexOf("abccba", 'z'));// -1

5. StringUtils.lastIndexOf(null, "a"));// -1

6. StringUtils.lastIndexOf("abc", null));// -1

7. StringUtils.lastIndexOf("", ""));// 0

8. StringUtils.lastIndexOf("abc", "b"));// 1

9. StringUtils.lastIndexOf("abc", "ab"));// 0

10. StringUtils.lastIndexOf("abc", ""));// 3 返回字符串的长度

    b）不区分大小写：

1. StringUtils.lastIndexOfIgnoreCase(null, "a");// -1

2. StringUtils.lastIndexOfIgnoreCase("abc", null);// -1

3. StringUtils.lastIndexOfIgnoreCase("", "");// 0

4. StringUtils.lastIndexOfIgnoreCase("abc", "B");// 1

5. StringUtils.lastIndexOfIgnoreCase("abc", "AB");// 0

6. StringUtils.lastIndexOfIgnoreCase("abc", "");// 3 返回字符串的长度