StringUtils常用方法

最新推荐文章于 2024-01-26 07:00:00 发布
最新推荐文章于 2024-01-26 07:00:00 发布
阅读量3.5k 收藏 56
点赞数 10
分类专栏： JavaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_40770656/article/details/104953883
版权

文章目录


日常开发中对字符串的处理是非常常见的，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

三分恶
关注
  • 10
    点赞
  • 踩
  • 56
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
自定封装StringUtils常用方法
02-24
继承了org.apache.commons.lang3.StringUtils工具类，加入了部分常用方法，使用时直接添加到项目的公共utils下，同时在pom.xml加入依赖： <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 --> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> <version>3.9</version> </dependency>
StringUtils工具类常见方法
不积跬步无以至千里
02-12 366
将集合或者数组以某种拼接符号拼接到一起，形成一个新的字符串（String类型的返回值）（1）指定开始位置： 会从指定的开始位置，一直截取到字符串末尾。三、subString根据指定位置截取字符串。（2）从分隔符最后一次出现的位置开始截取。（4）从分隔符最后一次出现的位置向前截取。从指定的分隔符截取，但不包含这个分隔符。（3）从分隔符第一次出现的位置向前截取。（5）截取指定标记字符串之间的字符串。1、去除字符串首位的控制字符。1、根据指定位置截取字符串。2、去除字符串首位的空白符。2、从指定的分隔符截取。
详细分析Java中的StringUtils工具类（org.springframework.util.StringUtils）
最新发布
码农研究僧的博客
01-26 1207
`org.springframework.util.StringUtils` 是 Spring Framework 中的一个实用工具类，用于执行各种字符串相关的操作。 `StringUtils` 旨在提供方便、简化的字符串处理方法，以支持开发人员在 Spring 应用程序中更轻松地处理字符串。包含了一系列静态方法，涵盖了一些常见的字符串操作，例如判空、判长度、连接、删除空白字符等。
StringUtils类方法介绍
Radica的博客
05-03 657
转载文章用于自己学习使用，若有侵权之处，请联系删除。
StringUtils中常用的方法
Li2992673708的博客
12-22 358
【代码】StringUtils中常用的方法。
StringUtils工具类的常用方法
江夏lz的博客
11-25 893
StringUtils 方法的操作对象是 java.lang.String 类型的对象，是对 JDK 提供的 String 类型操作方法的补充，并且是 null 安全的(即如果输入参数 String 为 null 则不会抛出  NullPointerException ，而是做了相应处理，例如，如果输入为 null 则返回也是 null 等，具体可以查看源代码)。除了构造器，StringUti...
JAVA 字符串截取方法
jingshuyunsi的博客
11-19 6135
java 字符串截取
Java 关于字符截取工具类【StringUtils】的集中截取方法
weixin_47056195的博客
11-10 551
【代码】Java 关于字符截取工具类【StringUtils】的集中截取方法。
StringUtils工具类常用方法
m0_56812186的博客
05-09 618
需要注意的是，若被替换的字符串为null，或者被替换的字符或字符序列为null，又或者替换的字符或字符序列为null，那 此次替换都会被忽略，返回原字符串；StringUtils类在操作字符串是安全的，不会报空指针异常，也正因此，在操作字符串时使用StringUtils相比使用原生的String会更加安全。isBlank：判断更严谨，包含的有空串("")、空白符(空格""，" “，制表符”\t"，回车符"\r"，"\n"等)以及null值；其它方法都差不多，就不展示源码了，有兴趣的朋友自己去查看下；
StringUtils.isEmpty和StringUtils.isBlank用法
大大
12-22 1032
转载自:http://blog.csdn.net/ocean20/article/details/6674077 StringUtils 方法的操作对象是 java.lang.String 类型的对象，是 JDK 提供的 String 类型操作方法的补充，并且是 null 安全的(即如果输入参数 String 为 null 则不会抛出 NullPointerException ，而是做了
java自定义封装StringUtils常用工具类
08-27
主要为大家详细介绍了java自定义封装StringUtils常用工具类，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
基于StringUtils工具类的常用方法介绍(必看篇)
08-29
下面小编就为大家带来一篇基于StringUtils工具类的常用方法介绍(必看篇)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
StringUtils API 使用方法
06-25
StringUtils方法的操作对象是java.lang.String类型的对象，是JDK提供的String类型操作方法的补充，并且是null安全的(即如果输入参数String为null则不会抛出NullPointerException，而是做了相应处理，例如，如果输入...
StringUtils 字符串常用工具
03-17
NULL 博文链接：https://xylonwang.iteye.com/blog/467843
Java时间格式字符串与Date的相互转化
热门推荐
三分恶的博客
02-14 1万+
文章目录将Date转化为格式化字符串时间格式字符串转换为Date 将Date转化为格式化字符串 将Date转化为格式化字符串是利用SimpleDateFormat类继承自 java.text.DateFormat类的format方法实现的： public final String format(Date date):将日期格式化成日期/时间字符串。 //获取当前时间 ...
Java工程师核心书单，阿里大佬看了都说好！
三分恶的博客
03-14 7211
Java核心书单，优中选优。
Java Review（三十七、多线程）
三分恶的博客
12-28 4688
文章目录线程和进程 几乎所有的操作系统都支持同时运行多个任务， 一个任务通常就是一个程序， 每个运行中的程序就是一个进程。 当一个程序运行时， 内部可能包含了多个顺序执行流， 每个顺序执行流就是一个线程。 线程和进程 几乎所有的操作系统都支持进程的概念， 所有运行中的任务通常对应一个进程（ Process)。 当一个程序进入内存运行时， 即变成一个进程。 进程是处于运行过程中的程序， 并且具...
Google Gson用法详解
三分恶的博客
05-31 3622
Gson（又称Google Gson）是Google公司发布的一个开放源代码的Java库，主要用途为序列化Java对象为JSON字符串，或反序列化JSON字符串成Java对象。
apache的StringUtils常用方法
03-24
Apache StringUtils 常用方法包括： 1. isEmpty()：判断字符串是否为空 2. isBlank()：判断字符串是否为空或者只包含空格 3. trim()：去除字符串两端的空格 4. equals()：比较两个字符串是否相等 5. substring()：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

三分恶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值