StringUtil (schedulerX-client 2.1.5 API)

java.lang.Object
- com.alibaba.tmq.client.util.StringUtil

```
public class StringUtil
extends Object
```
有关字符串处理的工具类。这个类中的每个方法都可以“安全”地处理null，而不会抛出NullPointerException。

版本:

$Id: StringUtil.java 1149 2004-08-10 02:01:41Z baobao $

作者:

Michael Zhou

字段概要

字段
限定符和类型字段和说明

static String EMPTY_STRING
空字符串。

字段
限定符和类型	字段和说明
`static String`	`EMPTY_STRING` 空字符串。

构造器概要

构造器
构造器和说明

StringUtil()

构造器
构造器和说明
`StringUtil()`

方法概要

所有方法静态方法具体方法
限定符和类型	方法和说明
`static String`	`abbreviate(String str, int maxWidth)` 将字符串转换成指定长度的缩略，例如：将"Now is the time for all good men"转换成"Now is the time for..."。
`static String`	`abbreviate(String str, int offset, int maxWidth)` 将字符串转换成指定长度的缩略，例如：将"Now is the time for all good men"转换成"...is the time for..."。
`static String`	`alignLeft(String str, int size)` 扩展并左对齐字符串，用空格`' '`填充右边。
`static String`	`alignLeft(String str, int size, char padChar)` 扩展并左对齐字符串，用指定字符填充右边。
`static String`	`alignLeft(String str, int size, String padStr)` 扩展并左对齐字符串，用指定字符串填充右边。
`static String`	`alignRight(String str, int size)` 扩展并右对齐字符串，用空格`' '`填充左边。
`static String`	`alignRight(String str, int size, char padChar)` 扩展并右对齐字符串，用指定字符填充左边。
`static String`	`alignRight(String str, int size, String padStr)` 扩展并右对齐字符串，用指定字符串填充左边。
`static String`	`capitalize(String str)` 将字符串的首字符转成大写（`Character.toTitleCase`），其它字符不变。
`static String`	`center(String str, int size)` 扩展并居中字符串，用空格`' '`填充两边。
`static String`	`center(String str, int size, char padChar)` 扩展并居中字符串，用指定字符填充两边。
`static String`	`center(String str, int size, String padStr)` 扩展并居中字符串，用指定字符串填充两边。
`static String`	`chomp(String str)` 删除字符串末尾的换行符。
`static String`	`chomp(String str, String separator)` 删除字符串末尾的指定字符串。
`static String`	`chop(String str)` 删除最后一个字符。
`static boolean`	`contains(String str, char searchChar)` 检查字符串中是否包含指定的字符。
`static boolean`	`contains(String str, String searchStr)` 检查字符串中是否包含指定的字符串。
`static boolean`	`containsNone(String str, char[] invalid)` 检查字符串是是否不包含指定字符集合中的字符。
`static boolean`	`containsNone(String str, String invalidChars)` 检查字符串是是否不包含指定字符集合中的字符。
`static boolean`	`containsOnly(String str, char[] valid)` 检查字符串是是否只包含指定字符集合中的字符。
`static boolean`	`containsOnly(String str, String valid)` 检查字符串是是否只包含指定字符集合中的字符。
`static int`	`countMatches(String str, String subStr)` 取得指定子串在字符串中出现的次数。
`static String`	`defaultIfBlank(String str)` 如果字符串是空白：`null`、空字符串`""`或只有空白字符，则返回空字符串`""`，否则返回字符串本身。
`static String`	`defaultIfBlank(String str, String defaultStr)` 如果字符串是`null`或空字符串`""`，则返回指定默认字符串，否则返回字符串本身。
`static String`	`defaultIfEmpty(String str)` 如果字符串是`null`或空字符串`""`，则返回空字符串`""`，否则返回字符串本身。
`static String`	`defaultIfEmpty(String str, String defaultStr)` 如果字符串是`null`或空字符串`""`，则返回指定默认字符串，否则返回字符串本身。
`static String`	`defaultIfNull(String str)` 如果字符串是`null`，则返回空字符串`""`，否则返回字符串本身。
`static String`	`defaultIfNull(String str, String defaultStr)` 如果字符串是`null`，则返回指定默认字符串，否则返回字符串本身。
`static String`	`deleteWhitespace(String str)` 删除所有在`Character.isWhitespace(char)`中所定义的空白。
`static String`	`difference(String str1, String str2)` 比较两个字符串，取得第二个字符串中，和第一个字符串不同的部分。
`static boolean`	`equals(String str1, String str2)` 比较两个字符串（大小写敏感）。
`static boolean`	`equalsIgnoreCase(String str1, String str2)` 比较两个字符串（大小写不敏感）。
`static int`	`getLevenshteinDistance(String s, String t)` 取得两个字符串的相似度，`0`代表字符串相等，数字越大表示字符串越不像。
`static int`	`indexOf(String str, char searchChar)` 在字符串中查找指定字符，并返回第一个匹配的索引值。
`static int`	`indexOf(String str, char searchChar, int startPos)` 在字符串中查找指定字符，并返回第一个匹配的索引值。
`static int`	`indexOf(String str, String searchStr)` 在字符串中查找指定字符串，并返回第一个匹配的索引值。
`static int`	`indexOf(String str, String searchStr, int startPos)` 在字符串中查找指定字符串，并返回第一个匹配的索引值。
`static int`	`indexOfAny(String str, char[] searchChars)` 在字符串中查找指定字符集合中的字符，并返回第一个匹配的起始索引。
`static int`	`indexOfAny(String str, String searchChars)` 在字符串中查找指定字符集合中的字符，并返回第一个匹配的起始索引。
`static int`	`indexOfAny(String str, String[] searchStrs)` 在字符串中查找指定字符串集合中的字符串，并返回第一个匹配的起始索引。
`static int`	`indexOfAnyBut(String str, char[] searchChars)` 在字符串中查找不在指定字符集合中的字符，并返回第一个匹配的起始索引。
`static int`	`indexOfAnyBut(String str, String searchChars)` 在字符串中查找不在指定字符集合中的字符，并返回第一个匹配的起始索引。
`static int`	`indexOfDifference(String str1, String str2)` 比较两个字符串，取得两字符串开始不同的索引值。
`static boolean`	`isAlpha(String str)` 判断字符串是否只包含unicode字母。
`static boolean`	`isAlphanumeric(String str)` 判断字符串是否只包含unicode字母和数字。
`static boolean`	`isAlphanumericSpace(String str)` 判断字符串是否只包含unicode字母数字和空格`' '`。
`static boolean`	`isAlphaSpace(String str)` 判断字符串是否只包含unicode字母和空格`' '`。
`static boolean`	`isBlank(String str)` 检查字符串是否是空白：`null`、空字符串`""`或只有空白字符。
`static boolean`	`isEmpty(String str)` 检查字符串是否为`null`或空字符串`""`。
`static boolean`	`isNotBlank(String str)` 检查字符串是否不是空白：`null`、空字符串`""`或只有空白字符。
`static boolean`	`isNotEmpty(String str)` 检查字符串是否不是`null`和空字符串`""`。
`static boolean`	`isNumeric(String str)` 判断字符串是否只包含unicode数字。
`static boolean`	`isNumericSpace(String str)` 判断字符串是否只包含unicode数字和空格`' '`。
`static boolean`	`isWhitespace(String str)` 判断字符串是否只包含unicode空白。
`static String`	`join(Iterator iterator, char separator)` 将`Iterator`中的元素连接成一个字符串。
`static String`	`join(Iterator iterator, String separator)` 将`Iterator`中的元素连接成一个字符串。
`static String`	`join(Object[] array)` 将数组中的元素连接成一个字符串。
`static String`	`join(Object[] array, char separator)` 将数组中的元素连接成一个字符串。
`static String`	`join(Object[] array, String separator)` 将数组中的元素连接成一个字符串。
`static int`	`lastIndexOf(String str, char searchChar)` 从字符串尾部开始查找指定字符，并返回第一个匹配的索引值。
`static int`	`lastIndexOf(String str, char searchChar, int startPos)` 从字符串尾部开始查找指定字符，并返回第一个匹配的索引值。
`static int`	`lastIndexOf(String str, String searchStr)` 从字符串尾部开始查找指定字符串，并返回第一个匹配的索引值。
`static int`	`lastIndexOf(String str, String searchStr, int startPos)` 从字符串尾部开始查找指定字符串，并返回第一个匹配的索引值。
`static int`	`lastIndexOfAny(String str, String[] searchStrs)` 从字符串尾部开始查找指定字符串集合中的字符串，并返回第一个匹配的起始索引。
`static String`	`left(String str, int len)` 取得长度为指定字符数的最左边的子串。
`static String`	`mid(String str, int pos, int len)` 取得从指定索引开始计算的、长度为指定字符数的子串。
`static String`	`overlay(String str, String overlay, int start, int end)` 将指定的子串用另一指定子串覆盖。
`static String`	`repeat(String str, int repeat)` 将指定字符串重复n遍。
`static String`	`replace(String text, String repl, String with)` 替换指定的子串，替换所有出现的子串。
`static String`	`replace(String text, String repl, String with, int max)` 替换指定的子串，替换指定的次数。
`static String`	`replaceChars(String str, char searchChar, char replaceChar)` 将字符串中所有指定的字符，替换成另一个。
`static String`	`replaceChars(String str, String searchChars, String replaceChars)` 将字符串中所有指定的字符，替换成另一个。
`static String`	`replaceOnce(String text, String repl, String with)` 替换指定的子串，只替换第一个出现的子串。
`static String`	`reverse(String str)` 反转字符串中的字符顺序。
`static String`	`reverseDelimited(String str, char separatorChar)` 反转指定分隔符分隔的各子串的顺序。
`static String`	`reverseDelimited(String str, String separatorChars, String separator)` 反转指定分隔符分隔的各子串的顺序。
`static String`	`right(String str, int len)` 取得长度为指定字符数的最右边的子串。
`static String[]`	`split(String str)` 将字符串按空白字符分割。
`static String[]`	`split(String str, char separatorChar)` 将字符串按指定字符分割。
`static String[]`	`split(String str, String separatorChars)` 将字符串按指定字符分割。
`static String[]`	`split(String str, String separatorChars, int max)` 将字符串按指定字符分割。
`static String`	`substring(String str, int start)` 取指定字符串的子串。
`static String`	`substring(String str, int start, int end)` 取指定字符串的子串。
`static String`	`substringAfter(String str, String separator)` 取得第一个出现的分隔子串之后的子串。
`static String`	`substringAfterLast(String str, String separator)` 取得最后一个的分隔子串之后的子串。
`static String`	`substringBefore(String str, String separator)` 取得第一个出现的分隔子串之前的子串。
`static String`	`substringBeforeLast(String str, String separator)` 取得最后一个的分隔子串之前的子串。
`static String`	`substringBetween(String str, String tag)` 取得指定分隔符的前两次出现之间的子串。
`static String`	`substringBetween(String str, String open, String close)` 取得两个分隔符之间的子串。
`static String`	`substringBetween(String str, String open, String close, int fromIndex)` 取得两个分隔符之间的子串。
`static String`	`swapCase(String str)` 反转字符串的大小写。
`static String`	`toCamelCase(String str)` 将字符串转换成camel case。
`static String`	`toLowerCase(String str)` 将字符串转换成小写。
`static String`	`toLowerCaseWithUnderscores(String str)` 将字符串转换成下划线分隔的小写字符串。
`static String`	`toPascalCase(String str)` 将字符串转换成pascal case。
`static String`	`toUpperCase(String str)` 将字符串转换成大写。
`static String`	`toUpperCaseWithUnderscores(String str)` 将字符串转换成下划线分隔的大写字符串。
`static String`	`trim(String str)` 除去字符串头尾部的空白，如果字符串是`null`，依然返回`null`。
`static String`	`trim(String str, String stripChars)` 除去字符串头尾部的指定字符，如果字符串是`null`，依然返回`null`。
`static String`	`trimEnd(String str)` 除去字符串尾部的空白，如果字符串是`null`，则返回`null`。
`static String`	`trimEnd(String str, String stripChars)` 除去字符串尾部的指定字符，如果字符串是`null`，依然返回`null`。
`static String`	`trimStart(String str)` 除去字符串头部的空白，如果字符串是`null`，则返回`null`。
`static String`	`trimStart(String str, String stripChars)` 除去字符串头部的指定字符，如果字符串是`null`，依然返回`null`。
`static String`	`trimToEmpty(String str)` 除去字符串头尾部的空白，如果字符串是`null`，则返回空字符串`""`。
`static String`	`trimToEmpty(String str, String stripChars)` 除去字符串头尾部的空白，如果字符串是`null`，则返回空字符串`""`。
`static String`	`trimToNull(String str)` 除去字符串头尾部的空白，如果结果字符串是空字符串`""`，则返回`null`。
`static String`	`trimToNull(String str, String stripChars)` 除去字符串头尾部的空白，如果结果字符串是空字符串`""`，则返回`null`。
`static String`	`uncapitalize(String str)` 将字符串的首字符转成小写，其它字符不变。

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

字段详细资料
- EMPTY_STRING
```
public static final String EMPTY_STRING
```
  空字符串。
  
  另请参阅:
  
  常量字段值

构造器详细资料
- StringUtil
```
public StringUtil()
```

方法详细资料

isEmpty

public static boolean isEmpty(String str)

检查字符串是否为null或空字符串""。

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

str 要检查的字符串如果为空, 则返回true

isNotEmpty

public static boolean isNotEmpty(String str)

检查字符串是否不是null和空字符串""。

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

str 要检查的字符串如果不为空, 则返回true

isBlank

public static boolean isBlank(String str)

检查字符串是否是空白：null、空字符串""或只有空白字符。

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

str 要检查的字符串如果为空白, 则返回true

isNotBlank

public static boolean isNotBlank(String str)

检查字符串是否不是空白：null、空字符串""或只有空白字符。

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

str 要检查的字符串如果为空白, 则返回true

defaultIfNull

public static String defaultIfNull(String str)

如果字符串是null，则返回空字符串""，否则返回字符串本身。

 StringUtil.defaultIfNull(null)  = ""
 StringUtil.defaultIfNull("")    = ""
 StringUtil.defaultIfNull("  ")  = "  "
 StringUtil.defaultIfNull("bat") = "bat"

str 要转换的字符串字符串本身或空字符串""

defaultIfNull

public static String defaultIfNull(String str,
                                   String defaultStr)

如果字符串是null，则返回指定默认字符串，否则返回字符串本身。

 StringUtil.defaultIfNull(null, "default")  = "default"
 StringUtil.defaultIfNull("", "default")    = ""
 StringUtil.defaultIfNull("  ", "default")  = "  "
 StringUtil.defaultIfNull("bat", "default") = "bat"

str 要转换的字符串 defaultStr 默认字符串字符串本身或指定的默认字符串

defaultIfEmpty
```
public static String defaultIfEmpty(String str)
```
如果字符串是null或空字符串""，则返回空字符串""，否则返回字符串本身。此方法实际上和defaultIfNull(String)等效。
```
 StringUtil.defaultIfEmpty(null)  = ""
 StringUtil.defaultIfEmpty("")    = ""
 StringUtil.defaultIfEmpty("  ")  = "  "
 StringUtil.defaultIfEmpty("bat") = "bat"
 
```
str 要转换的字符串字符串本身或空字符串""

defaultIfEmpty

public static String defaultIfEmpty(String str,
                                    String defaultStr)

如果字符串是null或空字符串""，则返回指定默认字符串，否则返回字符串本身。

 StringUtil.defaultIfEmpty(null, "default")  = "default"
 StringUtil.defaultIfEmpty("", "default")    = "default"
 StringUtil.defaultIfEmpty("  ", "default")  = "  "
 StringUtil.defaultIfEmpty("bat", "default") = "bat"

str 要转换的字符串 defaultStr 默认字符串字符串本身或指定的默认字符串

defaultIfBlank

public static String defaultIfBlank(String str)

如果字符串是空白：null、空字符串""或只有空白字符，则返回空字符串""，否则返回字符串本身。

 StringUtil.defaultIfBlank(null)  = ""
 StringUtil.defaultIfBlank("")    = ""
 StringUtil.defaultIfBlank("  ")  = ""
 StringUtil.defaultIfBlank("bat") = "bat"

str 要转换的字符串字符串本身或空字符串""

defaultIfBlank

public static String defaultIfBlank(String str,
                                    String defaultStr)

如果字符串是null或空字符串""，则返回指定默认字符串，否则返回字符串本身。

 StringUtil.defaultIfBlank(null, "default")  = "default"
 StringUtil.defaultIfBlank("", "default")    = "default"
 StringUtil.defaultIfBlank("  ", "default")  = "default"
 StringUtil.defaultIfBlank("bat", "default") = "bat"

str 要转换的字符串 defaultStr 默认字符串字符串本身或指定的默认字符串

trim
```
public static String trim(String str)
```
除去字符串头尾部的空白，如果字符串是null，依然返回null。注意，和String.trim不同，此方法使用Character.isWhitespace来判定空白，因而可以除去英文字符集之外的其它空白，如中文空格。
```
 StringUtil.trim(null)          = null
 StringUtil.trim("")            = ""
 StringUtil.trim("     ")       = ""
 StringUtil.trim("abc")         = "abc"
 StringUtil.trim("    abc    ") = "abc"
 
```
str 要处理的字符串除去空白的字符串，如果原字串为null，则返回null

trim

public static String trim(String str,
                          String stripChars)

除去字符串头尾部的指定字符，如果字符串是null，依然返回null。

 StringUtil.trim(null, *)          = null
 StringUtil.trim("", *)            = ""
 StringUtil.trim("abc", null)      = "abc"
 StringUtil.trim("  abc", null)    = "abc"
 StringUtil.trim("abc  ", null)    = "abc"
 StringUtil.trim(" abc ", null)    = "abc"
 StringUtil.trim("  abcyx", "xyz") = "  abc"

str 要处理的字符串 stripChars 要除去的字符，如果为null表示除去空白字符除去指定字符后的的字符串，如果原字串为null，则返回null

trimStart
```
public static String trimStart(String str)
```
除去字符串头部的空白，如果字符串是null，则返回null。注意，和String.trim不同，此方法使用Character.isWhitespace来判定空白，因而可以除去英文字符集之外的其它空白，如中文空格。
```
 StringUtil.trimStart(null)         = null
 StringUtil.trimStart("")           = ""
 StringUtil.trimStart("abc")        = "abc"
 StringUtil.trimStart("  abc")      = "abc"
 StringUtil.trimStart("abc  ")      = "abc  "
 StringUtil.trimStart(" abc ")      = "abc "
 
```
str 要处理的字符串除去空白的字符串，如果原字串为null或结果字符串为""，则返回null

trimStart

public static String trimStart(String str,
                               String stripChars)

除去字符串头部的指定字符，如果字符串是null，依然返回null。

 StringUtil.trimStart(null, *)          = null
 StringUtil.trimStart("", *)            = ""
 StringUtil.trimStart("abc", "")        = "abc"
 StringUtil.trimStart("abc", null)      = "abc"
 StringUtil.trimStart("  abc", null)    = "abc"
 StringUtil.trimStart("abc  ", null)    = "abc  "
 StringUtil.trimStart(" abc ", null)    = "abc "
 StringUtil.trimStart("yxabc  ", "xyz") = "abc  "

str 要处理的字符串 stripChars 要除去的字符，如果为null表示除去空白字符除去指定字符后的的字符串，如果原字串为null，则返回null

trimEnd
```
public static String trimEnd(String str)
```
除去字符串尾部的空白，如果字符串是null，则返回null。注意，和String.trim不同，此方法使用Character.isWhitespace来判定空白，因而可以除去英文字符集之外的其它空白，如中文空格。
```
 StringUtil.trimEnd(null)       = null
 StringUtil.trimEnd("")         = ""
 StringUtil.trimEnd("abc")      = "abc"
 StringUtil.trimEnd("  abc")    = "  abc"
 StringUtil.trimEnd("abc  ")    = "abc"
 StringUtil.trimEnd(" abc ")    = " abc"
 
```
str 要处理的字符串除去空白的字符串，如果原字串为null或结果字符串为""，则返回null

trimEnd

public static String trimEnd(String str,
                             String stripChars)

除去字符串尾部的指定字符，如果字符串是null，依然返回null。

 StringUtil.trimEnd(null, *)          = null
 StringUtil.trimEnd("", *)            = ""
 StringUtil.trimEnd("abc", "")        = "abc"
 StringUtil.trimEnd("abc", null)      = "abc"
 StringUtil.trimEnd("  abc", null)    = "  abc"
 StringUtil.trimEnd("abc  ", null)    = "abc"
 StringUtil.trimEnd(" abc ", null)    = " abc"
 StringUtil.trimEnd("  abcyx", "xyz") = "  abc"

str 要处理的字符串 stripChars 要除去的字符，如果为null表示除去空白字符除去指定字符后的的字符串，如果原字串为null，则返回null

trimToNull
```
public static String trimToNull(String str)
```
除去字符串头尾部的空白，如果结果字符串是空字符串""，则返回null。注意，和String.trim不同，此方法使用Character.isWhitespace来判定空白，因而可以除去英文字符集之外的其它空白，如中文空格。
```
 StringUtil.trimToNull(null)          = null
 StringUtil.trimToNull("")            = null
 StringUtil.trimToNull("     ")       = null
 StringUtil.trimToNull("abc")         = "abc"
 StringUtil.trimToNull("    abc    ") = "abc"
 
```
str 要处理的字符串除去空白的字符串，如果原字串为null或结果字符串为""，则返回null

trimToNull
```
public static String trimToNull(String str,
                                String stripChars)
```
除去字符串头尾部的空白，如果结果字符串是空字符串""，则返回null。注意，和String.trim不同，此方法使用Character.isWhitespace来判定空白，因而可以除去英文字符集之外的其它空白，如中文空格。
```
 StringUtil.trim(null, *)          = null
 StringUtil.trim("", *)            = null
 StringUtil.trim("abc", null)      = "abc"
 StringUtil.trim("  abc", null)    = "abc"
 StringUtil.trim("abc  ", null)    = "abc"
 StringUtil.trim(" abc ", null)    = "abc"
 StringUtil.trim("  abcyx", "xyz") = "  abc"
 
```
str 要处理的字符串 stripChars 要除去的字符，如果为null表示除去空白字符除去空白的字符串，如果原字串为null或结果字符串为""，则返回null

trimToEmpty
```
public static String trimToEmpty(String str)
```
除去字符串头尾部的空白，如果字符串是null，则返回空字符串""。注意，和String.trim不同，此方法使用Character.isWhitespace来判定空白，因而可以除去英文字符集之外的其它空白，如中文空格。
```
 StringUtil.trimToEmpty(null)          = ""
 StringUtil.trimToEmpty("")            = ""
 StringUtil.trimToEmpty("     ")       = ""
 StringUtil.trimToEmpty("abc")         = "abc"
 StringUtil.trimToEmpty("    abc    ") = "abc"
 
```
str 要处理的字符串除去空白的字符串，如果原字串为null或结果字符串为""，则返回null

trimToEmpty

public static String trimToEmpty(String str,
                                 String stripChars)

除去字符串头尾部的空白，如果字符串是null，则返回空字符串""。注意，和String.trim不同，此方法使用Character.isWhitespace来判定空白，因而可以除去英文字符集之外的其它空白，如中文空格。

 StringUtil.trim(null, *)          = ""
 StringUtil.trim("", *)            = ""
 StringUtil.trim("abc", null)      = "abc"
 StringUtil.trim("  abc", null)    = "abc"
 StringUtil.trim("abc  ", null)    = "abc"
 StringUtil.trim(" abc ", null)    = "abc"
 StringUtil.trim("  abcyx", "xyz") = "  abc"

str 要处理的字符串除去空白的字符串，如果原字串为null或结果字符串为""，则返回null

equals

public static boolean equals(String str1,
                             String str2)

比较两个字符串（大小写敏感）。

 StringUtil.equals(null, null)   = true
 StringUtil.equals(null, "abc")  = false
 StringUtil.equals("abc", null)  = false
 StringUtil.equals("abc", "abc") = true
 StringUtil.equals("abc", "ABC") = false

str1 要比较的字符串1 str2 要比较的字符串2 如果两个字符串相同，或者都是null，则返回true

equalsIgnoreCase

public static boolean equalsIgnoreCase(String str1,
                                       String str2)

比较两个字符串（大小写不敏感）。

 StringUtil.equalsIgnoreCase(null, null)   = true
 StringUtil.equalsIgnoreCase(null, "abc")  = false
 StringUtil.equalsIgnoreCase("abc", null)  = false
 StringUtil.equalsIgnoreCase("abc", "abc") = true
 StringUtil.equalsIgnoreCase("abc", "ABC") = true

str1 要比较的字符串1 str2 要比较的字符串2 如果两个字符串相同，或者都是null，则返回true

isAlpha

public static boolean isAlpha(String str)

判断字符串是否只包含unicode字母。 null将返回false，空字符串""将返回true。

 StringUtil.isAlpha(null)   = false
 StringUtil.isAlpha("")     = true
 StringUtil.isAlpha("  ")   = false
 StringUtil.isAlpha("abc")  = true
 StringUtil.isAlpha("ab2c") = false
 StringUtil.isAlpha("ab-c") = false

str 要检查的字符串如果字符串非null并且全由unicode字母组成，则返回true

isAlphaSpace

public static boolean isAlphaSpace(String str)

判断字符串是否只包含unicode字母和空格' '。 null将返回false，空字符串""将返回true。

 StringUtil.isAlphaSpace(null)   = false
 StringUtil.isAlphaSpace("")     = true
 StringUtil.isAlphaSpace("  ")   = true
 StringUtil.isAlphaSpace("abc")  = true
 StringUtil.isAlphaSpace("ab c") = true
 StringUtil.isAlphaSpace("ab2c") = false
 StringUtil.isAlphaSpace("ab-c") = false

str 要检查的字符串如果字符串非null并且全由unicode字母和空格组成，则返回true

isAlphanumeric

public static boolean isAlphanumeric(String str)

判断字符串是否只包含unicode字母和数字。 null将返回false，空字符串""将返回true。

 StringUtil.isAlphanumeric(null)   = false
 StringUtil.isAlphanumeric("")     = true
 StringUtil.isAlphanumeric("  ")   = false
 StringUtil.isAlphanumeric("abc")  = true
 StringUtil.isAlphanumeric("ab c") = false
 StringUtil.isAlphanumeric("ab2c") = true
 StringUtil.isAlphanumeric("ab-c") = false

str 要检查的字符串如果字符串非null并且全由unicode字母数字组成，则返回true

isAlphanumericSpace

public static boolean isAlphanumericSpace(String str)

判断字符串是否只包含unicode字母数字和空格' '。 null将返回false，空字符串""将返回true。

 StringUtil.isAlphanumericSpace(null)   = false
 StringUtil.isAlphanumericSpace("")     = true
 StringUtil.isAlphanumericSpace("  ")   = true
 StringUtil.isAlphanumericSpace("abc")  = true
 StringUtil.isAlphanumericSpace("ab c") = true
 StringUtil.isAlphanumericSpace("ab2c") = true
 StringUtil.isAlphanumericSpace("ab-c") = false

str 要检查的字符串如果字符串非null并且全由unicode字母数字和空格组成，则返回true

isNumeric

public static boolean isNumeric(String str)

判断字符串是否只包含unicode数字。 null将返回false，空字符串""将返回true。

 StringUtil.isNumeric(null)   = false
 StringUtil.isNumeric("")     = true
 StringUtil.isNumeric("  ")   = false
 StringUtil.isNumeric("123")  = true
 StringUtil.isNumeric("12 3") = false
 StringUtil.isNumeric("ab2c") = false
 StringUtil.isNumeric("12-3") = false
 StringUtil.isNumeric("12.3") = false

str 要检查的字符串如果字符串非null并且全由unicode数字组成，则返回true

isNumericSpace

public static boolean isNumericSpace(String str)

判断字符串是否只包含unicode数字和空格' '。 null将返回false，空字符串""将返回true。

 StringUtil.isNumericSpace(null)   = false
 StringUtil.isNumericSpace("")     = true
 StringUtil.isNumericSpace("  ")   = true
 StringUtil.isNumericSpace("123")  = true
 StringUtil.isNumericSpace("12 3") = true
 StringUtil.isNumericSpace("ab2c") = false
 StringUtil.isNumericSpace("12-3") = false
 StringUtil.isNumericSpace("12.3") = false

str 要检查的字符串如果字符串非null并且全由unicode数字和空格组成，则返回true

isWhitespace

public static boolean isWhitespace(String str)

判断字符串是否只包含unicode空白。 null将返回false，空字符串""将返回true。

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

str 要检查的字符串如果字符串非null并且全由unicode空白组成，则返回true

toUpperCase

public static String toUpperCase(String str)

将字符串转换成大写。如果字符串是null则返回null。

 StringUtil.toUpperCase(null)  = null
 StringUtil.toUpperCase("")    = ""
 StringUtil.toUpperCase("aBc") = "ABC"

str 要转换的字符串大写字符串，如果原字符串为null，则返回null

toLowerCase

public static String toLowerCase(String str)

将字符串转换成小写。如果字符串是null则返回null。

 StringUtil.toLowerCase(null)  = null
 StringUtil.toLowerCase("")    = ""
 StringUtil.toLowerCase("aBc") = "abc"

str 要转换的字符串大写字符串，如果原字符串为null，则返回null

capitalize
```
public static String capitalize(String str)
```
将字符串的首字符转成大写（Character.toTitleCase），其它字符不变。如果字符串是null则返回null。
```
 StringUtil.capitalize(null)  = null
 StringUtil.capitalize("")    = ""
 StringUtil.capitalize("cat") = "Cat"
 StringUtil.capitalize("cAt") = "CAt"
 
```
str 要转换的字符串首字符为大写的字符串，如果原字符串为null，则返回null

uncapitalize
```
public static String uncapitalize(String str)
```
将字符串的首字符转成小写，其它字符不变。如果字符串是null则返回null。
```
 StringUtil.uncapitalize(null)  = null
 StringUtil.uncapitalize("")    = ""
 StringUtil.uncapitalize("Cat") = "cat"
 StringUtil.uncapitalize("CAT") = "cAT"
 
```
str 要转换的字符串首字符为小写的字符串，如果原字符串为null，则返回null

swapCase

public static String swapCase(String str)

反转字符串的大小写。如果字符串是null则返回null。

 StringUtil.swapCase(null)                 = null
 StringUtil.swapCase("")                   = ""
 StringUtil.swapCase("The dog has a BONE") = "tHE DOG HAS A bone"

str 要转换的字符串大小写被反转的字符串，如果原字符串为null，则返回null

toCamelCase

public static String toCamelCase(String str)

将字符串转换成camel case。如果字符串是null则返回null。

 StringUtil.toCamelCase(null)  = null
 StringUtil.toCamelCase("")    = ""
 StringUtil.toCamelCase("aBc") = "aBc"
 StringUtil.toCamelCase("aBc def") = "aBcDef"
 StringUtil.toCamelCase("aBc def_ghi") = "aBcDefGhi"
 StringUtil.toCamelCase("aBc def_ghi 123") = "aBcDefGhi123"

此方法会保留除了下划线和空白以外的所有分隔符。 str 要转换的字符串 camel case字符串，如果原字符串为null，则返回null

toPascalCase

public static String toPascalCase(String str)

将字符串转换成pascal case。如果字符串是null则返回null。

 StringUtil.toPascalCase(null)  = null
 StringUtil.toPascalCase("")    = ""
 StringUtil.toPascalCase("aBc") = "ABc"
 StringUtil.toPascalCase("aBc def") = "ABcDef"
 StringUtil.toPascalCase("aBc def_ghi") = "ABcDefGhi"
 StringUtil.toPascalCase("aBc def_ghi 123") = "aBcDefGhi123"

此方法会保留除了下划线和空白以外的所有分隔符。 str 要转换的字符串 pascal case字符串，如果原字符串为null，则返回null

toUpperCaseWithUnderscores

public static String toUpperCaseWithUnderscores(String str)

将字符串转换成下划线分隔的大写字符串。如果字符串是null则返回null。

 StringUtil.toUpperCaseWithUnderscores(null)  = null
 StringUtil.toUpperCaseWithUnderscores("")    = ""
 StringUtil.toUpperCaseWithUnderscores("aBc") = "A_BC"
 StringUtil.toUpperCaseWithUnderscores("aBc def") = "A_BC_DEF"
 StringUtil.toUpperCaseWithUnderscores("aBc def_ghi") = "A_BC_DEF_GHI"
 StringUtil.toUpperCaseWithUnderscores("aBc def_ghi 123") = "A_BC_DEF_GHI_123"
 StringUtil.toUpperCaseWithUnderscores("__a__Bc__") = "__A__BC__"

此方法会保留除了空白以外的所有分隔符。 str 要转换的字符串下划线分隔的大写字符串，如果原字符串为null，则返回null

toLowerCaseWithUnderscores

public static String toLowerCaseWithUnderscores(String str)

将字符串转换成下划线分隔的小写字符串。如果字符串是null则返回null。

 StringUtil.toLowerCaseWithUnderscores(null)  = null
 StringUtil.toLowerCaseWithUnderscores("")    = ""
 StringUtil.toLowerCaseWithUnderscores("aBc") = "a_bc"
 StringUtil.toLowerCaseWithUnderscores("aBc def") = "a_bc_def"
 StringUtil.toLowerCaseWithUnderscores("aBc def_ghi") = "a_bc_def_ghi"
 StringUtil.toLowerCaseWithUnderscores("aBc def_ghi 123") = "a_bc_def_ghi_123"
 StringUtil.toLowerCaseWithUnderscores("__a__Bc__") = "__a__bc__"

此方法会保留除了空白以外的所有分隔符。 str 要转换的字符串下划线分隔的小写字符串，如果原字符串为null，则返回null

split
```
public static String[] split(String str)
```
将字符串按空白字符分割。分隔符不会出现在目标数组中，连续的分隔符就被看作一个。如果字符串为null，则返回null。
```
 StringUtil.split(null)       = null
 StringUtil.split("")         = []
 StringUtil.split("abc def")  = ["abc", "def"]
 StringUtil.split("abc  def") = ["abc", "def"]
 StringUtil.split(" abc ")    = ["abc"]
 
```
str 要分割的字符串分割后的字符串数组，如果原字符串为null，则返回null

split

public static String[] split(String str,
                             char separatorChar)

将字符串按指定字符分割。分隔符不会出现在目标数组中，连续的分隔符就被看作一个。如果字符串为null，则返回null。

 StringUtil.split(null, *)         = null
 StringUtil.split("", *)           = []
 StringUtil.split("a.b.c", '.')    = ["a", "b", "c"]
 StringUtil.split("a..b.c", '.')   = ["a", "b", "c"]
 StringUtil.split("a:b:c", '.')    = ["a:b:c"]
 StringUtil.split("a b c", ' ')    = ["a", "b", "c"]

str 要分割的字符串 separatorChar 分隔符分割后的字符串数组，如果原字符串为null，则返回null

split

public static String[] split(String str,
                             String separatorChars)

将字符串按指定字符分割。分隔符不会出现在目标数组中，连续的分隔符就被看作一个。如果字符串为null，则返回null。

 StringUtil.split(null, *)                = null
 StringUtil.split("", *)                  = []
 StringUtil.split("abc def", null)        = ["abc", "def"]
 StringUtil.split("abc def", " ")         = ["abc", "def"]
 StringUtil.split("abc  def", " ")        = ["abc", "def"]
 StringUtil.split(" ab:  cd::ef  ", ":")  = ["ab", "cd", "ef"]
 StringUtil.split("abc.def", "")          = ["abc.def"]

str 要分割的字符串 separatorChars 分隔符分割后的字符串数组，如果原字符串为null，则返回null

split

public static String[] split(String str,
                             String separatorChars,
                             int max)

将字符串按指定字符分割。分隔符不会出现在目标数组中，连续的分隔符就被看作一个。如果字符串为null，则返回null。

 StringUtil.split(null, *, *)                 = null
 StringUtil.split("", *, *)                   = []
 StringUtil.split("ab cd ef", null, 0)        = ["ab", "cd", "ef"]
 StringUtil.split("  ab   cd ef  ", null, 0)  = ["ab", "cd", "ef"]
 StringUtil.split("ab:cd::ef", ":", 0)        = ["ab", "cd", "ef"]
 StringUtil.split("ab:cd:ef", ":", 2)         = ["ab", "cdef"]
 StringUtil.split("abc.def", "", 2)           = ["abc.def"]

str 要分割的字符串 separatorChars 分隔符 max 返回的数组的最大个数，如果小于等于0，则表示无限制分割后的字符串数组，如果原字符串为null，则返回null

join

public static String join(Object[] array)

将数组中的元素连接成一个字符串。

 StringUtil.join(null)            = null
 StringUtil.join([])              = ""
 StringUtil.join([null])          = ""
 StringUtil.join(["a", "b", "c"]) = "abc"
 StringUtil.join([null, "", "a"]) = "a"

array 要连接的数组连接后的字符串，如果原数组为null，则返回null

join

public static String join(Object[] array,
                          char separator)

将数组中的元素连接成一个字符串。

 StringUtil.join(null, *)               = null
 StringUtil.join([], *)                 = ""
 StringUtil.join([null], *)             = ""
 StringUtil.join(["a", "b", "c"], ';')  = "a;b;c"
 StringUtil.join(["a", "b", "c"], null) = "abc"
 StringUtil.join([null, "", "a"], ';')  = ";;a"

array 要连接的数组 separator 分隔符连接后的字符串，如果原数组为null，则返回null

join

public static String join(Object[] array,
                          String separator)

将数组中的元素连接成一个字符串。

 StringUtil.join(null, *)                = null
 StringUtil.join([], *)                  = ""
 StringUtil.join([null], *)              = ""
 StringUtil.join(["a", "b", "c"], "--")  = "a--b--c"
 StringUtil.join(["a", "b", "c"], null)  = "abc"
 StringUtil.join(["a", "b", "c"], "")    = "abc"
 StringUtil.join([null, "", "a"], ',')   = ",,a"

array 要连接的数组 separator 分隔符连接后的字符串，如果原数组为null，则返回null

join

public static String join(Iterator iterator,
                          char separator)

将Iterator中的元素连接成一个字符串。

 StringUtil.join(null, *)                = null
 StringUtil.join([], *)                  = ""
 StringUtil.join([null], *)              = ""
 StringUtil.join(["a", "b", "c"], "--")  = "a--b--c"
 StringUtil.join(["a", "b", "c"], null)  = "abc"
 StringUtil.join(["a", "b", "c"], "")    = "abc"
 StringUtil.join([null, "", "a"], ',')   = ",,a"

iterator 要连接的Iterator separator 分隔符连接后的字符串，如果原数组为null，则返回null

join

public static String join(Iterator iterator,
                          String separator)

将Iterator中的元素连接成一个字符串。

 StringUtil.join(null, *)                = null
 StringUtil.join([], *)                  = ""
 StringUtil.join([null], *)              = ""
 StringUtil.join(["a", "b", "c"], "--")  = "a--b--c"
 StringUtil.join(["a", "b", "c"], null)  = "abc"
 StringUtil.join(["a", "b", "c"], "")    = "abc"
 StringUtil.join([null, "", "a"], ',')   = ",,a"

iterator 要连接的Iterator separator 分隔符连接后的字符串，如果原数组为null，则返回null

indexOf
```
public static int indexOf(String str,
                          char searchChar)
```
在字符串中查找指定字符，并返回第一个匹配的索引值。如果字符串为null或未找到，则返回-1。
```
 StringUtil.indexOf(null, *)         = -1
 StringUtil.indexOf("", *)           = -1
 StringUtil.indexOf("aabaabaa", 'a') = 0
 StringUtil.indexOf("aabaabaa", 'b') = 2
 
```
str 要扫描的字符串 searchChar 要查找的字符第一个匹配的索引值。如果字符串为null或未找到，则返回-1

indexOf

public static int indexOf(String str,
                          char searchChar,
                          int startPos)

在字符串中查找指定字符，并返回第一个匹配的索引值。如果字符串为null或未找到，则返回-1。

 StringUtil.indexOf(null, *, *)          = -1
 StringUtil.indexOf("", *, *)            = -1
 StringUtil.indexOf("aabaabaa", 'b', 0)  = 2
 StringUtil.indexOf("aabaabaa", 'b', 3)  = 5
 StringUtil.indexOf("aabaabaa", 'b', 9)  = -1
 StringUtil.indexOf("aabaabaa", 'b', -1) = 2

str 要扫描的字符串 searchChar 要查找的字符 startPos 开始搜索的索引值，如果小于0，则看作0 第一个匹配的索引值。如果字符串为null或未找到，则返回-1

indexOf

public static int indexOf(String str,
                          String searchStr)

在字符串中查找指定字符串，并返回第一个匹配的索引值。如果字符串为null或未找到，则返回-1。

 StringUtil.indexOf(null, *)          = -1
 StringUtil.indexOf(*, null)          = -1
 StringUtil.indexOf("", "")           = 0
 StringUtil.indexOf("aabaabaa", "a")  = 0
 StringUtil.indexOf("aabaabaa", "b")  = 2
 StringUtil.indexOf("aabaabaa", "ab") = 1
 StringUtil.indexOf("aabaabaa", "")   = 0

str 要扫描的字符串 searchStr 要查找的字符串第一个匹配的索引值。如果字符串为null或未找到，则返回-1

indexOf

public static int indexOf(String str,
                          String searchStr,
                          int startPos)

在字符串中查找指定字符串，并返回第一个匹配的索引值。如果字符串为null或未找到，则返回-1。

 StringUtil.indexOf(null, *, *)          = -1
 StringUtil.indexOf(*, null, *)          = -1
 StringUtil.indexOf("", "", 0)           = 0
 StringUtil.indexOf("aabaabaa", "a", 0)  = 0
 StringUtil.indexOf("aabaabaa", "b", 0)  = 2
 StringUtil.indexOf("aabaabaa", "ab", 0) = 1
 StringUtil.indexOf("aabaabaa", "b", 3)  = 5
 StringUtil.indexOf("aabaabaa", "b", 9)  = -1
 StringUtil.indexOf("aabaabaa", "b", -1) = 2
 StringUtil.indexOf("aabaabaa", "", 2)   = 2
 StringUtil.indexOf("abc", "", 9)        = 3

str 要扫描的字符串 searchStr 要查找的字符串 startPos 开始搜索的索引值，如果小于0，则看作0 第一个匹配的索引值。如果字符串为null或未找到，则返回-1

indexOfAny

public static int indexOfAny(String str,
                             char[] searchChars)

在字符串中查找指定字符集合中的字符，并返回第一个匹配的起始索引。如果字符串为null，则返回-1。如果字符集合为null或空，也返回-1。

 StringUtil.indexOfAny(null, *)                = -1
 StringUtil.indexOfAny("", *)                  = -1
 StringUtil.indexOfAny(*, null)                = -1
 StringUtil.indexOfAny(*, [])                  = -1
 StringUtil.indexOfAny("zzabyycdxx",['z','a']) = 0
 StringUtil.indexOfAny("zzabyycdxx",['b','y']) = 3
 StringUtil.indexOfAny("aba", ['z'])           = -1

str 要扫描的字符串 searchChars 要搜索的字符集合第一个匹配的索引值。如果字符串为null或未找到，则返回-1

indexOfAny

public static int indexOfAny(String str,
                             String searchChars)

在字符串中查找指定字符集合中的字符，并返回第一个匹配的起始索引。如果字符串为null，则返回-1。如果字符集合为null或空，也返回-1。

 StringUtil.indexOfAny(null, *)            = -1
 StringUtil.indexOfAny("", *)              = -1
 StringUtil.indexOfAny(*, null)            = -1
 StringUtil.indexOfAny(*, "")              = -1
 StringUtil.indexOfAny("zzabyycdxx", "za") = 0
 StringUtil.indexOfAny("zzabyycdxx", "by") = 3
 StringUtil.indexOfAny("aba","z")          = -1

str 要扫描的字符串 searchChars 要搜索的字符集合第一个匹配的索引值。如果字符串为null或未找到，则返回-1

indexOfAny

public static int indexOfAny(String str,
                             String[] searchStrs)

在字符串中查找指定字符串集合中的字符串，并返回第一个匹配的起始索引。如果字符串为null，则返回-1。如果字符串集合为null或空，也返回-1。如果字符串集合包括""，并且字符串不为null，则返回str.length()

 StringUtil.indexOfAny(null, *)                     = -1
 StringUtil.indexOfAny(*, null)                     = -1
 StringUtil.indexOfAny(*, [])                       = -1
 StringUtil.indexOfAny("zzabyycdxx", ["ab","cd"])   = 2
 StringUtil.indexOfAny("zzabyycdxx", ["cd","ab"])   = 2
 StringUtil.indexOfAny("zzabyycdxx", ["mn","op"])   = -1
 StringUtil.indexOfAny("zzabyycdxx", ["zab","aby"]) = 1
 StringUtil.indexOfAny("zzabyycdxx", [""])          = 0
 StringUtil.indexOfAny("", [""])                    = 0
 StringUtil.indexOfAny("", ["a"])                   = -1

str 要扫描的字符串 searchStrs 要搜索的字符串集合第一个匹配的索引值。如果字符串为null或未找到，则返回-1

indexOfAnyBut

public static int indexOfAnyBut(String str,
                                char[] searchChars)

在字符串中查找不在指定字符集合中的字符，并返回第一个匹配的起始索引。如果字符串为null，则返回-1。如果字符集合为null或空，也返回-1。

 StringUtil.indexOfAnyBut(null, *)             = -1
 StringUtil.indexOfAnyBut("", *)               = -1
 StringUtil.indexOfAnyBut(*, null)             = -1
 StringUtil.indexOfAnyBut(*, [])               = -1
 StringUtil.indexOfAnyBut("zzabyycdxx",'za')   = 3
 StringUtil.indexOfAnyBut("zzabyycdxx", 'by')  = 0
 StringUtil.indexOfAnyBut("aba", 'ab')         = -1

str 要扫描的字符串 searchChars 要搜索的字符集合第一个匹配的索引值。如果字符串为null或未找到，则返回-1

indexOfAnyBut

public static int indexOfAnyBut(String str,
                                String searchChars)

在字符串中查找不在指定字符集合中的字符，并返回第一个匹配的起始索引。如果字符串为null，则返回-1。如果字符集合为null或空，也返回-1。

 StringUtil.indexOfAnyBut(null, *)            = -1
 StringUtil.indexOfAnyBut("", *)              = -1
 StringUtil.indexOfAnyBut(*, null)            = -1
 StringUtil.indexOfAnyBut(*, "")              = -1
 StringUtil.indexOfAnyBut("zzabyycdxx", "za") = 3
 StringUtil.indexOfAnyBut("zzabyycdxx", "by") = 0
 StringUtil.indexOfAnyBut("aba","ab")         = -1

str 要扫描的字符串 searchChars 要搜索的字符集合第一个匹配的索引值。如果字符串为null或未找到，则返回-1

lastIndexOf
```
public static int lastIndexOf(String str,
                              char searchChar)
```
从字符串尾部开始查找指定字符，并返回第一个匹配的索引值。如果字符串为null或未找到，则返回-1。
```
 StringUtil.lastIndexOf(null, *)         = -1
 StringUtil.lastIndexOf("", *)           = -1
 StringUtil.lastIndexOf("aabaabaa", 'a') = 7
 StringUtil.lastIndexOf("aabaabaa", 'b') = 5
 
```
str 要扫描的字符串 searchChar 要查找的字符第一个匹配的索引值。如果字符串为null或未找到，则返回-1

lastIndexOf

public static int lastIndexOf(String str,
                              char searchChar,
                              int startPos)

从字符串尾部开始查找指定字符，并返回第一个匹配的索引值。如果字符串为null或未找到，则返回-1。

 StringUtil.lastIndexOf(null, *, *)          = -1
 StringUtil.lastIndexOf("", *,  *)           = -1
 StringUtil.lastIndexOf("aabaabaa", 'b', 8)  = 5
 StringUtil.lastIndexOf("aabaabaa", 'b', 4)  = 2
 StringUtil.lastIndexOf("aabaabaa", 'b', 0)  = -1
 StringUtil.lastIndexOf("aabaabaa", 'b', 9)  = 5
 StringUtil.lastIndexOf("aabaabaa", 'b', -1) = -1
 StringUtil.lastIndexOf("aabaabaa", 'a', 0)  = 0

str 要扫描的字符串 searchChar 要查找的字符 startPos 从指定索引开始向前搜索第一个匹配的索引值。如果字符串为null或未找到，则返回-1

lastIndexOf

public static int lastIndexOf(String str,
                              String searchStr)

从字符串尾部开始查找指定字符串，并返回第一个匹配的索引值。如果字符串为null或未找到，则返回-1。

 StringUtil.lastIndexOf(null, *)         = -1
 StringUtil.lastIndexOf("", *)           = -1
 StringUtil.lastIndexOf("aabaabaa", 'a') = 7
 StringUtil.lastIndexOf("aabaabaa", 'b') = 5

str 要扫描的字符串 searchStr 要查找的字符串第一个匹配的索引值。如果字符串为null或未找到，则返回-1

lastIndexOf

public static int lastIndexOf(String str,
                              String searchStr,
                              int startPos)

从字符串尾部开始查找指定字符串，并返回第一个匹配的索引值。如果字符串为null或未找到，则返回-1。

 StringUtil.lastIndexOf(null, *, *)          = -1
 StringUtil.lastIndexOf(*, null, *)          = -1
 StringUtil.lastIndexOf("aabaabaa", "a", 8)  = 7
 StringUtil.lastIndexOf("aabaabaa", "b", 8)  = 5
 StringUtil.lastIndexOf("aabaabaa", "ab", 8) = 4
 StringUtil.lastIndexOf("aabaabaa", "b", 9)  = 5
 StringUtil.lastIndexOf("aabaabaa", "b", -1) = -1
 StringUtil.lastIndexOf("aabaabaa", "a", 0)  = 0
 StringUtil.lastIndexOf("aabaabaa", "b", 0)  = -1

str 要扫描的字符串 searchStr 要查找的字符串 startPos 从指定索引开始向前搜索第一个匹配的索引值。如果字符串为null或未找到，则返回-1

lastIndexOfAny

public static int lastIndexOfAny(String str,
                                 String[] searchStrs)

从字符串尾部开始查找指定字符串集合中的字符串，并返回第一个匹配的起始索引。如果字符串为null，则返回-1。如果字符串集合为null或空，也返回-1。如果字符串集合包括""，并且字符串不为null，则返回str.length()

 StringUtil.lastIndexOfAny(null, *)                   = -1
 StringUtil.lastIndexOfAny(*, null)                   = -1
 StringUtil.lastIndexOfAny(*, [])                     = -1
 StringUtil.lastIndexOfAny(*, [null])                 = -1
 StringUtil.lastIndexOfAny("zzabyycdxx", ["ab","cd"]) = 6
 StringUtil.lastIndexOfAny("zzabyycdxx", ["cd","ab"]) = 6
 StringUtil.lastIndexOfAny("zzabyycdxx", ["mn","op"]) = -1
 StringUtil.lastIndexOfAny("zzabyycdxx", ["mn","op"]) = -1
 StringUtil.lastIndexOfAny("zzabyycdxx", ["mn",""])   = 10

str 要扫描的字符串 searchStrs 要搜索的字符串集合第一个匹配的索引值。如果字符串为null或未找到，则返回-1

contains

public static boolean contains(String str,
                               char searchChar)

检查字符串中是否包含指定的字符。如果字符串为null，将返回false。

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

str 要扫描的字符串 searchChar 要查找的字符如果找到，则返回true

contains

public static boolean contains(String str,
                               String searchStr)

检查字符串中是否包含指定的字符串。如果字符串为null，将返回false。

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

str 要扫描的字符串 searchStr 要查找的字符串如果找到，则返回true

containsOnly

public static boolean containsOnly(String str,
                                   char[] valid)

检查字符串是是否只包含指定字符集合中的字符。如果字符串为null，则返回false。如果字符集合为null则返回false。但是空字符串永远返回true.

 StringUtil.containsOnly(null, *)       = false
 StringUtil.containsOnly(*, null)       = false
 StringUtil.containsOnly("", *)         = true
 StringUtil.containsOnly("ab", '')      = false
 StringUtil.containsOnly("abab", 'abc') = true
 StringUtil.containsOnly("ab1", 'abc')  = false
 StringUtil.containsOnly("abz", 'abc')  = false

str 要扫描的字符串 valid 要查找的字符串如果找到，则返回true

containsOnly

public static boolean containsOnly(String str,
                                   String valid)

检查字符串是是否只包含指定字符集合中的字符。如果字符串为null，则返回false。如果字符集合为null则返回false。但是空字符串永远返回true.

 StringUtil.containsOnly(null, *)       = false
 StringUtil.containsOnly(*, null)       = false
 StringUtil.containsOnly("", *)         = true
 StringUtil.containsOnly("ab", "")      = false
 StringUtil.containsOnly("abab", "abc") = true
 StringUtil.containsOnly("ab1", "abc")  = false
 StringUtil.containsOnly("abz", "abc")  = false

str 要扫描的字符串 valid 要查找的字符串如果找到，则返回true

containsNone

public static boolean containsNone(String str,
                                   char[] invalid)

检查字符串是是否不包含指定字符集合中的字符。如果字符串为null，则返回false。如果字符集合为null则返回true。但是空字符串永远返回true.

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

str 要扫描的字符串 invalid 要查找的字符串如果找到，则返回true

containsNone

public static boolean containsNone(String str,
                                   String invalidChars)

检查字符串是是否不包含指定字符集合中的字符。如果字符串为null，则返回false。如果字符集合为null则返回true。但是空字符串永远返回true.

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

str 要扫描的字符串 invalidChars 要查找的字符串如果找到，则返回true

countMatches

public static int countMatches(String str,
                               String subStr)

取得指定子串在字符串中出现的次数。如果字符串为null或空，则返回0。

 StringUtil.countMatches(null, *)       = 0
 StringUtil.countMatches("", *)         = 0
 StringUtil.countMatches("abba", null)  = 0
 StringUtil.countMatches("abba", "")    = 0
 StringUtil.countMatches("abba", "a")   = 2
 StringUtil.countMatches("abba", "ab")  = 1
 StringUtil.countMatches("abba", "xxx") = 0

str 要扫描的字符串 subStr 子字符串子串在字符串中出现的次数，如果字符串为null或空，则返回0

substring

public static String substring(String str,
                               int start)

取指定字符串的子串。负的索引代表从尾部开始计算。如果字符串为null，则返回null。

 StringUtil.substring(null, *)   = null
 StringUtil.substring("", *)     = ""
 StringUtil.substring("abc", 0)  = "abc"
 StringUtil.substring("abc", 2)  = "c"
 StringUtil.substring("abc", 4)  = ""
 StringUtil.substring("abc", -2) = "bc"
 StringUtil.substring("abc", -4) = "abc"

str 字符串 start 起始索引，如果为负数，表示从尾部查找子串，如果原始串为null，则返回null

substring

public static String substring(String str,
                               int start,
                               int end)

取指定字符串的子串。负的索引代表从尾部开始计算。如果字符串为null，则返回null。

 StringUtil.substring(null, *, *)    = null
 StringUtil.substring("", * ,  *)    = "";
 StringUtil.substring("abc", 0, 2)   = "ab"
 StringUtil.substring("abc", 2, 0)   = ""
 StringUtil.substring("abc", 2, 4)   = "c"
 StringUtil.substring("abc", 4, 6)   = ""
 StringUtil.substring("abc", 2, 2)   = ""
 StringUtil.substring("abc", -2, -1) = "b"
 StringUtil.substring("abc", -4, 2)  = "ab"

str 字符串 start 起始索引，如果为负数，表示从尾部计算 end 结束索引（不含），如果为负数，表示从尾部计算子串，如果原始串为null，则返回null

left

public static String left(String str,
                          int len)

取得长度为指定字符数的最左边的子串。

 StringUtil.left(null, *)    = null
 StringUtil.left(*, -ve)     = ""
 StringUtil.left("", *)      = ""
 StringUtil.left("abc", 0)   = ""
 StringUtil.left("abc", 2)   = "ab"
 StringUtil.left("abc", 4)   = "abc"

str 字符串 len 最左子串的长度子串，如果原始字串为null，则返回null

right

public static String right(String str,
                           int len)

取得长度为指定字符数的最右边的子串。

 StringUtil.right(null, *)    = null
 StringUtil.right(*, -ve)     = ""
 StringUtil.right("", *)      = ""
 StringUtil.right("abc", 0)   = ""
 StringUtil.right("abc", 2)   = "bc"
 StringUtil.right("abc", 4)   = "abc"

str 字符串 len 最右子串的长度子串，如果原始字串为null，则返回null

mid

public static String mid(String str,
                         int pos,
                         int len)

取得从指定索引开始计算的、长度为指定字符数的子串。

 StringUtil.mid(null, *, *)    = null
 StringUtil.mid(*, *, -ve)     = ""
 StringUtil.mid("", 0, *)      = ""
 StringUtil.mid("abc", 0, 2)   = "ab"
 StringUtil.mid("abc", 0, 4)   = "abc"
 StringUtil.mid("abc", 2, 4)   = "c"
 StringUtil.mid("abc", 4, 2)   = ""
 StringUtil.mid("abc", -2, 2)  = "ab"

str 字符串 pos 起始索引，如果为负数，则看作0 len 子串的长度，如果为负数，则看作长度为0 子串，如果原始字串为null，则返回null

substringBefore

public static String substringBefore(String str,
                                     String separator)

取得第一个出现的分隔子串之前的子串。如果字符串为null，则返回null。如果分隔子串为null或未找到该子串，则返回原字符串。

 StringUtil.substringBefore(null, *)      = null
 StringUtil.substringBefore("", *)        = ""
 StringUtil.substringBefore("abc", "a")   = ""
 StringUtil.substringBefore("abcba", "b") = "a"
 StringUtil.substringBefore("abc", "c")   = "ab"
 StringUtil.substringBefore("abc", "d")   = "abc"
 StringUtil.substringBefore("abc", "")    = ""
 StringUtil.substringBefore("abc", null)  = "abc"

str 字符串 separator 要搜索的分隔子串子串，如果原始串为null，则返回null

substringAfter

public static String substringAfter(String str,
                                    String separator)

取得第一个出现的分隔子串之后的子串。如果字符串为null，则返回null。如果分隔子串为null或未找到该子串，则返回原字符串。

 StringUtil.substringAfter(null, *)      = null
 StringUtil.substringAfter("", *)        = ""
 StringUtil.substringAfter(*, null)      = ""
 StringUtil.substringAfter("abc", "a")   = "bc"
 StringUtil.substringAfter("abcba", "b") = "cba"
 StringUtil.substringAfter("abc", "c")   = ""
 StringUtil.substringAfter("abc", "d")   = ""
 StringUtil.substringAfter("abc", "")    = "abc"

str 字符串 separator 要搜索的分隔子串子串，如果原始串为null，则返回null

substringBeforeLast

public static String substringBeforeLast(String str,
                                         String separator)

取得最后一个的分隔子串之前的子串。如果字符串为null，则返回null。如果分隔子串为null或未找到该子串，则返回原字符串。

 StringUtil.substringBeforeLast(null, *)      = null
 StringUtil.substringBeforeLast("", *)        = ""
 StringUtil.substringBeforeLast("abcba", "b") = "abc"
 StringUtil.substringBeforeLast("abc", "c")   = "ab"
 StringUtil.substringBeforeLast("a", "a")     = ""
 StringUtil.substringBeforeLast("a", "z")     = "a"
 StringUtil.substringBeforeLast("a", null)    = "a"
 StringUtil.substringBeforeLast("a", "")      = "a"

str 字符串 separator 要搜索的分隔子串子串，如果原始串为null，则返回null

substringAfterLast

public static String substringAfterLast(String str,
                                        String separator)

取得最后一个的分隔子串之后的子串。如果字符串为null，则返回null。如果分隔子串为null或未找到该子串，则返回原字符串。

 StringUtil.substringAfterLast(null, *)      = null
 StringUtil.substringAfterLast("", *)        = ""
 StringUtil.substringAfterLast(*, "")        = ""
 StringUtil.substringAfterLast(*, null)      = ""
 StringUtil.substringAfterLast("abc", "a")   = "bc"
 StringUtil.substringAfterLast("abcba", "b") = "a"
 StringUtil.substringAfterLast("abc", "c")   = ""
 StringUtil.substringAfterLast("a", "a")     = ""
 StringUtil.substringAfterLast("a", "z")     = ""

str 字符串 separator 要搜索的分隔子串子串，如果原始串为null，则返回null

substringBetween

public static String substringBetween(String str,
                                      String tag)

取得指定分隔符的前两次出现之间的子串。如果字符串为null，则返回null。如果分隔子串为null，则返回null。

 StringUtil.substringBetween(null, *)            = null
 StringUtil.substringBetween("", "")             = ""
 StringUtil.substringBetween("", "tag")          = null
 StringUtil.substringBetween("tagabctag", null)  = null
 StringUtil.substringBetween("tagabctag", "")    = ""
 StringUtil.substringBetween("tagabctag", "tag") = "abc"

str 字符串 tag 要搜索的分隔子串子串，如果原始串为null或未找到分隔子串，则返回null

substringBetween

public static String substringBetween(String str,
                                      String open,
                                      String close)

取得两个分隔符之间的子串。如果字符串为null，则返回null。如果分隔子串为null，则返回null。

 StringUtil.substringBetween(null, *, *)          = null
 StringUtil.substringBetween("", "", "")          = ""
 StringUtil.substringBetween("", "", "tag")       = null
 StringUtil.substringBetween("", "tag", "tag")    = null
 StringUtil.substringBetween("yabcz", null, null) = null
 StringUtil.substringBetween("yabcz", "", "")     = ""
 StringUtil.substringBetween("yabcz", "y", "z")   = "abc"
 StringUtil.substringBetween("yabczyabcz", "y", "z")   = "abc"

str 字符串 open 要搜索的分隔子串1 close 要搜索的分隔子串2 子串，如果原始串为null或未找到分隔子串，则返回null

substringBetween

public static String substringBetween(String str,
                                      String open,
                                      String close,
                                      int fromIndex)

取得两个分隔符之间的子串。如果字符串为null，则返回null。如果分隔子串为null，则返回null。

 StringUtil.substringBetween(null, *, *)          = null
 StringUtil.substringBetween("", "", "")          = ""
 StringUtil.substringBetween("", "", "tag")       = null
 StringUtil.substringBetween("", "tag", "tag")    = null
 StringUtil.substringBetween("yabcz", null, null) = null
 StringUtil.substringBetween("yabcz", "", "")     = ""
 StringUtil.substringBetween("yabcz", "y", "z")   = "abc"
 StringUtil.substringBetween("yabczyabcz", "y", "z")   = "abc"

str 字符串 open 要搜索的分隔子串1 close 要搜索的分隔子串2 fromIndex 从指定index处搜索子串，如果原始串为null或未找到分隔子串，则返回null

deleteWhitespace

public static String deleteWhitespace(String str)

删除所有在Character.isWhitespace(char)中所定义的空白。

 StringUtil.deleteWhitespace(null)         = null
 StringUtil.deleteWhitespace("")           = ""
 StringUtil.deleteWhitespace("abc")        = "abc"
 StringUtil.deleteWhitespace("   ab  c  ") = "abc"

str 要处理的字符串去空白后的字符串，如果原始字符串为null，则返回null

replaceOnce

public static String replaceOnce(String text,
                                 String repl,
                                 String with)

替换指定的子串，只替换第一个出现的子串。如果字符串为null则返回null，如果指定子串为null，则返回原字符串。

 StringUtil.replaceOnce(null, *, *)        = null
 StringUtil.replaceOnce("", *, *)          = ""
 StringUtil.replaceOnce("aba", null, null) = "aba"
 StringUtil.replaceOnce("aba", null, null) = "aba"
 StringUtil.replaceOnce("aba", "a", null)  = "aba"
 StringUtil.replaceOnce("aba", "a", "")    = "ba"
 StringUtil.replaceOnce("aba", "a", "z")   = "zba"

text 要扫描的字符串 repl 要搜索的子串 with 替换字符串被替换后的字符串，如果原始字符串为null，则返回null

replace

public static String replace(String text,
                             String repl,
                             String with)

替换指定的子串，替换所有出现的子串。如果字符串为null则返回null，如果指定子串为null，则返回原字符串。

 StringUtil.replace(null, *, *)        = null
 StringUtil.replace("", *, *)          = ""
 StringUtil.replace("aba", null, null) = "aba"
 StringUtil.replace("aba", null, null) = "aba"
 StringUtil.replace("aba", "a", null)  = "aba"
 StringUtil.replace("aba", "a", "")    = "b"
 StringUtil.replace("aba", "a", "z")   = "zbz"

text 要扫描的字符串 repl 要搜索的子串 with 替换字符串被替换后的字符串，如果原始字符串为null，则返回null

replace

public static String replace(String text,
                             String repl,
                             String with,
                             int max)

替换指定的子串，替换指定的次数。如果字符串为null则返回null，如果指定子串为null，则返回原字符串。

 StringUtil.replace(null, *, *, *)         = null
 StringUtil.replace("", *, *, *)           = ""
 StringUtil.replace("abaa", null, null, 1) = "abaa"
 StringUtil.replace("abaa", null, null, 1) = "abaa"
 StringUtil.replace("abaa", "a", null, 1)  = "abaa"
 StringUtil.replace("abaa", "a", "", 1)    = "baa"
 StringUtil.replace("abaa", "a", "z", 0)   = "abaa"
 StringUtil.replace("abaa", "a", "z", 1)   = "zbaa"
 StringUtil.replace("abaa", "a", "z", 2)   = "zbza"
 StringUtil.replace("abaa", "a", "z", -1)  = "zbzz"

text 要扫描的字符串 repl 要搜索的子串 with 替换字符串 max maximum number of values to replace, or -1 if no maximum 被替换后的字符串，如果原始字符串为null，则返回null

replaceChars

public static String replaceChars(String str,
                                  char searchChar,
                                  char replaceChar)

将字符串中所有指定的字符，替换成另一个。如果字符串为null则返回null。

 StringUtil.replaceChars(null, *, *)        = null
 StringUtil.replaceChars("", *, *)          = ""
 StringUtil.replaceChars("abcba", 'b', 'y') = "aycya"
 StringUtil.replaceChars("abcba", 'z', 'y') = "abcba"

str 要扫描的字符串 searchChar 要搜索的字符 replaceChar 替换字符被替换后的字符串，如果原始字符串为null，则返回null

replaceChars

public static String replaceChars(String str,
                                  String searchChars,
                                  String replaceChars)

将字符串中所有指定的字符，替换成另一个。如果字符串为null则返回null。如果搜索字符串为null或空，则返回原字符串。例如： replaceChars("hello", "ho", "jy") = jelly。通常搜索字符串和替换字符串是等长的，如果搜索字符串比替换字符串长，则多余的字符将被删除。如果搜索字符串比替换字符串短，则缺少的字符将被忽略。

 StringUtil.replaceChars(null, *, *)           = null
 StringUtil.replaceChars("", *, *)             = ""
 StringUtil.replaceChars("abc", null, *)       = "abc"
 StringUtil.replaceChars("abc", "", *)         = "abc"
 StringUtil.replaceChars("abc", "b", null)     = "ac"
 StringUtil.replaceChars("abc", "b", "")       = "ac"
 StringUtil.replaceChars("abcba", "bc", "yz")  = "ayzya"
 StringUtil.replaceChars("abcba", "bc", "y")   = "ayya"
 StringUtil.replaceChars("abcba", "bc", "yzx") = "ayzya"

str 要扫描的字符串 searchChars 要搜索的字符串 replaceChars 替换字符串被替换后的字符串，如果原始字符串为null，则返回null

overlay

public static String overlay(String str,
                             String overlay,
                             int start,
                             int end)

将指定的子串用另一指定子串覆盖。如果字符串为null，则返回null。负的索引值将被看作0，越界的索引值将被设置成字符串的长度相同的值。

 StringUtil.overlay(null, *, *, *)            = null
 StringUtil.overlay("", "abc", 0, 0)          = "abc"
 StringUtil.overlay("abcdef", null, 2, 4)     = "abef"
 StringUtil.overlay("abcdef", "", 2, 4)       = "abef"
 StringUtil.overlay("abcdef", "", 4, 2)       = "abef"
 StringUtil.overlay("abcdef", "zzzz", 2, 4)   = "abzzzzef"
 StringUtil.overlay("abcdef", "zzzz", 4, 2)   = "abzzzzef"
 StringUtil.overlay("abcdef", "zzzz", -1, 4)  = "zzzzef"
 StringUtil.overlay("abcdef", "zzzz", 2, 8)   = "abzzzz"
 StringUtil.overlay("abcdef", "zzzz", -2, -3) = "zzzzabcdef"
 StringUtil.overlay("abcdef", "zzzz", 8, 10)  = "abcdefzzzz"

str 要扫描的字符串 overlay 用来覆盖的字符串 start 起始索引 end 结束索引被覆盖后的字符串，如果原始字符串为null，则返回null

chomp

public static String chomp(String str)

删除字符串末尾的换行符。如果字符串不以换行结尾，则什么也不做。换行符有三种情形："\n"、"\r"、"\r\n"。

 StringUtil.chomp(null)          = null
 StringUtil.chomp("")            = ""
 StringUtil.chomp("abc \r")      = "abc "
 StringUtil.chomp("abc\n")       = "abc"
 StringUtil.chomp("abc\r\n")     = "abc"
 StringUtil.chomp("abc\r\n\r\n") = "abc\r\n"
 StringUtil.chomp("abc\n\r")     = "abc\n"
 StringUtil.chomp("abc\n\rabc")  = "abc\n\rabc"
 StringUtil.chomp("\r")          = ""
 StringUtil.chomp("\n")          = ""
 StringUtil.chomp("\r\n")        = ""

str 要处理的字符串不以换行结尾的字符串，如果原始字串为null，则返回null

chomp

public static String chomp(String str,
                           String separator)

删除字符串末尾的指定字符串。如果字符串不以该字符串结尾，则什么也不做。

 StringUtil.chomp(null, *)         = null
 StringUtil.chomp("", *)           = ""
 StringUtil.chomp("foobar", "bar") = "foo"
 StringUtil.chomp("foobar", "baz") = "foobar"
 StringUtil.chomp("foo", "foo")    = ""
 StringUtil.chomp("foo ", "foo")   = "foo "
 StringUtil.chomp(" foo", "foo")   = " "
 StringUtil.chomp("foo", "foooo")  = "foo"
 StringUtil.chomp("foo", "")       = "foo"
 StringUtil.chomp("foo", null)     = "foo"

str 要处理的字符串 separator 要删除的字符串不以指定字符串结尾的字符串，如果原始字串为null，则返回null

chop

public static String chop(String str)

删除最后一个字符。如果字符串以\r\n结尾，则同时删除它们。

 StringUtil.chop(null)          = null
 StringUtil.chop("")            = ""
 StringUtil.chop("abc \r")      = "abc "
 StringUtil.chop("abc\n")       = "abc"
 StringUtil.chop("abc\r\n")     = "abc"
 StringUtil.chop("abc")         = "ab"
 StringUtil.chop("abc\nabc")    = "abc\nab"
 StringUtil.chop("a")           = ""
 StringUtil.chop("\r")          = ""
 StringUtil.chop("\n")          = ""
 StringUtil.chop("\r\n")        = ""

str 要处理的字符串删除最后一个字符的字符串，如果原始字符串为null，则返回null

repeat

public static String repeat(String str,
                            int repeat)

将指定字符串重复n遍。

 StringUtil.repeat(null, 2)   = null
 StringUtil.repeat("", 0)     = ""
 StringUtil.repeat("", 2)     = ""
 StringUtil.repeat("a", 3)    = "aaa"
 StringUtil.repeat("ab", 2)   = "abab"
 StringUtil.repeat("abcd", 2) = "abcdabcd"
 StringUtil.repeat("a", -2)   = ""

str 要重复的字符串 repeat 重复次数，如果小于0，则看作0 重复n次的字符串，如果原始字符串为null，则返回null

alignLeft

public static String alignLeft(String str,
                               int size)

扩展并左对齐字符串，用空格' '填充右边。

 StringUtil.alignLeft(null, *)   = null
 StringUtil.alignLeft("", 3)     = "   "
 StringUtil.alignLeft("bat", 3)  = "bat"
 StringUtil.alignLeft("bat", 5)  = "bat  "
 StringUtil.alignLeft("bat", 1)  = "bat"
 StringUtil.alignLeft("bat", -1) = "bat"

str 要对齐的字符串 size 扩展字符串到指定宽度扩展后的字符串，如果字符串为null，则返回null

alignLeft

public static String alignLeft(String str,
                               int size,
                               char padChar)

扩展并左对齐字符串，用指定字符填充右边。

 StringUtil.alignLeft(null, *, *)     = null
 StringUtil.alignLeft("", 3, 'z')     = "zzz"
 StringUtil.alignLeft("bat", 3, 'z')  = "bat"
 StringUtil.alignLeft("bat", 5, 'z')  = "batzz"
 StringUtil.alignLeft("bat", 1, 'z')  = "bat"
 StringUtil.alignLeft("bat", -1, 'z') = "bat"

str 要对齐的字符串 size 扩展字符串到指定宽度 padChar 填充字符扩展后的字符串，如果字符串为null，则返回null

alignLeft

public static String alignLeft(String str,
                               int size,
                               String padStr)

扩展并左对齐字符串，用指定字符串填充右边。

 StringUtil.alignLeft(null, *, *)      = null
 StringUtil.alignLeft("", 3, "z")      = "zzz"
 StringUtil.alignLeft("bat", 3, "yz")  = "bat"
 StringUtil.alignLeft("bat", 5, "yz")  = "batyz"
 StringUtil.alignLeft("bat", 8, "yz")  = "batyzyzy"
 StringUtil.alignLeft("bat", 1, "yz")  = "bat"
 StringUtil.alignLeft("bat", -1, "yz") = "bat"
 StringUtil.alignLeft("bat", 5, null)  = "bat  "
 StringUtil.alignLeft("bat", 5, "")    = "bat  "

str 要对齐的字符串 size 扩展字符串到指定宽度 padStr 填充字符串扩展后的字符串，如果字符串为null，则返回null

alignRight

public static String alignRight(String str,
                                int size)

扩展并右对齐字符串，用空格' '填充左边。

 StringUtil.alignRight(null, *)   = null
 StringUtil.alignRight("", 3)     = "   "
 StringUtil.alignRight("bat", 3)  = "bat"
 StringUtil.alignRight("bat", 5)  = "  bat"
 StringUtil.alignRight("bat", 1)  = "bat"
 StringUtil.alignRight("bat", -1) = "bat"

str 要对齐的字符串 size 扩展字符串到指定宽度扩展后的字符串，如果字符串为null，则返回null

alignRight

public static String alignRight(String str,
                                int size,
                                char padChar)

扩展并右对齐字符串，用指定字符填充左边。

 StringUtil.alignRight(null, *, *)     = null
 StringUtil.alignRight("", 3, 'z')     = "zzz"
 StringUtil.alignRight("bat", 3, 'z')  = "bat"
 StringUtil.alignRight("bat", 5, 'z')  = "zzbat"
 StringUtil.alignRight("bat", 1, 'z')  = "bat"
 StringUtil.alignRight("bat", -1, 'z') = "bat"

str 要对齐的字符串 size 扩展字符串到指定宽度 padChar 填充字符扩展后的字符串，如果字符串为null，则返回null

alignRight

public static String alignRight(String str,
                                int size,
                                String padStr)

扩展并右对齐字符串，用指定字符串填充左边。

 StringUtil.alignRight(null, *, *)      = null
 StringUtil.alignRight("", 3, "z")      = "zzz"
 StringUtil.alignRight("bat", 3, "yz")  = "bat"
 StringUtil.alignRight("bat", 5, "yz")  = "yzbat"
 StringUtil.alignRight("bat", 8, "yz")  = "yzyzybat"
 StringUtil.alignRight("bat", 1, "yz")  = "bat"
 StringUtil.alignRight("bat", -1, "yz") = "bat"
 StringUtil.alignRight("bat", 5, null)  = "  bat"
 StringUtil.alignRight("bat", 5, "")    = "  bat"

str 要对齐的字符串 size 扩展字符串到指定宽度 padStr 填充字符串扩展后的字符串，如果字符串为null，则返回null

center

public static String center(String str,
                            int size)

扩展并居中字符串，用空格' '填充两边。

 StringUtil.center(null, *)   = null
 StringUtil.center("", 4)     = "    "
 StringUtil.center("ab", -1)  = "ab"
 StringUtil.center("ab", 4)   = " ab "
 StringUtil.center("abcd", 2) = "abcd"
 StringUtil.center("a", 4)    = " a  "

str 要对齐的字符串 size 扩展字符串到指定宽度扩展后的字符串，如果字符串为null，则返回null

center

public static String center(String str,
                            int size,
                            char padChar)

扩展并居中字符串，用指定字符填充两边。

 StringUtil.center(null, *, *)     = null
 StringUtil.center("", 4, ' ')     = "    "
 StringUtil.center("ab", -1, ' ')  = "ab"
 StringUtil.center("ab", 4, ' ')   = " ab "
 StringUtil.center("abcd", 2, ' ') = "abcd"
 StringUtil.center("a", 4, ' ')    = " a  "
 StringUtil.center("a", 4, 'y')    = "yayy"

str 要对齐的字符串 size 扩展字符串到指定宽度 padChar 填充字符扩展后的字符串，如果字符串为null，则返回null

center

public static String center(String str,
                            int size,
                            String padStr)

扩展并居中字符串，用指定字符串填充两边。

 StringUtil.center(null, *, *)     = null
 StringUtil.center("", 4, " ")     = "    "
 StringUtil.center("ab", -1, " ")  = "ab"
 StringUtil.center("ab", 4, " ")   = " ab "
 StringUtil.center("abcd", 2, " ") = "abcd"
 StringUtil.center("a", 4, " ")    = " a  "
 StringUtil.center("a", 4, "yz")   = "yayz"
 StringUtil.center("abc", 7, null) = "  abc  "
 StringUtil.center("abc", 7, "")   = "  abc  "

str 要对齐的字符串 size 扩展字符串到指定宽度 padStr 填充字符串扩展后的字符串，如果字符串为null，则返回null

reverse
```
public static String reverse(String str)
```
反转字符串中的字符顺序。如果字符串为null，则返回null。
```
 StringUtil.reverse(null)  = null
 StringUtil.reverse("")    = ""
 StringUtil.reverse("bat") = "tab"
 
```
str 要反转的字符串反转后的字符串，如果原字符串为null，则返回null

reverseDelimited

public static String reverseDelimited(String str,
                                      char separatorChar)

反转指定分隔符分隔的各子串的顺序。如果字符串为null，则返回null。

 StringUtil.reverseDelimited(null, *)      = null
 StringUtil.reverseDelimited("", *)        = ""
 StringUtil.reverseDelimited("a.b.c", 'x') = "a.b.c"
 StringUtil.reverseDelimited("a.b.c", '.') = "c.b.a"

str 要反转的字符串 separatorChar 分隔符反转后的字符串，如果原字符串为null，则返回null

reverseDelimited

public static String reverseDelimited(String str,
                                      String separatorChars,
                                      String separator)

反转指定分隔符分隔的各子串的顺序。如果字符串为null，则返回null。

 StringUtil.reverseDelimited(null, *, *)          = null
 StringUtil.reverseDelimited("", *, *)            = ""
 StringUtil.reverseDelimited("a.b.c", null, null) = "a.b.c"
 StringUtil.reverseDelimited("a.b.c", "", null)   = "a.b.c"
 StringUtil.reverseDelimited("a.b.c", ".", ",")   = "c,b,a"
 StringUtil.reverseDelimited("a.b.c", ".", null)  = "c b a"

str 要反转的字符串 separatorChars 分隔符，如果为null，则默认使用空白字符 separator 用来连接子串的分隔符，如果为null，默认使用空格反转后的字符串，如果原字符串为null，则返回null

abbreviate
```
public static String abbreviate(String str,
                                int maxWidth)
```
将字符串转换成指定长度的缩略，例如：将"Now is the time for all good men"转换成"Now is the time for..."。
- 如果str比maxWidth短，直接返回；
- 否则将它转换成缩略：substring(str, 0, max-3) + "..."；
- 如果maxWidth小于4抛出IllegalArgumentException；
- 返回的字符串不可能长于指定的maxWidth。
```
 StringUtil.abbreviate(null, *)      = null
 StringUtil.abbreviate("", 4)        = ""
 StringUtil.abbreviate("abcdefg", 6) = "abc..."
 StringUtil.abbreviate("abcdefg", 7) = "abcdefg"
 StringUtil.abbreviate("abcdefg", 8) = "abcdefg"
 StringUtil.abbreviate("abcdefg", 4) = "a..."
 StringUtil.abbreviate("abcdefg", 3) = IllegalArgumentException
 
```
str 要检查的字符串 maxWidth 最大长度，不小于4，如果小于4，则看作4 字符串缩略，如果原始字符串为null则返回null

abbreviate

public static String abbreviate(String str,
                                int offset,
                                int maxWidth)

将字符串转换成指定长度的缩略，例如：将"Now is the time for all good men"转换成"...is the time for..."。和abbreviate(String, int)类似，但是增加了一个“左边界”偏移量。注意，“左边界”处的字符未必出现在结果字符串的最左边，但一定出现在结果字符串中。返回的字符串不可能长于指定的maxWidth。

 StringUtil.abbreviate(null, *, *)                = null
 StringUtil.abbreviate("", 0, 4)                  = ""
 StringUtil.abbreviate("abcdefghijklmno", -1, 10) = "abcdefg..."
 StringUtil.abbreviate("abcdefghijklmno", 0, 10)  = "abcdefg..."
 StringUtil.abbreviate("abcdefghijklmno", 1, 10)  = "abcdefg..."
 StringUtil.abbreviate("abcdefghijklmno", 4, 10)  = "abcdefg..."
 StringUtil.abbreviate("abcdefghijklmno", 5, 10)  = "...fghi..."
 StringUtil.abbreviate("abcdefghijklmno", 6, 10)  = "...ghij..."
 StringUtil.abbreviate("abcdefghijklmno", 8, 10)  = "...ijklmno"
 StringUtil.abbreviate("abcdefghijklmno", 10, 10) = "...ijklmno"
 StringUtil.abbreviate("abcdefghijklmno", 12, 10) = "...ijklmno"
 StringUtil.abbreviate("abcdefghij", 0, 3)        = IllegalArgumentException
 StringUtil.abbreviate("abcdefghij", 5, 6)        = IllegalArgumentException

str 要检查的字符串 offset 左边界偏移量 maxWidth 最大长度，不小于4，如果小于4，则看作4 字符串缩略，如果原始字符串为null则返回null

difference

public static String difference(String str1,
                                String str2)

比较两个字符串，取得第二个字符串中，和第一个字符串不同的部分。

 StringUtil.difference("i am a machine", "i am a robot")  = "robot"
 StringUtil.difference(null, null)                        = null
 StringUtil.difference("", "")                            = ""
 StringUtil.difference("", null)                          = ""
 StringUtil.difference("", "abc")                         = "abc"
 StringUtil.difference("abc", "")                         = ""
 StringUtil.difference("abc", "abc")                      = ""
 StringUtil.difference("ab", "abxyz")                     = "xyz"
 StringUtil.difference("abcde", "abxyz")                  = "xyz"
 StringUtil.difference("abcde", "xyz")                    = "xyz"

str1 字符串1 str2 字符串2 第二个字符串中，和第一个字符串不同的部分。如果两个字符串相同，则返回空字符串""

indexOfDifference

public static int indexOfDifference(String str1,
                                    String str2)

比较两个字符串，取得两字符串开始不同的索引值。

 StringUtil.indexOfDifference("i am a machine", "i am a robot")   = 7
 StringUtil.indexOfDifference(null, null)                         = -1
 StringUtil.indexOfDifference("", null)                           = -1
 StringUtil.indexOfDifference("", "")                             = -1
 StringUtil.indexOfDifference("", "abc")                          = 0
 StringUtil.indexOfDifference("abc", "")                          = 0
 StringUtil.indexOfDifference("abc", "abc")                       = -1
 StringUtil.indexOfDifference("ab", "abxyz")                      = 2
 StringUtil.indexOfDifference("abcde", "abxyz")                   = 2
 StringUtil.indexOfDifference("abcde", "xyz")                     = 0

str1 字符串1 str2 字符串2 两字符串开始产生差异的索引值，如果两字符串相同，则返回-1

getLevenshteinDistance

public static int getLevenshteinDistance(String s,
                                         String t)

取得两个字符串的相似度，0代表字符串相等，数字越大表示字符串越不像。这个算法取自http://www.merriampark.com/ld.htm。它计算的是从字符串1转变到字符串2所需要的删除、插入和替换的步骤数。

 StringUtil.getLevenshteinDistance(null, *)             = IllegalArgumentException
 StringUtil.getLevenshteinDistance(*, null)             = IllegalArgumentException
 StringUtil.getLevenshteinDistance("","")               = 0
 StringUtil.getLevenshteinDistance("","a")              = 1
 StringUtil.getLevenshteinDistance("aaapppp", "")       = 7
 StringUtil.getLevenshteinDistance("frog", "fog")       = 1
 StringUtil.getLevenshteinDistance("fly", "ant")        = 3
 StringUtil.getLevenshteinDistance("elephant", "hippo") = 7
 StringUtil.getLevenshteinDistance("hippo", "elephant") = 7
 StringUtil.getLevenshteinDistance("hippo", "zzzzzzzz") = 8
 StringUtil.getLevenshteinDistance("hello", "hallo")    = 1

s 第一个字符串，如果是null，则看作空字符串 t 第二个字符串，如果是null，则看作空字符串相似度值

类 StringUtil

字段概要

构造器概要

方法概要

从类继承的方法 java.lang.Object

字段详细资料

EMPTY_STRING

构造器详细资料

StringUtil

方法详细资料

isEmpty

isNotEmpty

isBlank

isNotBlank

defaultIfNull

defaultIfNull

defaultIfEmpty

defaultIfEmpty

defaultIfBlank

defaultIfBlank

trim

trim

trimStart

trimStart

trimEnd

trimEnd

trimToNull

trimToNull

trimToEmpty

trimToEmpty

equals

equalsIgnoreCase

isAlpha

isAlphaSpace

isAlphanumeric

isAlphanumericSpace

isNumeric

isNumericSpace

isWhitespace

toUpperCase

toLowerCase

capitalize

uncapitalize

swapCase

toCamelCase

toPascalCase

toUpperCaseWithUnderscores

toLowerCaseWithUnderscores

split

split

split

split

join

join

join

join

join

indexOf

indexOf

indexOf

indexOf

indexOfAny

indexOfAny

indexOfAny

indexOfAnyBut

indexOfAnyBut

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOfAny

contains

contains

containsOnly

containsOnly

containsNone

containsNone

countMatches

substring

substring