StringUtils类方法归纳

StringUtils方法概览

• IsEmpty/IsBlank - checks if a String contains text
• IsEmpty/IsBlank – 检查字符串是否有内容。
• Trim/Strip - removes leading and trailing whitespace
• Trim/Strip – 删除字符串开始和结尾的空白符。
• Equals - compares two strings null-safe
• Equals – 比较两个字符串null安全。
• IndexOf/LastIndexOf/Contains - null-safe index-of checks
• IndexOf/LastIndexOf/Contains – null安全的索引检查。
• IndexOfAny/LastIndexOfAny/IndexOfAnyBut/LastIndexOfAnyBut - index-of any of a set of Strings
• IndexOfAny/LastIndexOfAny/IndexOfAnyBut/LastIndexOfAnyBut – 字符串集合索引检查。
• ContainsOnly/ContainsNone - does String contains only/none of these characters
• ContainsOnly/ContainsNone – 字符在字符串中出现一次或一次也没有出现。
• Substring/Left/Right/Mid - null-safe substring extractions
• Substring/Left/Right/Mid – null安全子串的提取。
• SubstringBefore/SubstringAfter/SubstringBetween - substring extraction relative to other strings
• SubstringBefore/SubstringAfter/SubstringBetween – 子串提取依赖其它字符串。
• Split/Join - splits a String into an array of substrings and vice versa
• Split/Join – 字符串拆分为子串的字符串数组，反之亦然。
• Remove/Delete - removes part of a String
• Remove/Delete – 删除部分字符串。
• Replace/Overlay - Searches a String and replaces one String with another
• Replace/Overlay – 替换字符串的部分字符。
• Chomp/Chop - removes the last part of a String
• Chomp/Chop – 删除字符串最后的字符。
• LeftPad/RightPad/Center/Repeat - pads a String
• LeftPad/RightPad/Center/Repeat – 补字符串。
• UpperCase/LowerCase/SwapCase/Capitalize/Uncapitalize - changes the case of a String
• UpperCase/LowerCase/SwapCase/Capitalize/Uncapitalize – 改变字符串的大小写。
• CountMatches - counts the number of occurrences of one String in another
• CountMatches – 计算一个字符或字符串在另外一个字符串出现的次数。
• IsAlpha/IsNumeric/IsWhitespace/IsAsciiPrintable - checks the characters in a String
• IsAlpha/IsNumeric/IsWhitespace/IsAsciiPrintable – 判断字符是否在字符串中。
• DefaultString - protects against a null input String
• DefaultString –null安全，null转换为字符串。
• Reverse/ReverseDelimited - reverses a String
• Reverse/ReverseDelimited – 反转字符串。
• Abbreviate - abbreviates a string using ellipsis
• Abbreviate – 缩写字符串用省略符。
• Difference - compares two Strings and reports on their differences
• Difference – 比较两个字符串并且返回不同。
• LevensteinDistance - the number of changes needed to change one String into another
• LevensteinDistance – 一个字符串改变为另一个字符串需要改变的数量。

判空函数

1. StringUtils.isEmpty(String str)
2. StringUtils.isNotEmpty(String str)
3. StringUtils.isBlank(String str)
4. StringUtils.isNotBlank(String str)
5. StringUtils.isWhitespace(CharSequence cs)

• isWhitespace判断空白

 StringUtils.isWhitespace(null)   = false
 StringUtils.isWhitespace("")     = true
 StringUtils.isWhitespace("  ")   = true
 StringUtils.isWhitespace("abc")  = false
 StringUtils.isWhitespace("ab2c") = false
 StringUtils.isWhitespace("ab-c") = false

• isBlank和isEmpty的区别（isNotBlank = !isBlank  Empty同理）

    public static boolean isBlank(String str) {
        int strLen;
        if (str == null || (strLen = str.length()) == 0) {
            return true;
        }
        for (int i = 0; i < strLen; i++) {
            if ((Character.isWhitespace(str.charAt(i)) == false)) {
                return false;
            }
        }
        return true;
    }

 StringUtils.isBlank(null)      = true
 StringUtils.isBlank("")        = true
 StringUtils.isBlank(" ")       = true
 StringUtils.isBlank("bob")     = false
 StringUtils.isBlank("  bob  ") = false

 StringUtils.isEmpty(null)      = true
 StringUtils.isEmpty("")        = true
 StringUtils.isEmpty(" ")       = false
 StringUtils.isEmpty("bob")     = false
 StringUtils.isEmpty("  bob  ") = false

删除函数

1. StringUtils.remove(String str, char remove)
2. StringUtils.remove(String str, String remove)
3. StringUtils.removeEnd(String str, String remove)
4. StringUtils.removeEndIgnoreCase(String str, String remove)
5. StringUtils.removeStart(String str, String remove)
6. StringUtils.removeStartIgnoreCase(String str, String remove)
7. StringUtils.deleteWhitespace(String str)

• 例子

//删除字符
StringUtils.remove("queued", 'u') = "qeed"

//删除字符串
StringUtils.remove("queued", "ue") = "qd"

//删除结尾匹配的字符串
StringUtils.removeEnd("www.domain.com", ".com")   = "www.domain"

//删除结尾匹配的字符串,找都不到返回原字符串
StringUtils.removeEnd("www.domain.com", "domain") = "www.domain.com"

//忽略大小写的
StringUtils.removeEndIgnoreCase("www.domain.com", ".COM") = "www.domain")

//删除所有空白（好用）
StringUtils.deleteWhitespace("abc")        = "abc"
StringUtils.deleteWhitespace("   ab  c  ") = "abc"

替换函数

1. replace(String text, String searchString, String replacement)
2. replace(String text, String searchString, String replacement, int max)
3. replaceChars(String str, char searchChar, char replaceChar)
4. replaceChars(String str, String searchChars, String replaceChars)
5. replaceEach(String text, String[] searchList, String[] replacementList)
6. replaceEachRepeatedly(String text, String[] searchList, String[] replacementList)
7. replaceOnce(String text, String searchString, String replacement)
8. overlay(String str,String overlay,int start,int end)

• 例子

StringUtils.replace("aba", "a", "")    = "b"
StringUtils.replace("aba", "a", "z")   = "zbz"    

//数字就是替换个数，0代表不替换，1代表从开始数起第一个，-1代表全部替换
StringUtils.replace("abaa", "a", "", -1)   = "b"
StringUtils.replace("abaa", "a", "z", 0)   = "abaa"
StringUtils.replace("abaa", "a", "z", 1)   = "zbaa"
StringUtils.replace("abaa", "a", "z", 2)   = "zbza"
StringUtils.replace("abaa", "a", "z", -1)  = "zbzz"

//replaceEach是replace的增强版，搜索列表和替换长度必须一致，否则报IllegalArgumentException异常
StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"w", "t"})  = "wcte"
StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"})  = "dcte"
StringUtils.replaceChars("dabcba", "bcd", "yzx") = "xayzya"
StringUtils.replaceChars("abcba", "bc", "y")   = "ayya"

//replaceOnce只替换一次
StringUtils.replaceOnce("aba", "a", "")    = "ba"
StringUtils.replaceOnce("aba", "a", "z")   = "zba"
StringUtils.replaceEachRepeatedly("abcde", new String[]{"ab", "d"}, new String[]{"w", "t"}) = "wcte"

//这是一个非常奇怪的函数，本来自己料想结果应该是“dcte”的，可是结果居然是tcte，而dcte再替换一次就是tcte了。
StringUtils.replaceEachRepeatedly("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"}) = "tcte"

StringUtils.overlay("abcdef", "zzzz", 2, 4)   = "abzzzzef"
StringUtils.overlay("abcdef", "zzzz", 4, 2)   = "abzzzzef"
StringUtils.overlay("abcdef", "zzzz", -1, 4)  = "zzzzef"
StringUtils.overlay("abcdef", "zzzz", 2, 8)   = "abzzzz"
StringUtils.overlay("abcdef", "zzzz", -2, -3) = "zzzzabcdef"
StringUtils.overlay("abcdef", "zzzz", 8, 10)  = "abcdefzzzz"

分隔合并函数

1. split(String str)
2. split(String str, char separatorChar)
3. split(String str, String separatorChars)
4. split(String str, String separatorChars, int max)
5. splitByCharacterType(String str)
6. splitByCharacterTypeCamelCase(String str)
7. splitByWholeSeparator(String str, String separator)
8. splitByWholeSeparator(String str, String separator, int max)
9. splitByWholeSeparatorPreserveAllTokens(String str, String separator)
10. splitByWholeSeparatorPreserveAllTokens(String str, String separator, int max)
11. splitPreserveAllTokens(String str)
12. splitPreserveAllTokens(String str, char separatorChar)
13. splitPreserveAllTokens(String str, String separatorChars)
14. splitPreserveAllTokens(String str, String separatorChars, int max)

//用空白符做空格
StringUtils.split("abc def")  = ["abc", "def"]
StringUtils.split("abc  def") = ["abc", "def"]
StringUtils.split("a..b.c", '.')   = ["a", "b", "c"]
//用字符分割
StringUtils.split("a:b:c", '.')    = ["a:b:c"]
//0 或者负数代表没有限制
StringUtils.split("ab:cd:ef", ":", 0)    = ["ab", "cd", "ef"]
//分割字符串 ,可以设定得到数组的长度，限定为2
StringUtils.split("ab:cd:ef", ":", 2)    = ["ab", "cd:ef"]
//null也可以作为分隔
StringUtils.splitByWholeSeparator("ab de fg", null)      = ["ab", "de", "fg"]
StringUtils.splitByWholeSeparator("ab   de fg", null)    = ["ab", "de", "fg"]
StringUtils.splitByWholeSeparator("ab:cd:ef", ":")       = ["ab", "cd", "ef"]
StringUtils.splitByWholeSeparator("ab-!-cd-!-ef", "-!-") = ["ab", "cd", "ef"]
//带有限定长度的分隔
StringUtils.splitByWholeSeparator("ab:cd:ef", ":", 2)       = ["ab", "cd:ef"]

1. join(byte[] array,char separator)
2. join(Object[] array,char separator)等方法
3. join(Object[] array,char separator,int startIndex,int endIndex)

//只有一个参数的join，简单合并在一起
StringUtils.join(["a", "b", "c"]) = "abc"
StringUtils.join([null, "", "a"]) = "a"
//null的话，就是把字符合并在一起
StringUtils.join(["a", "b", "c"], null) = "abc"
//从index为0到3合并，注意是排除3的
StringUtils.join([null, "", "a"], ',', 0, 3)   = ",,a"
StringUtils.join(["a", "b", "c"], "--", 0, 3)  = "a--b--c"
//从index为1到3合并，注意是排除3的
StringUtils.join(["a", "b", "c"], "--", 1, 3)  = "b--c"
StringUtils.join(["a", "b", "c"], "--", 2, 3)  = "c"

截取函数

1. substring(String str,int start)
2. substringAfter(String str,String separator)
3. substringBeforeLast(String str,String separator)
4. substringAfterLast(String str,String separator)
5. substringBetween(String str,String tag)

StringUtils.substring("abcdefg", 0)  = "abcdefg"
StringUtils.substring("abcdefg", 2)  = "cdefg"
StringUtils.substring("abcdefg", 4)  = "efg"
//start>0表示从左向右, start<0表示从右向左, start=0则从左第一位开始
StringUtils.substring("abcdefg", -2) = "fg"
StringUtils.substring("abcdefg", -4) = "defg"

//从第二个参数字符串开始截取，排除第二个字符串
StringUtils.substringAfter("abc", "a")   = "bc"
StringUtils.substringAfter("abcba", "b") = "cba"
StringUtils.substringAfter("abc", "c")   = ""

//从最后一个字母出现开始截取
StringUtils.substringBeforeLast("abcba", "b") = "abc"
StringUtils.substringBeforeLast("abc", "c")   = "ab"
StringUtils.substringBeforeLast("a", "a")     = ""
StringUtils.substringBeforeLast("a", "z")     = "a"

StringUtils.substringAfterLast("abc", "a")   = "bc"
StringUtils.substringAfterLast("abcba", "b") = "a"
StringUtils.substringAfterLast("abc", "c")   = ""

StringUtils.substringBetween("tagabctag", null)  = null
StringUtils.substringBetween("tagabctag", "")    = ""
StringUtils.substringBetween("tagabctag", "tag") = "abc"

差异函数

1. difference(String str1,String str2)

//在str1中寻找str2中没有的的字符串，并返回
StringUtils.difference("", "abc") = "abc"
StringUtils.difference("abc", "") = ""
StringUtils.difference("abc", "abc") = ""
StringUtils.difference("abc", "ab") = ""
StringUtils.difference("ab", "abxyz") = "xyz"
StringUtils.difference("abcde", "abxyz") = "xyz"
StringUtils.difference("abcde", "xyz") = "xyz"

删除空白函数

1. trim(String str)
2. trimToEmpty(String str)
3. trimToNull(String str)
4. deleteWhitespace(String str)

 StringUtils.trim(null)          = null
 StringUtils.trim("")            = ""
 StringUtils.trim("     ")       = ""
 StringUtils.trim("abc")         = "abc"
 StringUtils.trim("    abc    ") = "abc"

 StringUtils.trimToEmpty(null)          = ""
 StringUtils.trimToEmpty("")            = ""
 StringUtils.trimToEmpty("     ")       = ""
 StringUtils.trimToEmpty("abc")         = "abc"
 StringUtils.trimToEmpty("    abc    ") = "abc"

 StringUtils.trimToNull(null)          = null
 StringUtils.trimToNull("")            = null
 StringUtils.trimToNull("     ")       = null
 StringUtils.trimToNull("abc")         = "abc"
 StringUtils.trimToNull("    abc    ") = "abc"

判断是否相等函数

1. equals(CharSequence cs1,CharSequence cs2)
2. equalsIgnoreCase(CharSequence str1, CharSequence str2)

StringUtils.equals("abc", null)  = false
StringUtils.equals("abc", "abc") = true
StringUtils.equals("abc", "ABC") = false
//忽略大小写
StringUtils.equalsIgnoreCase("abc", null)  = false
StringUtils.equalsIgnoreCase("abc", "abc") = true
StringUtils.equalsIgnoreCase("abc", "ABC") = true

是否包含函数

• 关键字 contains

 StringUtils.contains(null, *)    = false
 StringUtils.contains("", *)      = false
 StringUtils.contains("abc", 'a') = true
 StringUtils.contains("abc", 'z') = false

 StringUtils.contains(null, *) = false
 StringUtils.contains(*, null) = false
 StringUtils.contains("", "") = true
 StringUtils.contains("abc", "") = true
 StringUtils.contains("abc", "a") = true
 StringUtils.contains("abc", "z") = false
 StringUtils.contains("abc", "A") = true
 StringUtils.contains("abc", "Z") = false

 StringUtils.containsNone(null, *)       = true
 StringUtils.containsNone(*, null)       = true
 StringUtils.containsNone("", *)         = true
 StringUtils.containsNone("ab", '')      = true
 StringUtils.containsNone("abab", 'xyz') = true
 StringUtils.containsNone("ab1", 'xyz')  = true
 StringUtils.containsNone("abz", 'xyz')  = false

 StringUtils.containsAny(null, *)            = false
 StringUtils.containsAny("", *)              = false
 StringUtils.containsAny(*, null)            = false
 StringUtils.containsAny(*, "")              = false
 StringUtils.containsAny("zzabyycdxx", "za") = true
 StringUtils.containsAny("zzabyycdxx", "by") = true
 StringUtils.containsAny("aba","z")          = false

索引下标函数

• 关键字 indexOf

//返回第二个参数开始出现的索引值
StringUtils.indexOf("aabaabaa", "a")  = 0
StringUtils.indexOf("aabaabaa", "b")  = 2
StringUtils.indexOf("aabaabaa", "ab") = 1

//从第三个参数索引开始找起，返回第二个参数开始出现的索引值
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.lastIndexOf("aabaabaa", 'a') = 7
StringUtils.lastIndexOf("aabaabaa", 'b') = 5

StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A", 8)  = 7
StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 8)  = 5
StringUtils.lastIndexOfIgnoreCase("aabaabaa", "AB", 8) = 4
StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 9)  = 5