在上一篇中總結了StringUtils工具類在判斷字串為空，大小寫轉換，移除字元或字元序列，替換，反轉，切割合併等方面的方法，這次再彙總一下其它常用的方法。

一、擷取

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

substring(String str,int start)
substring(String str,int start, int end)
substringAfter(String str,String separator)
substringAfterLast(String str,String separator)
substringBefore(String str,String separator)
substringBeforeLast(String str,String separator)
substringBetween(String str,String tag)
 

  需要注意的是，擷取字串時，若被擷取的字串為null或""，則擷取之後的返回的字串也為null和""。

  （1）根據指定位置擷取字串，當指定的擷取位置為非負數時，則從左往右開始擷取，第一位為0，後面依次類推，但當索引值為負數時，則從右往左擷取，注意此時右側第一位為-1：

    a）只指定了起始位置，則擷取至字串末尾：

StringUtils.substring(null, 2); // "" null和""擷取後都返回null和""
StringUtils.substring(null, 2); // null
StringUtils.substring("china", 0); // china 指定的起始擷取位置為0，則從第一位開始擷取，也就是不擷取
StringUtils.substring("china", 2); // ina 指定的擷取位置為2，則從左往右第三位開始擷取
StringUtils.substring("china", -2); // na 指定的擷取位置為-2，則從右往左第二位開始擷取
 

    b）指定了起始位置和結束位置，則從起始位置開始擷取到結束位置（但不包含結束位置）：

StringUtils.substring(null, 2, 4); // null null和""擷取後都返回null和""
StringUtils.substring("", 2, 4); // ""
StringUtils.substring("china", 0, 0); // ""
StringUtils.substring("china", 2, 4); // in
StringUtils.substring("china", -2, -4); // in
StringUtils.substring("china", 2, -3); // ""
StringUtils.substring("china", 2, -1); // in
 

    （2）根據指定的分隔符進行擷取（不包含該分隔符）：       a）從分隔符第一次出現的位置向後擷取：

StringUtils.substringAfter("china", "i"); // na 從第一次出現"i"的位置向後擷取，不包含第一次出現的"i"
StringUtils.substringAfter("china", "hi"); // na
StringUtils.substringAfter("chinachina","h")); // inachina
StringUtils.substringAfter("china", "a"); // ""
StringUtils.substringAfter("china", "d"); // "" 分隔符在要擷取的字串中不存在，則返回""
StringUtils.substringAfter("china", "")); // china 分隔符為""，則返回原字串
Stringtils.substringAfter("china", null); // "" 分隔符為null，則返回""

      b）從分隔符最後一次出現的位置向後擷取：

StringUtils.substringAfterLast("china", "i"); // na
StringUtils.substringAfterLast("chinachina", "i"); // na "i"最後出現的位置向後擷取

      c）從分隔符第一次出現的位置向前擷取：

StringUtils.substringBefore("china", "i"); // ch 
StringUtils.substringBefore("chinachina", "i"); // ch 從"i"第一次出現的位置向前擷取

      d）從分隔符最後一次出現的位置向前擷取：

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

      e）擷取指定標記字串之間的字元序列：

StringUtils.substringBetween(null, "ch") // null
StringUtils.substringBetween("", "") // ""
StringUtils.substringBetween("tagabctag", "") // "" 標記字串為""，則擷取後返回""
StringUtils.substringBetween("", "tag") // null // 注意此處返回的是null
StringUtils.substringBetween("tagabctag", null) // null 標記字串為null，則擷取後返回null
StringUtils.substringBetween("tagabctag", "tag") // "abc"

二、去除空白：

  去除字串中的空白符是我們在處理字串時經常遇到的問題，StringUtils中也封裝了一些非常好用的方法來幫助我們解決這個問題：

trim(String str)
trimToEmpty(String str)
trimToNull(String str)
strip(String str)
stripToEmpty(String str)
stripToNull(String str)
deleteWhitespace(String str)

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

StringUtils.trim(null); // null
StringUtils.trim(""); // ""
StringUtils.trim("     ");// ""
StringUtils.trim("abc"); // abc
StringUtils.trim("    abc    "); // abc
StringUtils.trim(" a b c "); // "a b c" 注意此處字串內部的控制符是不去除的

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

StringUtils.trimToEmpty(null); // "" 此處返回的是""
StringUtils.trimToEmpty(""); // ""
StringUtils.trimToEmpty("     ");// ""
StringUtils.trimToEmpty("abc"); // abc
StringUtils.trimToEmpty("    abc    "); // abc
StringUtils.trimToEmpty(" a b c "); // a b c

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

StringUtils.trimToNull(null); // null
StringUtils.trimToNull(""); // null
StringUtils.trimToNull("     ");// null
StringUtils.trimToNull("abc"); // abc
StringUtils.trimToNull(" \t\r\nabc    "); // abc
StringUtils.trimToNull(" a b c "); // "a b c" 

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

StringUtils.strip(null); // null
StringUtils.strip(""); // ""
StringUtils.strip("     ");// ""
StringUtils.strip("abc"); // abc
StringUtils.strip(" \t\r\n abc    "); // abc
StringUtils.strip(" a b c "); // a b c

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

StringUtils.stripToEmpty(null); // null
StringUtils.stripToEmpty(""); // nulld
StringUtils.stripToEmpty("     ");// null
StringUtils.stripToEmpty("abc"); // abc
StringUtils.stripToEmpty(" \t\r\n abc    "); // abc
StringUtils.stripToEmpty(" a b c "); // "a b c"

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

StringUtils.stripToNull(null); // null
StringUtils.stripToNull(""); // nulld
StringUtils.stripToNull("     ");// null
StringUtils.stripToNull("abc"); // abc
StringUtils.stripToNull(" \t\r\n abc    "); // abc
StringUtils.stripToNull(" a b c "); // "a b c"

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

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

三、包含：

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

contains(CharSequence seq, int searchChar)
contains(CharSequence seq, CharSequence searchSeq)
containsIgnoreCase(CharSequence str, CharSequence searchStr)
containsAny(CharSequence cs, char... searchChars)
containsAny(CharSequence cs, CharSequence searchChars)
containsOnly(CharSequence cs,char… valid)
containsOnly(CharSequence cs, String validChars)
containsNone(CharSequence cs,char… searchChars)
containsNone(CharSequence cs, String invalidChars)
startsWith(CharSequence str,CharSequence prefix)
startsWithIgnoreCase(CharSequence str,CharSequence prefix)
startsWithAny(CharSequence string,CharSequence… searchStrings)

  （1）判斷字串中是否包含指定的字元或字元序列：     a）區分大小寫：

StringUtils.contains(null, 'a'); // false
StringUtils.contains("china", null); // false
StringUtils.contains("", 'a'); // false
StringUtils.contains("china", 'a');// true
StringUtils.contains("china", 'z');//false
StringUtils.contains(null, "a"); // false
StringUtils.contains("china", null); // false
StringUtils.contains("", ""); // true
StringUtils.contains("abc", "");// true
StringUtils.contains("china", "na");// true
StringUtils.contains("abc", "z"); // false

    b）不區分大小寫：

StringUtils.containsIgnoreCase("china", 'a');// true
StringUtils.containsIgnoreCase("china", 'A');// true
StringUtils.containsIgnoreCase("china", 'Z');//false
StringUtils.containsIgnoreCase(null, "A"); // false
StringUtils.containsIgnoreCase("china", null); // false
StringUtils.containsIgnoreCase("", ""); // true
StringUtils.containsIgnoreCase("abc", "");// true         
StringUtils.containsIgnoreCase("china", "na");// true
StringUtils.containsIgnoreCase("china", "Na");// true
StringUtils.containsIgnoreCase("abc", "Z"); // false

  （2）判斷字串中是否包含指定字元集合中或指定字串中任一字元，區分大小寫：

StringUtils.containsAny(null, 'a', 'b');// false
StringUtils.containsAny("", 'a', 'b');// false
StringUtils.containsAny("abc", 'a', 'z');// true
StringUtils.containsAny("abc", 'x', 'y');// false
StringUtils.containsAny("abc", 'A', 'z');// false
StringUtils.containsAny(null, "a");// false
StringUtils.containsAny("", "a");// false
StringUtils.containsAny("abc", "ab");// true
StringUtils.containsAny("abc", "ax");// true
StringUtils.containsAny("abc", "xy");// false
StringUtils.containsAny("abc", "Ax");// false

  （3）判斷字串中是否不包含指定的字元或指定的字串中的字元，區分大小寫：

StringUtils.containsNone(null, 'a'); // true
StringUtils.containsNone("", 'a'); // true 注意這裡，空串總是返回true
StringUtils.containsNone("china", ' '); // true 注意包含空白符為true
StringUtils.containsNone("china", '\t'); // true
StringUtils.containsNone("china", '\r'); // true
StringUtils.containsNone("china", 'x', 'y', 'z'); // true
StringUtils.containsNone("china", 'c', 'y', 'z'); // false
StringUtils.containsNone("china", 'C', 'y', 'z'); // true
StringUtils.containsNone(null, "a"); // true
StringUtils.containsNone("", "a"); // true
StringUtils.containsNone("china", ""); // true
StringUtils.containsNone("china", "xyz"); // true
StringUtils.containsNone("china", "cyz"); // false
StringUtils.containsNone("china", "Cyz"); // true

  （4）判斷字串中的字元是否都是出自所指定的字元陣列或字串，區分大小寫：

StringUtils.containsOnly(null, 'a');// false
StringUtils.containsOnly("", "a");// true
StringUtils.containsOnly("ab", ' ');// false
StringUtils.containsOnly("abab", 'a', 'b', 'c');// true
StringUtils.containsOnly("abcd", 'a', 'b', 'c');// false
StringUtils.containsOnly("Abab", 'a', 'b', 'c');// false
StringUtils.containsOnly(null, "a");// false
StringUtils.containsOnly("", "a"); // true
StringUtils.containsOnly("abab", "abc));// true
StringUtils.containsOnly("abcd", "abc"); // false
StringUtils.containsOnly("Abab", "abc");// false

  （5）判斷字串是否以指定的字元序列開頭：     a）區分大小寫：

StringUtils.startsWith(null, null); // true
StringUtils.startsWith(null, "abc"); // false
StringUtils.startsWith("abcdef", null); // false
StringUtils.startsWith("abcdef", "abc"); // true
StringUtils.startsWith("ABCDEF", "abc"); // false

    b）不區分大小寫：

StringUtils.startsWithIgnoreCase(null, null);// true
StringUtils.startsWithIgnoreCase(null, "abc");// false
StringUtils.startsWithIgnoreCase("abcdef", null);// false
StringUtils.startsWithIgnoreCase("abcdef", "abc");// true
StringUtils.startsWithIgnoreCase("ABCDEF", "abc");// true

  （6）判斷字串是否以指定的字元序列陣列中任意一個開頭，區分大小寫：

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

四、查詢索引：

  StringUtils中獲取字元或字元序列在字串中出現的索引下標的方法主要有：

indexOf(CharSequence seq, int searchChar)
indexOf(CharSequence seq,CharSequence searchSeq)
indexOfIgnoreCase
indexOf(CharSequence seq,CharSequence searchSeq,int startPos)
lastIndexOf(CharSequence seq,int searchChar)
lastIndexOfIgnoreCase(CharSequence str,CharSequence searchStr)

  （1）獲取指定字元或字元序列在字串中第一次出現的索引，若字串中不包含該字元或字元序列，則返回-1，若字串或字元序列為""或null，也返回-1（（但字串和字元序列都為""的情況下，則返回0））：     a）區分大小寫：

StringUtils.indexOf(null, 'a');// -1
StringUtils.indexOf("", 'a');// -1
StringUtils.indexOf("abca", 'a');// 0
StringUtils.indexOf("abca", 'b');// 1
StringUtils.indexOf("abca", 'A');// -1
StringUtils.indexOf(null, "a"); // -1
StringUtils.indexOf("abc", null); // -1
StringUtils.indexOf("", ""); // 0
StringUtils.indexOf("", "a"); // -1  注意這裡第二個引數為""時則為0
StringUtils.indexOf("abc", "a"); // 0
StringUtils.indexOf("abc", "b"); // 1
StringUtils.indexOf("abc", "ab"); // 0
StringUtils.indexOf("abc", ""); // 0

    b）不區分大小寫：

StringUtils.indexOfIgnoreCase(null, "a"); // -1
StringUtils.indexOfIgnoreCase("abc", null); // -1
StringUtils.indexOfIgnoreCase("", ""); // 0
StringUtils.indexOfIgnoreCase("", "a");// -1
StringUtils.indexOfIgnoreCase("abc", "b));// 1
StringUtils.indexOfIgnoreCase("abc", "B"); // 1

  （1）獲取字元序列在字串中指定位置之後第一次出現的索引，若字串中指定位置之後不包含該字元序列，則返回-1，若字串或字元序列為""或null，也返回-1（但字串和字元序列都為""的情況下，結果就有點怪異，有時返回0，有時返回1，有時返回-1，根據指定的起始位置會有變化）：     a）區分大小寫：

StringUtils.indexOf(null, "a", 2); // -1
StringUtils.indexOf("abc", null, 2); // -1
StringUtils.indexOf("", "", 0); // 0 注意此處和下一行都返回0，對比忽略大小寫的情形，就有點不一樣
StringUtils.indexOf("", "", 1); // 0
StringUtils.indexOf("", "", 2); // 0 
StringUtils.indexOf("", "a", 0); // -1 不包括第二個引數為""的情況
StringUtils.indexOf("abac", "a", 1); // 2
StringUtils.indexOf("abcab", "ab", 2); // 3
StringUtils.indexOf("abc", "a", -1); // 0 -1被當作是0
StringUtils.indexOf("abc", "a", 2); // -1

    b）不區分大小寫：

StringUtils.indexOfIgnoreCase("", "", 0)); // 0
StringUtils.indexOfIgnoreCase("", "", 0)); // 1 與不忽略大小寫的情況不同，下面也是
StringUtils.indexOfIgnoreCase("", "", 0)); //-1 
StringUtils.indexOfIgnoreCase("abac", "A", 1)); // 2
StringUtils.indexOfIgnoreCase("abcab", "AB", 2)); // 3
StringUtils.indexOfIgnoreCase("abc", "B", -1)); // 1 -1被當作是0

  （2）獲取指定字元或字元序列在字串中最後一次出現的索引，若字串中不包含該字元序列，則返回-1，若字串或字元序列為""或null，也返回-1（但字串和字元序列都為""的情況下，返回0）：     a）區分大小寫：

StringUtils.lastIndexOf(null, 'a'));// -1
StringUtils.lastIndexOf("", 'a'));// -1
StringUtils.lastIndexOf("abccba", 'a'));// 5
StringUtils.lastIndexOf("abccba", 'z'));// -1
StringUtils.lastIndexOf(null, "a"));// -1
StringUtils.lastIndexOf("abc", null));// -1
StringUtils.lastIndexOf("", ""));// 0
StringUtils.lastIndexOf("abc", "b"));// 1
StringUtils.lastIndexOf("abc", "ab"));// 0
StringUtils.lastIndexOf("abc", ""));// 3 返回字串的長度

    b）不區分大小寫：

StringUtils.lastIndexOfIgnoreCase(null, "a");// -1
StringUtils.lastIndexOfIgnoreCase("abc", null);// -1
StringUtils.lastIndexOfIgnoreCase("", "");// 0
StringUtils.lastIndexOfIgnoreCase("abc", "B");// 1
StringUtils.lastIndexOfIgnoreCase("abc", "AB");// 0
StringUtils.lastIndexOfIgnoreCase("abc", "");// 3  返回字串的長度