StringUtil (tiny-码云(gitee.com))

java.lang.Object
- org.tinygroup.commons.tools.StringUtil

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

Author:

renhui

Constructor Summary

Constructors
Constructor and Description

StringUtil()

Constructors
Constructor and Description
`StringUtil()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`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`。
`static String`	`abbreviate(String str, int offset, int maxWidth)` 将字符串转换成指定长度的缩略，例如：将"Now is the time for all good men"转换成"...is the time for..."。
`static String`	`bytesToString(byte[] bytes)` 将一个byte数组转换成62进制的字符串。
`static String`	`bytesToString(byte[] bytes, boolean noCase)` 将一个byte数组转换成62进制的字符串。
`static String`	`capitalize(String str)` 将字符串的首字符转成大写（`Character.toTitleCase`），其它字符不变。
`static String`	`chomp(String str)` 删除字符串末尾的换行符。如果字符串不以换行结尾，则什么也不做。
`static String`	`chomp(String str, String separator)` 删除字符串末尾的指定字符串。如果字符串不以该字符串结尾，则什么也不做。
`static String`	`chop(String str)` 删除最后一个字符。
`static boolean`	`contains(String str, char searchChar)` 检查字符串中是否包含指定的字符。如果字符串为`null`，将返回`false`。
`static boolean`	`contains(String str, String searchStr)` 检查字符串中是否包含指定的字符串。如果字符串为`null`，将返回`false`。
`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, String defaultStr)` 如果字符串是`null`或空字符串`""`，则返回指定默认字符串，否则返回字符串本身。
`static String`	`defaultIfEmpty(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 String`	`escapeMetaDataPattern(String pattern)` Escape table or schema patterns used for DatabaseMetaData functions.
`static int`	`getLength(String str)` 取得字符串的长度。
`static void`	`indent(Formatter buf, String str, String indent)` 从第二行开始，对每一行缩进指定空白。
`static void`	`indent(StringBuilder buf, String str, String indent)` 从第二行开始，对每一行缩进指定空白。
`static String`	`indent(String str, String indent)` 从第二行开始，对每一行缩进指定空白。
`static int`	`indexOf(String str, char searchChar)` 在字符串中查找指定字符，并返回第一个匹配的索引值。如果字符串为`null`或未找到，则返回`-1`。
`static int`	`indexOf(String str, char searchChar, int startPos)` 在字符串中查找指定字符，并返回第一个匹配的索引值。如果字符串为`null`或未找到，则返回`-1`。
`static int`	`indexOf(String str, String searchStr)` 在字符串中查找指定字符串，并返回第一个匹配的索引值。如果字符串为`null`或未找到，则返回`-1`。
`static int`	`indexOf(String str, String searchStr, int startPos)` 在字符串中查找指定字符串，并返回第一个匹配的索引值。如果字符串为`null`或未找到，则返回`-1`。
`static int`	`indexOfAny(String str, char[] searchChars)` 在字符串中查找指定字符集合中的字符，并返回第一个匹配的起始索引。如果字符串为`null`，则返回 `-1`。如果字符集合为`null`或空，也返回`-1`。
`static int`	`indexOfAny(String str, String searchChars)` 在字符串中查找指定字符集合中的字符，并返回第一个匹配的起始索引。如果字符串为`null`，则返回 `-1`。如果字符集合为`null`或空，也返回`-1`。
`static int`	`indexOfAny(String str, String[] searchStrs)` 在字符串中查找指定字符串集合中的字符串，并返回第一个匹配的起始索引。如果字符串为`null`，则返回 `-1`。如果字符串集合为`null`或空，也返回`-1`。如果字符串集合包括`""`，并且字符串不为`null`，则返回 `str.length()`
`static int`	`indexOfAnyBut(String str, char[] searchChars)` 在字符串中查找不在指定字符集合中的字符，并返回第一个匹配的起始索引。如果字符串为`null`，则返回 `-1`。如果字符集合为`null`或空，也返回`-1`。
`static int`	`indexOfAnyBut(String str, String searchChars)` 在字符串中查找不在指定字符集合中的字符，并返回第一个匹配的起始索引。如果字符串为`null`，则返回 `-1`。如果字符集合为`null`或空，也返回`-1`。
`static int`	`indexOfDifference(String str1, String str2)` 比较两个字符串，取得两字符串开始不同的索引值。
`static boolean`	`isBlank(String str)` 检查字符串是否是空白：`null`、空字符串`""`或只有空白字符。
`static boolean`	`isEmpty(String str)` 检查字符串是否为`null`或空字符串`""`。
`static boolean`	`isEqualsIgnoreCase(String str1, String str2)` 比较两个字符串（大小写不敏感）。
`static String`	`join(Iterable<?> list, String separator)` 将`Iterator`中的元素连接成一个字符串。
`static String`	`join(Object[] array, String separator)` 将数组中的元素连接成一个字符串。
`static int`	`lastIndexOf(String str, char searchChar)` 从字符串尾部开始查找指定字符，并返回第一个匹配的索引值。如果字符串为`null`或未找到，则返回 `-1`。
`static int`	`lastIndexOf(String str, char searchChar, int startPos)` 从字符串尾部开始查找指定字符，并返回第一个匹配的索引值。如果字符串为`null`或未找到，则返回 `-1`。
`static int`	`lastIndexOf(String str, String searchStr)` 从字符串尾部开始查找指定字符串，并返回第一个匹配的索引值。如果字符串为`null`或未找到，则返回 `-1`。
`static int`	`lastIndexOf(String str, String searchStr, int startPos)` 从字符串尾部开始查找指定字符串，并返回第一个匹配的索引值。如果字符串为`null`或未找到，则返回 `-1`。
`static int`	`lastIndexOfAny(String str, String[] searchStrs)` 从字符串尾部开始查找指定字符串集合中的字符串，并返回第一个匹配的起始索引。如果字符串为`null`，则返回 `-1`。如果字符串集合为`null`或空，也返回`-1`。如果字符串集合包括`""`，并且字符串不为`null`，则返回 `str.length()`
`static String`	`left(String str, int len)` 取得长度为指定字符数的最左边的子串。
`static String`	`longToString(long longValue)` 将一个长整形转换成62进制的字符串。
`static String`	`longToString(long longValue, boolean noCase)` 将一个长整形转换成62进制的字符串。
`static String`	`mid(String str, int pos, int len)` 取得从指定索引开始计算的、长度为指定字符数的子串。
`static String`	`overlay(String str, String overlay, int start, int end)` 将指定的子串用另一指定子串覆盖。
`static String`	`quoteIdentifier(String s)` Enclose a string with double quotes.
`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`	`replaceAll(String s, String before, String after)` Replace all occurrences of the before string with the after string.
`static String`	`replaceChar(String str, char searchChar, char replaceChar)` 将字符串中所有指定的字符，替换成另一个。
`static String`	`replaceChars(String str, String searchChars, String replaceChars)` 将字符串中所有指定的字符，替换成另一个。
`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, 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[]`	`toStringArray(Collection<String> collection)` Copy the given Collection into a String array.
`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)` 将字符串的首字符转成小写，其它字符不变。

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail
- StringUtil
```
public StringUtil()
```

Method Detail

getLength
```
public static int getLength(String str)
```
取得字符串的长度。

Parameters:

str - 要取长度的字符串

Returns:

如果字符串为null，则返回0。否则返回字符串的长度。

isEqualsIgnoreCase

public static boolean isEqualsIgnoreCase(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

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

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

Parameters:: str - 要检查的字符串
Returns:: 如果为空, 则返回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

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

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"

Parameters:: str - 要转换的字符串; defaultStr - 默认字符串
Returns:: 字符串本身或指定的默认字符串

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"

Parameters:: str - 要转换的字符串; defaultStr - 默认字符串
Returns:: 字符串本身或指定的默认字符串

trim

public static String trim(String str)

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

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

Parameters:: str - 要处理的字符串
Returns:: 除去空白的字符串，如果原字串为null，则返回null

trimToNull

public static String trimToNull(String str)

除去字符串头尾部的空白，如果结果字符串是空字符串""，则返回null。

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

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

trimToEmpty

public static String trimToEmpty(String str)

除去字符串头尾部的空白，如果字符串是null，则返回空字符串""。

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

Parameters:: str - 要处理的字符串
Returns:: 除去空白的字符串，如果原字串为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"

Parameters:: str - 要处理的字符串; stripChars - 要除去的字符，如果为null表示除去空白字符
Returns:: 除去指定字符后的的字符串，如果原字串为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 "
 
```
Parameters:

str - 要处理的字符串

Returns:

除去空白的字符串，如果原字串为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  "

Parameters:: str - 要处理的字符串; stripChars - 要除去的字符，如果为null表示除去空白字符
Returns:: 除去指定字符后的的字符串，如果原字串为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"
 
```
Parameters:

str - 要处理的字符串

Returns:

除去空白的字符串，如果原字串为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"

Parameters:: str - 要处理的字符串; stripChars - 要除去的字符，如果为null表示除去空白字符
Returns:: 除去指定字符后的的字符串，如果原字串为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"
 
```
Parameters:

str - 要处理的字符串

stripChars - 要除去的字符，如果为null表示除去空白字符

Returns:

除去空白的字符串，如果原字串为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"

Parameters:: str - 要处理的字符串
Returns:: 除去空白的字符串，如果原字串为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"
 
```
Parameters:

str - 要转换的字符串

Returns:

首字符为大写的字符串，如果原字符串为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"
 
```
Parameters:

str - 要转换的字符串

Returns:

首字符为小写的字符串，如果原字符串为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"

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

toUpperCase
```
public static String toUpperCase(String str)
```
将字符串转换成大写。
如果字符串是null则返回null。
```
 StringUtil.toUpperCase(null)  = null
 StringUtil.toUpperCase("")    = ""
 StringUtil.toUpperCase("aBc") = "ABC"
 
```
Parameters:

str - 要转换的字符串

Returns:

大写字符串，如果原字符串为null，则返回null

toLowerCase
```
public static String toLowerCase(String str)
```
将字符串转换成小写。
如果字符串是null则返回null。
```
 StringUtil.toLowerCase(null)  = null
 StringUtil.toLowerCase("")    = ""
 StringUtil.toLowerCase("aBc") = "abc"
 
```
Parameters:

str - 要转换的字符串

Returns:

大写字符串，如果原字符串为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"

此方法会保留除了下划线和空白以外的所有分隔符。

Parameters:: str - 要转换的字符串
Returns:: 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"

此方法会保留除了下划线和空白以外的所有分隔符。

Parameters:: str - 要转换的字符串
Returns:: 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__"

此方法会保留除了空白以外的所有分隔符。

Parameters:: str - 要转换的字符串
Returns:: 下划线分隔的大写字符串，如果原字符串为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__"

此方法会保留除了空白以外的所有分隔符。

Parameters:: str - 要转换的字符串
Returns:: 下划线分隔的小写字符串，如果原字符串为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"]

Parameters:: str - 要分割的字符串; separatorChar - 分隔符
Returns:: 分割后的字符串数组，如果原字符串为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"]

Parameters:: str - 要分割的字符串; separatorChars - 分隔符
Returns:: 分割后的字符串数组，如果原字符串为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"]

Parameters:: str - 要分割的字符串; separatorChars - 分隔符; max - 返回的数组的最大个数，如果小于等于0，则表示无限制
Returns:: 分割后的字符串数组，如果原字符串为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"

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

join

public static String join(Iterable<?> list,
                          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"

Parameters:: iterator - 要连接的Iterator; separator - 分隔符
Returns:: 连接后的字符串，如果原数组为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
 
```
Parameters:

str - 要扫描的字符串

searchChar - 要查找的字符

Returns:

第一个匹配的索引值。如果字符串为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

Parameters:: str - 要扫描的字符串; searchChar - 要查找的字符; startPos - 开始搜索的索引值，如果小于0，则看作0
Returns:: 第一个匹配的索引值。如果字符串为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

Parameters:: str - 要扫描的字符串; searchStr - 要查找的字符串
Returns:: 第一个匹配的索引值。如果字符串为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

Parameters:: str - 要扫描的字符串; searchStr - 要查找的字符串; startPos - 开始搜索的索引值，如果小于0，则看作0
Returns:: 第一个匹配的索引值。如果字符串为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

Parameters:: str - 要扫描的字符串; searchChars - 要搜索的字符集合
Returns:: 第一个匹配的索引值。如果字符串为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

Parameters:: str - 要扫描的字符串; searchChars - 要搜索的字符集合
Returns:: 第一个匹配的索引值。如果字符串为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

Parameters:: str - 要扫描的字符串; searchStrs - 要搜索的字符串集合
Returns:: 第一个匹配的索引值。如果字符串为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

Parameters:: str - 要扫描的字符串; searchChars - 要搜索的字符集合
Returns:: 第一个匹配的索引值。如果字符串为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

Parameters:: str - 要扫描的字符串; searchChars - 要搜索的字符集合
Returns:: 第一个匹配的索引值。如果字符串为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
 
```
Parameters:

str - 要扫描的字符串

searchChar - 要查找的字符

Returns:

第一个匹配的索引值。如果字符串为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

Parameters:: str - 要扫描的字符串; searchChar - 要查找的字符; startPos - 从指定索引开始向前搜索
Returns:: 第一个匹配的索引值。如果字符串为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

Parameters:: str - 要扫描的字符串; searchStr - 要查找的字符串
Returns:: 第一个匹配的索引值。如果字符串为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

Parameters:: str - 要扫描的字符串; searchStr - 要查找的字符串; startPos - 从指定索引开始向前搜索
Returns:: 第一个匹配的索引值。如果字符串为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

Parameters:: str - 要扫描的字符串; searchStrs - 要搜索的字符串集合
Returns:: 第一个匹配的索引值。如果字符串为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

Parameters:: str - 要扫描的字符串; searchChar - 要查找的字符
Returns:: 如果找到，则返回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

Parameters:: str - 要扫描的字符串; searchStr - 要查找的字符串
Returns:: 如果找到，则返回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

Parameters:: str - 要扫描的字符串; valid - 要查找的字符串
Returns:: 如果找到，则返回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

Parameters:: str - 要扫描的字符串; valid - 要查找的字符串
Returns:: 如果找到，则返回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

Parameters:: str - 要扫描的字符串; invalid - 要查找的字符串
Returns:: 如果找到，则返回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

Parameters:: str - 要扫描的字符串; invalidChars - 要查找的字符串
Returns:: 如果找到，则返回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

Parameters:: str - 要扫描的字符串; subStr - 子字符串
Returns:: 子串在字符串中出现的次数，如果字符串为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"

Parameters:: str - 字符串; start - 起始索引，如果为负数，表示从尾部查找
Returns:: 子串，如果原始串为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"

Parameters:: str - 字符串; start - 起始索引，如果为负数，表示从尾部计算; end - 结束索引（不含），如果为负数，表示从尾部计算
Returns:: 子串，如果原始串为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"

Parameters:: str - 字符串; len - 最左子串的长度
Returns:: 子串，如果原始字串为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"

Parameters:: str - 字符串; len - 最右子串的长度
Returns:: 子串，如果原始字串为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"

Parameters:: str - 字符串; pos - 起始索引，如果为负数，则看作0; len - 子串的长度，如果为负数，则看作长度为0
Returns:: 子串，如果原始字串为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"

Parameters:: str - 字符串; separator - 要搜索的分隔子串
Returns:: 子串，如果原始串为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"

Parameters:: str - 字符串; separator - 要搜索的分隔子串
Returns:: 子串，如果原始串为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"

Parameters:: str - 字符串; separator - 要搜索的分隔子串
Returns:: 子串，如果原始串为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")     = ""

Parameters:: str - 字符串; separator - 要搜索的分隔子串
Returns:: 子串，如果原始串为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"

Parameters:: str - 字符串; tag - 要搜索的分隔子串
Returns:: 子串，如果原始串为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"

Parameters:: str - 字符串; open - 要搜索的分隔子串1; close - 要搜索的分隔子串2
Returns:: 子串，如果原始串为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"

Parameters:: str - 字符串; open - 要搜索的分隔子串1; close - 要搜索的分隔子串2; fromIndex - 从指定index处搜索
Returns:: 子串，如果原始串为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"

Parameters:: str - 要处理的字符串
Returns:: 去空白后的字符串，如果原始字符串为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"

Parameters:: text - 要扫描的字符串; repl - 要搜索的子串; with - 替换字符串
Returns:: 被替换后的字符串，如果原始字符串为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"

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

replaceChar

public static String replaceChar(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"

Parameters:: str - 要扫描的字符串; searchChar - 要搜索的字符; replaceChar - 替换字符
Returns:: 被替换后的字符串，如果原始字符串为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"

Parameters:: str - 要扫描的字符串; searchChars - 要搜索的字符串; replaceChars - 替换字符串
Returns:: 被替换后的字符串，如果原始字符串为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"

Parameters:: str - 要扫描的字符串; overlay - 用来覆盖的字符串; start - 起始索引; end - 结束索引
Returns:: 被覆盖后的字符串，如果原始字符串为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)   = ""

Parameters:: str - 要重复的字符串; repeat - 重复次数，如果小于0，则看作0
Returns:: 重复n次的字符串，如果原始字符串为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")        = ""

Parameters:: str - 要处理的字符串
Returns:: 不以换行结尾的字符串，如果原始字串为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"

Parameters:: str - 要处理的字符串; separator - 要删除的字符串
Returns:: 不以指定字符串结尾的字符串，如果原始字串为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")        = ""

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

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

str - 要反转的字符串

Returns:

反转后的字符串，如果原字符串为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"

Parameters:: str - 要反转的字符串; separatorChar - 分隔符
Returns:: 反转后的字符串，如果原字符串为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"

Parameters:: str - 要反转的字符串; separatorChars - 分隔符，如果为null，则默认使用空白字符; separator - 用来连接子串的分隔符，如果为null，默认使用空格
Returns:: 反转后的字符串，如果原字符串为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
 
```
Parameters:

str - 要检查的字符串

maxWidth - 最大长度，不小于4，如果小于4，则看作 4

Returns:

字符串缩略，如果原始字符串为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

Parameters:: str - 要检查的字符串; offset - 左边界偏移量; maxWidth - 最大长度，不小于4，如果小于4，则看作 4
Returns:: 字符串缩略，如果原始字符串为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"

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

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

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

longToString
```
public static String longToString(long longValue)
```
将一个长整形转换成62进制的字符串。

longToString

public static String longToString(long longValue,
                                  boolean noCase)

将一个长整形转换成62进制的字符串。

bytesToString
```
public static String bytesToString(byte[] bytes)
```
将一个byte数组转换成62进制的字符串。

bytesToString

public static String bytesToString(byte[] bytes,
                                   boolean noCase)

将一个byte数组转换成62进制的字符串。

indent

public static String indent(String str,
                            String indent)

从第二行开始，对每一行缩进指定空白。

indent

public static void indent(Formatter buf,
                          String str,
                          String indent)

从第二行开始，对每一行缩进指定空白。

indent

public static void indent(StringBuilder buf,
                          String str,
                          String indent)

从第二行开始，对每一行缩进指定空白。

toStringArray
```
public static String[] toStringArray(Collection<String> collection)
```
Copy the given Collection into a String array. The Collection must contain String elements only.

Parameters:

collection - the Collection to copy

Returns:

the String array (null if the passed-in Collection was null)

equals

public static boolean equals(String str1,
                             String str2)

quoteIdentifier
```
public static String quoteIdentifier(String s)
```
Enclose a string with double quotes. A double quote inside the string is escaped using a double quote.

Parameters:

s - the text

Returns:

the double quoted text

escapeMetaDataPattern
```
public static String escapeMetaDataPattern(String pattern)
```
Escape table or schema patterns used for DatabaseMetaData functions.

Parameters:

pattern - the pattern

Returns:

the escaped pattern

replaceAll

public static String replaceAll(String s,
                                String before,
                                String after)

Replace all occurrences of the before string with the after string.

Parameters:: s - the string; before - the old text; after - the new text
Returns:: the string with the before string replaced

Class StringUtil

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

StringUtil

Method Detail

getLength

isEqualsIgnoreCase

isEmpty

isBlank

defaultIfEmpty

defaultIfBlank

trim

trimToNull

trimToEmpty

trim

trimStart

trimStart

trimEnd

trimEnd

trimToNull

trimToEmpty

capitalize

uncapitalize

swapCase

toUpperCase

toLowerCase

toCamelCase

toPascalCase

toUpperCaseWithUnderscores

toLowerCaseWithUnderscores

split

split

split

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

left

right

mid

substringBefore

substringAfter

substringBeforeLast

substringAfterLast

substringBetween

substringBetween

substringBetween

deleteWhitespace

replace

replace

replaceChar

replaceChars

overlay

repeat

chomp

chomp

chop