@[Toc]

日常开发中对字符串的处理是非常常见的，StringUtils工具类是org.apache.commons.lang3包下的工具类，对String类型的操作作了封装，是对Java自带的API的有效补充，可以帮助我们更高效快速地处理字符串。

除了构造方法外，StirngUtils类的所有方法均是类方法，可以直接通过类来调用，同时官方也不建议构造StringUtils实例。

1、截取

StingUtils常用的截取字符串的方法：

String substring(String str,int start)：避免异常地从指定的String获取一个子字符串。
String substring(String str,int start, int end)：可避免异常地从指定的String获取一个子字符串。
String substringAfter(String str,String separator)：在第一次出现分隔符后获取子字符串。
String substringAfterLast(String str,String separator)：在最后一次出现分隔符之后获取子字符串。
String substringBefore(String str,String separator)：在第一次出现分隔符之前获取子字符串。
String substringBeforeLast(String str,String separator)：在最后一次出现分隔符之前获取子字符串。
String substringBetween(String str,String tag)：获取嵌套在同一String的两个实例之间的String。
String substringBetween(String str, String open, String close)：获取嵌套在两个字符串之间的字符串。

1.1、根据指定位置截取字符串

（1）、指定开始位置

只指定开始位置，会截取到字符串末尾：

      // "" null和""截取后都返回null和""
      StringUtils.substring(null, 2);
      // null
      StringUtils.substring(null, 2);
      // fighter 指定的起始截取位置为0，则从第一位开始截取，也就是不截取
      StringUtils.substring("fighter", 0);
      // ghter 指定的截取位置为2，则从左往右第三位开始截取
      StringUtils.substring("fighter", 2);
      // er 指定的截取位置为-2，则从右往左第二位开始截取
      StringUtils.substring("fighter", -2);

（2）、指定起始位置和结束位置

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

  // null null和""截取后都返回null和""
    StringUtils.substring(null, 2, 4);
    // ""
    StringUtils.substring("", 2, 4);
    // ""
    StringUtils.substring("fighter", 0, 0);
    // gh
    StringUtils.substring("fighter", 2, 4);
    
    // ""
    StringUtils.substring("fighter", 2, -3);
    // ghte
    StringUtils.substring("fighter", 2, -1);

1.2、从指定的分隔符截取

从指定的分隔符截取，不包含该分隔符。

（1）、从分隔符第一次出现的位置向后截取

// na 从第一次出现"i"的位置向后截取，不包含第一次出现的"i"
StringUtils.substringAfter("china", "i"); 
// na
StringUtils.substringAfter("china", "hi");
// inachina 
StringUtils.substringAfter("chinachina","h")); 
// ""
StringUtils.substringAfter("china", "a"); 
// "" 分隔符在要截取的字符串中不存在，则返回""
StringUtils.substringAfter("china", "d"); 
// china 分隔符为""，则返回原字符串
StringUtils.substringAfter("china", "")); 
// "" 分隔符为null，则返回""
Stringtils.substringAfter("china", null);

（2）、从分隔符最后一次出现的位置向后截取

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

（3）、从分隔符第一次出现的位置向前截取

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

（4）、从分隔符最后一次出现的位置向前截取

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

（5）、截取指定标记字符串之间的字符序列

// null
StringUtils.substringBetween(null, "ch") 
StringUtils.substringBetween("", "") // ""
// "" 标记字符串为""，则截取后返回""
StringUtils.substringBetween("tagabctag", "") 
// null ， 注意此处返回的是null
StringUtils.substringBetween("", "tag") 
// null 标记字符串为null，则截取后返回null
StringUtils.substringBetween("tagabctag", null) 
// "abc"
StringUtils.substringBetween("tagabctag", "tag") 
//ght
StringUtils.substringBetween("fighter","fi","er")

2、判空

* CharSequence是一个描述字符串结构的接口，其中有三个常见的子类：Stirng、StringBuffer、StirngBuilder。

StingUtils判空的方法主要如下：

boolean isBlank(CharSequence cs) :检查CharSequence是否为空（“”），仅null或空白。
boolean isEmpty(CharSequence cs)：检查CharSequence是否为空（“”）或null。
boolean isNotBlank(CharSequence cs)：检查CharSequence是否不为空（“”），不为null和仅空白。
boolean isNotEmpty(CharSequence cs)：检查CharSequence是否不为空（“”）并且不为null。
boolean isAnyBlank(CharSequence... css)：检查是否有任何CharSequences为空（“”）或仅为null或空白。
boolean isAnyEmpty(CharSequence... css)：检查任何CharSequences是否为空（“”）或null。
boolean isNoneBlank(CharSequence... css)：检查所有CharSequences是否为空（“”）或null。
boolean isNoneEmpty(CharSequence... css)：检查所有CharSequences是否为空（“”）或null。
boolean isWhitespace(CharSequence cs)：检查CharSequence是否仅包含空格。

需要一提的是：上面都是判断的方法，其中blank、empty、whitespace的区别如下： blank：代表的是空串("")、空白符(空格""，" "，制表符"\t"，回车符"\r"，"\n"等)以及null值； empty：代表的是空串("")和null值，不包含空白符； whitespace：包含空串("")和空白符，不包含null值.

    StringUtils.isBlank("");   // true
    StringUtils.isBlank(" ");   // true
    StringUtils.isBlank("     "); // true
    StringUtils.isBlank("\t"); // true
    StringUtils.isBlank("\r"); // true
    StringUtils.isBlank("\n"); // true
    StringUtils.isBlank(null); // true
 
    StringUtils.isEmpty(""); // true
    StringUtils.isEmpty(" "); // false
    StringUtils.isEmpty("     "); // false
    StringUtils.isEmpty("\t"); // false
    StringUtils.isEmpty("\r"); // false
    StringUtils.isEmpty("\n"); // false
    StringUtils.isEmpty(null); // true
 
    StringUtils.isWhitespace(""); // true
    StringUtils.isWhitespace(" "); // true
    StringUtils.isWhitespace("    "); // true
    StringUtils.isWhitespace("\t"); // true
    StringUtils.isWhitespace("\r"); // true
    StringUtils.isWhitespace("\n"); // true
    StringUtils.isWhitespace(null); // false

isAnyBlank，isNoneBlank，isAnyEmpty，isNoneEmpty四个方法是用于判断多个字符串是否为空:

    StringUtils.isAnyBlank("titanic", "jack", "rose")); // false
    StringUtils.isAnyBlank("", "jack", "rose")); // true
    StringUtils.isAnyBlank(" ", "jack", "rose")); // true
    StringUtils.isAnyBlank(null, "jack", "rose")); // true
 
    StringUtils.isAnyEmpty("titanic", "jack", "rose")); // false
    StringUtils.isAnyEmpty("", "jack", "rose")); // true
    StringUtils.isAnyEmpty(" ", "jack", "rose")); // false
    StringUtils.isAnyEmpty(null, "jack", "rose")); // true
 
    StringUtils.isNoneBlank("titanic", "jack", "rose")); // true
    StringUtils.isNoneBlank("", "jack", "rose")); // false
    StringUtils.isNoneBlank(" ", "jack", "rose")); // false
    StringUtils.isNoneBlank(null, "jack", "rose")); // false
 
    StringUtils.isNoneEmpty("titanic", "jack", "rose")); // true
    StringUtils.isNoneEmpty("", "jack", "rose")); // false
    StringUtils.isNoneEmpty(" ", "jack", "rose")); // true
    StringUtils.isNoneEmpty(null, "jack", "rose")); // false

3、去除空白

去除空白是比较常见的问题，StingUtils常见的去除空白方法：

String trim(String str)：从此String的两端移除控制字符（char <= 32），并通过返回null来处理null。
String trimToEmpty(String str)：如果此字符串在修剪后为空（“”）或为null，则从此String的两端删除控制字符（char <= 32），并返回一个空String（“”）。
String trimToNull(String str)：如果该字符串在修剪后为空（“”）或为null，则从此String的两端删除控制字符（char <= 32），并返回null。
String strip(String str)：从字符串的开头和结尾去除空格。
String stripToEmpty(String str)：如果输入为null，则从String的开头和结尾去除空格，并返回一个空String。
String stripToNull(String str)：如果字符串开头为空（“”），则从字符串的开头和结尾去除空格，并返回null。
String deleteWhitespace(String str):从Character.isWhitespace（char）定义的字符串中删除所有空格。

3.1、去除字符串首尾的控制字符

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

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

    //trimToNull
    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"

3.2、去除字符串首尾的空白符

空白符主要包括' '，'\t'，'\r'，'\n'，'\u000B'，'\f'，'\u001C'，'\u001D' ，'\u001E'，'\u001F'。

    //strip
    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

    //stripToEmpty
    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"

    //stripToNull
    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"

3.3、去除字符串中所有的空白符

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

4、转换

StirngUtils中大小写转换主要方法：

String capitalize(String str)：根据Character.toTitleCase（int）将首字母大写更改为首字母大写。
String uncapitalize(String str)：将一个字符串取消大写，将每个字符按Character.toLowerCase（int）更改为小写。
String upperCase(String str)：根据String.toUpperCase（）将String转换为大写。
String upperCase(String str,Locale locale)：根据String.toUpperCase（Locale）将String转换为大写。
String lowerCase(String str)：根据String.toLowerCase（）将String转换为小写。
String lowerCase(String str,Locale locale)：根据String.toLowerCase（Locale）将String转换为小写。
String swapCase(String str)：交换字符串的大小写，将大写和标题大小写更改为小写，将小写更改为大写。
boolean isAllUpperCase(CharSequence cs)：检查CharSequence是否仅包含大写字符。
boolean isAllLowerCase(CharSequence cs)：检查CharSequence是否仅包含小写字符。

4.1、字符串首字母大小写转换

    StringUtils.capitalize(null)); // null (注意此处不会报异常)
    StringUtils.capitalize("china")); // China (首字母转大写)
    StringUtils.uncapitalize(null)); // null  
    StringUtils.uncapitalize("CHINA")); // cHINA (首字母转小写)

4.2、字符串整体大小写转换

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

4.3、字符串大小写互换

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

4.4、判断字符串是否全部是大写或小写

    StringUtils.isAllUpperCase(null)); // false
    StringUtils.isAllUpperCase("")); // false
    StringUtils.isAllUpperCase(" ")); // false
    StringUtils.isAllUpperCase("CHINA")); // true
    StringUtils.isAllLowerCase(null)); // false
    StringUtils.isAllLowerCase("")); // false
    StringUtils.isAllLowerCase(" ")); // false
    StringUtils.isAllLowerCase("china")); // true

5、替换

StingUtils类常见替换方法：

String replace(String text, String searchString, String replacement)：将字符串中的子串替换成另一个字符串
String replace(String text, String searchString, String replacement, int max)：将字符串替换为较大字符串中的另一个字符串，以获取搜索字符串的第一个最大值。
String replaceChars(String str, char searchChar, char replaceChar)：将一个字符串中所有出现的字符替换为另一个。
String replaceChars(String str, String searchChars, String replaceChars)：一次性替换字符串中的多个字符。
String replaceOnce(String text, String searchString, String replacement)：一次将一个字符串替换为较大字符串中的另一个字符串。
String overlay(String str,String overlay,int start,int end)：用另一个字符串覆盖一个字符串的一部分。
String replaceEach(String text, String[] searchList, String[] replacementList)：替换另一个字符串中所有出现的字符串。
String replaceEachRepeatedly(String text, String[] searchList, String[]replacementList)：替换另一个字符串中所有出现的字符串。

5.1、替换单个字符或字符序列

        //replace方法替换单个字符
        StringUtils.replace("china", null, "z")); // china (此处被替换字符序列为null，因此替换会被忽略，返回原字符串)
        StringUtils.replace("china", "c", null)); // china (此处替换字符序列为null，因此替换也被忽略，返回原字符串)
        StringUtils.replace("china", "a", "ese")); // chinese
        StringUtils.replace("china", "a", "")); // chin

     //  replace方法指定最大替换的个数      
        StringUtils.replace("aabaaa", "a", "z", 0)); // aabaaa (0表示替换的个数为0，也就是不替换)
        StringUtils.replace("aabaaa", "a", "z", 1)); // zabaaa (1表示最多替换1个)
        StringUtils.replace("aabaaa", "a", "z", 2)); // zzbaaa (2表示最多替换2个)
        StringUtils.replace("aabaaa", "a", "z", 3)); // zzbzaa (3表示最多替换3个)
        StringUtils.replace("aabaaa", "a", "z", -1)); // zzbzaa (-1表示全部替换)

     //replaceChars替换单个字符或者单个字符序列
        StringUtils.replaceChars("china", 'a', 'z')); // chinz
        StringUtils.replaceChars("china", "a", "z")); // chinz

    //replaceOnce方法只会替换一次，也就是只会替换第一个要替换的字符序列
        StringUtils.replaceOnce("abaa", "a", "z")); // zbaa

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

5.1、同时替换多个字符序列

 //replaceEach方法,可以同时替换多个字符序列，但被替换和替换的字符序列的个数应该对应，否则会报IllegalArgumentException
            StringUtils.replaceEach("china", new String[] { "ch", "a" }, new String[] { "x", "z" })); // xhinz (将ch和a分别替换为x和z)
         StringUtils.replaceEach("china", null, new String[] { "x", "z" })); // china (存在null，不进行替换)
         StringUtils.replaceEach("china", new String[] { "ch", "a" }, new String[] { "x", "z", "y" })); // IllegalArgumentException (被替换和替换的个数不对应)


//replaceEachRepeatedly方法,可以循环进行替换
           StringUtils.replaceEachRepeatedly("china", new String[] { "c", "x" }, new String[] { "x", "z" })); // zhina (c被替换为x，x又被替换为z)

6、包含

StringUtils包含主要方法如下：

boolean contains(CharSequence seq, int searchChar)：检查CharSequence是否包含搜索的CharSequence，处理null的情况。
boolean contains(CharSequence seq, CharSequence searchSeq)：检查CharSequence是否包含搜索的CharSequence，处理null的情况。
boolean containsIgnoreCase(CharSequence str, CharSequence searchStr)：检查CharSequence是否包含搜索CharSequence（不区分大小写），处理null。
boolean containsAny(CharSequence cs, char... searchChars)：检查CharSequence是否在给定的字符集中包含任何字符。
boolean containsAny(CharSequence cs, CharSequence searchChars)：检查CharSequence是否在给定的字符集中包含任何字符。
boolean containsOnly(CharSequence cs,char… valid)：检查CharSequence是否仅包含某些字符。
boolean containsOnly(CharSequence cs, String validChars)：检查CharSequence是否仅包含某些字符。
boolean containsNone(CharSequence cs,char… searchChars)：检查CharSequence是否不包含某些字符。
boolean containsNone(CharSequence cs, String invalidChars)：检查CharSequence是否不包含某些字符。
boolean startsWith(CharSequence str,CharSequence prefix)：检查CharSequence是否以指定的前缀开头。
boolean startsWithIgnoreCase(CharSequence str,CharSequence prefix)：不区分大小写，检查CharSequence是否以指定的前缀开头。
boolean startsWithAny(CharSequence string,CharSequence… searchStrings)：检查CharSequence是否以任何提供的区分大小写的前缀开头。

6.1、判断字符串中是否包含指定的字符或字符序列

  //区分大小写
  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

 //不区分大小写
  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

6.1、判断字符串中是否包含指定字符集合中或指定字符串中任一字符

  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

6.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

6.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

6.5、判断字符串是否以指定的字符序列开头

//区分大小写
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

//不区分大小写
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.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

7、反转

StringUtils反转的主要方法如下：

String reverse(String str)：根据StringBuilder.reverse（）反转字符串。
String reverseDelimited(String str, char separatorChar)：反转由特定字符分隔的字符串。

    //简单反转
    StringUtils.reverse("china")); // anihc

    //据指定分隔符进行反转
    StringUtils.reverseDelimited("china", ',')); // china
    StringUtils.reverseDelimited("cxhinxa", 'x')); // axhinxz
    StringUtils.reverseDelimited("c.hin.a", '.')); // a.hin.c
    StringUtils.reverseDelimited("c.hina", '.')); // hina.c

8、移除

StringUtils常用的移除方法：

String remove(String str, char remove)：从源字符串中删除所有出现的字符。
String remove(String str, String remove)：从源字符串中删除所有出现的子字符串。

  //移除字符
  StringUtils.remove(null, *)          // null
  StringUtils.remove("", *)            //""
  StringUtils.remove("queued", 'u')    // "qeed"
  StringUtils.remove("queued", 'z')     //"queued"

 //移除子字符串
  StringUtils.remove(null, *)        //null
 StringUtils.remove("", *)           //""
 StringUtils.remove(*, null)        //*
 StringUtils.remove(*, "")          //*
 StringUtils.remove("queued", "ue")   //"qd"
 StringUtils.remove("queued", "zz")   //"queued"

9、查询索引

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

int indexOf(CharSequence seq, int searchChar)：返回指定字符首次出现的序列中的索引。
int indexOf(CharSequence seq,CharSequence searchSeq)：在CharSequence中查找第一个索引。
int indexOfIgnoreCase(CharSequence str, CharSequence searchStr)：CharSequence中第一个索引的大小写不区分大小写。
int indexOf(CharSequence seq,CharSequence searchSeq,int startPos)：从指定位置在CharSequence中发现第一个索引的不区分大小写。
int lastIndexOf(CharSequence seq,int searchChar)：查找CharSequence中的最后一个索引。
int lastIndexOfIgnoreCase(CharSequence str,CharSequence searchStr)：查找CharSequence中的最后一个索引，不区分大小写。

9.1、获取指定字符或字符序列在字符串中第一次出现的索引

若字符串中不包含该字符或字符序列，则返回-1，若字符串或字符序列为""或null，也返回-1（（但字符串和字符序列都为""的情况下，则返回0）。

//区分大小写
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

//不区分大小写
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

9.2、获取字符序列在字符串中指定位置之后第一次出现的索引

//区分大小写
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

//不区分大小写
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

9.3、获取指定字符或字符序列在字符串中最后一次出现的索引

//区分大小写
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 返回字符串的长度

//不区分大小写
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  返回字符串的长度

参考：

【1】：StringUtils API 【2】：StringUtils--StringUtils中的截取、去除空白、包含、查询索引常用方法【3】：StringUtils工具类常用方法汇总(判空、转换、移除、替换、反转) 【4】：Java之StringUtils的常用方法【5】：StringUtils常用方法+StringUtils详细介绍详解【6】：CharSequence详情介绍【7】：Java中文API