StringUtils (bus-core 3.0.9 API)

java.lang.Object
- org.aoju.bus.core.utils.TextUtils
- - org.aoju.bus.core.utils.StringUtils

All Implemented Interfaces:

Serializable, Appendable, CharSequence
```
public class StringUtils
extends TextUtils
```
字符串处理类
用于MD5,加解密和字符串编码转换

Since:

JDK 1.8

Version:

3.0.9

Author:

Kimi Liu

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

static int INDEX_NOT_FOUND
- Fields inherited from class org.aoju.bus.core.utils.TextUtils
  DEFAULT_CAPACITY

Fields
Modifier and Type	Field and Description
`static int`	`INDEX_NOT_FOUND`

Constructor Summary

Constructors
Constructor and Description

StringUtils()

Constructors
Constructor and Description
`StringUtils()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static String`	`addPrefixIfNot(CharSequence str, CharSequence prefix)` 如果给定字符串不是以prefix开头的，在开头补充 prefix
`static String`	`addSuffixIfNot(CharSequence str, CharSequence suffix)` 如果给定字符串不是以suffix结尾的，在尾部补充 suffix
`static String`	`AESToString(String text, String token)` AES解密
`static String`	`AESToString(String text, String token, String charset)` AES解密
`static boolean`	`areNotEmpty(String... values)`
`static byte[]`	`base64ToByte(String str)` 将base64字符串处理成String字节
`static String`	`base64ToString(String str)` 将base64字符串处理成String (用默认的String编码集)
`static String`	`base64ToString(String str, String charset)` 将base64字符串处理成String (用默认的String编码集)
`static String`	`brief(CharSequence str, int maxLength)` 将给定字符串，变成 "xxx...xxx" 形式的字符串
`static StringBuilder`	`builder()` 创建StringBuilder对象
`static StringBuilder`	`builder(CharSequence... strs)` 创建StringBuilder对象
`static StringBuilder`	`builder(int capacity)` 创建StringBuilder对象
`static String`	`buildString(Object original, String middle, int prefixLength)` 构建新的字符串
`static String`	`byteArrayToHex(byte[] byteArray)` 将字节数组换成16进制的字符串
`static int`	`byteLength(CharSequence cs, Charset charset)` 给定字符串转为bytes后的byte数（byte长度）
`static byte[]`	`bytes(CharSequence str)` 编码字符串使用系统默认编码
`static byte[]`	`bytes(CharSequence str, Charset charset)` 编码字符串
`static byte[]`	`bytes(CharSequence str, String charset)` 编码字符串
`static String`	`capitalize(String str)`
`static String`	`cleanBlank(CharSequence str)` 清理空白字符
`static String`	`compress(byte[] bytes)` 系统压缩(返回base64后的压缩数据)
`static String`	`compress(String val, String... charset)` 系统压缩(返回base64后的压缩数据)
`static String`	`compress2(byte[] bts)` 自定义二级压缩(最终显示为base64后的串)
`static String`	`compress2(String val, String... charset)` 自定义二级压缩(最终显示为base64后的串)
`static String`	`concat(boolean isNullToEmpty, CharSequence... strs)` 连接多个字符串为一个
`static boolean`	`contains(CharSequence str, char searchChar)` 指定字符是否在字符串中出现过
`static boolean`	`containsAny(CharSequence str, char... testChars)` 查找指定字符串是否包含指定字符列表中的任意一个字符
`static boolean`	`containsAny(CharSequence str, CharSequence... testStrs)` 查找指定字符串是否包含指定字符串列表中的任意一个字符串
`static boolean`	`containsAnyIgnoreCase(CharSequence str, CharSequence... testStrs)` 查找指定字符串是否包含指定字符串列表中的任意一个字符串忽略大小写
`static boolean`	`containsBlank(CharSequence str)` 给定字符串是否包含空白符（空白符包括空格、制表符、全角空格和不间断空格）如果给定字符串为null或者""，则返回false
`static boolean`	`containsIgnoreCase(CharSequence str, CharSequence testStr)` 是否包含特定字符，忽略大小写，如果给定两个参数都为`null`，返回true
`static boolean`	`containsOnly(CharSequence str, char... testChars)` 检查指定字符串中是否只包含给定的字符
`static int`	`count(CharSequence content, char charForSearch)` 统计指定内容中包含指定字符的数量
`static int`	`count(CharSequence content, CharSequence strForSearch)` 统计指定内容中包含指定字符串的数量参数为 `null` 或者 "" 返回 `0`.
`static String[]`	`cut(CharSequence str, int partLength)` 将字符串切分为N等份
`static String`	`defaultString(String str, String defaultStr)` Returns either the passed in String, or if the String is `null`, the value of `defaultStr`.
`static String`	`DESToString(String text, String token)` DES解密
`static String`	`DESToString(String text, String token, String charset)` DES解密
`static boolean`	`endWith(CharSequence str, char c)` 字符串是否以给定字符结尾
`static boolean`	`endWith(CharSequence str, CharSequence suffix)` 是否以指定字符串结尾
`static boolean`	`endWith(CharSequence str, CharSequence suffix, boolean isIgnoreCase)` 是否以指定字符串结尾如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
`static boolean`	`endWithIgnoreCase(CharSequence str, CharSequence suffix)` 是否以指定字符串结尾，忽略大小写
`static boolean`	`equals(CharSequence str1, CharSequence str2)` 比较两个字符串（大小写敏感）。
`static boolean`	`equals(CharSequence str1, CharSequence str2, boolean ignoreCase)` 比较两个字符串是否相等。
`static boolean`	`equalsIgnoreCase(CharSequence str1, CharSequence str2)` 比较两个字符串（大小写不敏感）。
`static String`	`fill(String str, char filledChar, int len, boolean isPre)` 将已有字符串填充为规定长度，如果已有字符串超过这个长度则返回这个字符串
`static String`	`fillAfter(String str, char filledChar, int len)` 将已有字符串填充为规定长度，如果已有字符串超过这个长度则返回这个字符串字符填充于字符串后
`static String`	`fillBefore(String str, char filledChar, int len)` 将已有字符串填充为规定长度，如果已有字符串超过这个长度则返回这个字符串字符填充于字符串前
`static String`	`format(String val, Object... argArray)` 格式化字符串此方法只是简单将占位符 {} 按照顺序替换为参数如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可例：通常使用：format("this is {} for {}", "a", "b") =》 this is a for b 转义{}： format("this is \\{} for {}", "a", "b") =》 this is \{} for a 转义\： format("this is \\\\{} for {}", "a", "b") =》 this is \a for b
`static String`	`getContainsStr(CharSequence str, CharSequence... testStrs)` 查找指定字符串是否包含指定字符串列表中的任意一个字符串，如果包含返回找到的第一个字符串
`static String`	`getContainsStrIgnoreCase(CharSequence str, CharSequence... testStrs)` 查找指定字符串是否包含指定字符串列表中的任意一个字符串，如果包含返回找到的第一个字符串忽略大小写
`static StringReader`	`getReader(CharSequence str)` 获得StringReader
`static StringWriter`	`getWriter()` 获得StringWriter
`static boolean`	`hasBlank(CharSequence... strs)` 是否包含空字符串
`static boolean`	`hasEmpty(CharSequence... strs)` 是否包含空字符串
`static boolean`	`hasLength(String str)` Check that the given `String` is neither `null` nor of length 0.
`static boolean`	`hasText(String str)` Check whether the given `String` contains actual text.
`static byte[]`	`hexStringToByte(String hex)` bytes字符串转换为Byte值 src Byte字符串，每个Byte之间没有分隔符
`static String`	`hide(CharSequence str, int startInclude, int endExclude)` 替换指定字符串的指定区间内字符为"*"
`static int`	`indexOf(CharSequence str, char searchChar)` 指定范围内查找指定字符
`static int`	`indexOf(CharSequence str, char searchChar, int start)` 指定范围内查找指定字符
`static int`	`indexOf(CharSequence str, char searchChar, int start, int end)` 指定范围内查找指定字符
`static int`	`indexOf(CharSequence str, CharSequence searchStr, int fromIndex, boolean ignoreCase)` 指定范围内反向查找字符串
`static int`	`indexOfIgnoreCase(CharSequence str, CharSequence searchStr)` 指定范围内查找字符串，忽略大小写
`static int`	`indexOfIgnoreCase(CharSequence str, CharSequence searchStr, int fromIndex)` 指定范围内查找字符串
`static boolean`	`isAllCharMatch(CharSequence value, Matcher<Character> matcher)` 字符串的每一个字符是否都与定义的匹配器匹配
`static boolean`	`isAnyBlank(CharSequence... css)` Checks if any of the CharSequences are empty ("") or null or whitespace only.
`static boolean`	`isBlank(CharSequence cs)`
`static boolean`	`isEmpty(Collection<?> collection)` 集合是否为空
`static boolean`	`isEmpty(Map<?,?> map)` Map是否为空
`static boolean`	`isEmpty(Object obj)` 校验对象是不是为null或者内容是""
`static boolean`	`isEmptyIfStr(Object obj)` 如果对象是字符串是否为空串空的定义如下: 1、为null 2、为""
`static boolean`	`isLowerCase(CharSequence str)` 给定字符串中的字母是否全部为小写，判断依据如下：
`static boolean`	`isNotBlank(CharSequence cs)`
`static boolean`	`isNotEmpty(String str)`
`static boolean`	`isSubEquals(CharSequence str1, int start1, CharSequence str2, int start2, int length, boolean ignoreCase)` 截取两个字符串的不同部分（长度一致），判断截取的子串是否相同任意一个字符串为null返回false
`static boolean`	`isSurround(CharSequence str, char prefix, char suffix)` 给定字符串是否被字符包围
`static boolean`	`isSurround(CharSequence str, CharSequence prefix, CharSequence suffix)` 给定字符串是否被字符包围
`static boolean`	`isUpperCase(CharSequence str)` 给定字符串中的字母是否全部为大写，判断依据如下：
`static boolean`	`isWrap(CharSequence str, char wrapper)` 指定字符串是否被同一字符包装（前后都有这些字符串）
`static boolean`	`isWrap(CharSequence str, char prefixChar, char suffixChar)` 指定字符串是否被包装
`static boolean`	`isWrap(CharSequence str, String wrapper)` 指定字符串是否被同一字符包装（前后都有这些字符串）
`static boolean`	`isWrap(CharSequence str, String prefix, String suffix)` 指定字符串是否被包装
`static int`	`lastIndexOf(CharSequence str, CharSequence searchStr, int fromIndex, boolean ignoreCase)` 指定范围内查找字符串
`static int`	`lastIndexOfIgnoreCase(CharSequence str, CharSequence searchStr)` 指定范围内查找字符串，忽略大小写
`static int`	`lastIndexOfIgnoreCase(CharSequence str, CharSequence searchStr, int fromIndex)` 指定范围内查找字符串，忽略大小写
`static String`	`left(String str, int len)` Gets the leftmost `len` characters of a String.
`static String`	`leftPad(String str, int size)` 用指定的字符串填充一个字符串
`static String`	`leftPad(String str, int size, char padChar)` 用指定的字符串填充一个字符串
`static String`	`leftPad(String str, int size, String padStr)` 用指定的字符串填充一个字符串
`static int`	`length(CharSequence cs)` 获取字符串的长度，如果为null返回0
`static String`	`lowerFirst(CharSequence str)` 小写首字母例如：str = Name, return name
`static String`	`mid(String str, int pos, int len)` Gets `len` characters from the middle of a String.
`static String`	`nullToDefault(CharSequence str, String defaultStr)` 如果字符串是`null`，则返回指定默认字符串，否则返回字符串本身。
`static String`	`nullToEmpty(CharSequence str)` 当给定字符串为null时，转换为Empty
`static int`	`ordinalIndexOf(String str, String searchStr, int ordinal)` 返回字符串 searchStr 在字符串 str 中第 ordinal 次出现的位置。如果 str=null 或 searchStr=null 或 ordinal小于等于0 则返回-1
`static String`	`removePreAndLowerFirst(CharSequence str, CharSequence prefix)` 去掉首部指定长度的字符串并将剩余字符串首字母小写例如：str=setName, prefix=set =》 return name
`static String`	`removePreAndLowerFirst(CharSequence str, int preLength)` 去掉首部指定长度的字符串并将剩余字符串首字母小写例如：str=setName, preLength=3 =》 return name
`static String`	`removePrefix(CharSequence str, CharSequence prefix)` 去掉指定前缀
`static String`	`removePrefixIgnoreCase(CharSequence str, CharSequence prefix)` 忽略大小写去掉指定前缀
`static String`	`removeStart(String str, String remove)` 删除指定字符串是否在开始位置，否则返回源字符串 A `null` source string will return `null`.
`static String`	`removeSuffix(CharSequence str, CharSequence suffix)` 去掉指定后缀
`static String`	`repeat(char c, int count)` 重复某个字符
`static String`	`repeat(CharSequence str, int count)` 重复某个字符串
`static String`	`replace(CharSequence str, CharSequence searchStr, CharSequence replacement)` 替换字符串中的指定字符串
`static String`	`replace(CharSequence str, CharSequence searchStr, CharSequence replacement, boolean ignoreCase)` 替换字符串中的指定字符串
`static String`	`replace(CharSequence str, int fromIndex, CharSequence searchStr, CharSequence replacement, boolean ignoreCase)` 替换字符串中的指定字符串
`static String`	`replace(CharSequence str, int startInclude, int endExclude, char replacedChar)` 替换指定字符串的指定区间内字符为固定字符
`static String`	`replaceBlank(String str)`
`static String`	`replaceChars(CharSequence str, char[] chars, CharSequence replacedStr)` 替换字符字符数组中所有的字符为replacedStr
`static String`	`replaceChars(CharSequence str, String chars, CharSequence replacedStr)` 替换字符字符数组中所有的字符为replacedStr 提供的chars为所有需要被替换的字符，例如："\r\n"，则"\r"和"\n"都会被替换，哪怕他们单独存在
`static String`	`replaceIgnoreCase(CharSequence str, CharSequence searchStr, CharSequence replacement)` 替换字符串中的指定字符串，忽略大小写
`static String`	`reverse(String str)` 反转字符串例如：abcd =》dcba
`static String`	`right(String str, int len)` Gets the rightmost `len` characters of a String.
`static String`	`rightPad(String str, int size, char padChar)` Right pad a String with a specified character.
`static String`	`rightPad(String str, int size, String padStr)` Right pad a String with a specified String.
`static List<String>`	`split(CharSequence str, char separator)` 切分字符串 a#b#c =》 [a,b,c] a##b#c =》 [a,"",b,c]
`static List<String>`	`split(CharSequence str, char separator, int limit)` 切分字符串，不去除切分后每个元素两边的空白符，不去除空白项
`static String[]`	`split(CharSequence str, CharSequence separator)` 切分字符串
`static String`	`split(String str)` 切分字符串
`static List<String>`	`split(String str, char separator)` 切分字符串，去除切分后每个元素两边的空白符，去除空白项
`static List<String>`	`split(String str, char separator, boolean isTrim, boolean ignoreEmpty)` 切分字符串
`static List<String>`	`split(String str, char separator, int limit, boolean isTrim, boolean ignoreEmpty)` 切分字符串，大小写敏感
`static List<String>`	`split(String str, char separator, int limit, boolean isTrim, boolean ignoreEmpty, boolean ignoreCase)` 切分字符串
`static String`	`split(String str, CharSequence separator, CharSequence reserve)` 切分字符串
`static List<String>`	`split(String str, int limit)` 使用空白符切分字符串切分后的字符串两边不包含空白符，空串或空白符串并不做为元素之一
`static List<String>`	`split(String str, Pattern separatorPattern, int limit, boolean isTrim, boolean ignoreEmpty)` 通过正则切分字符串
`static List<String>`	`split(String str, String separator, boolean isTrim, boolean ignoreEmpty)` 切分字符串，不忽略大小写
`static List<String>`	`split(String str, String separator, int limit, boolean isTrim, boolean ignoreEmpty)` 切分字符串，不忽略大小写
`static List<String>`	`split(String str, String separator, int limit, boolean isTrim, boolean ignoreEmpty, boolean ignoreCase)` 切分字符串
`static String[]`	`splitByLength(String text, int len)`
`static List<String>`	`splitByRegex(String str, String separatorRegex, int limit, boolean isTrim, boolean ignoreEmpty)` 通过正则切分字符串
`static List<String>`	`splitIgnoreCase(String str, char separator, int limit, boolean isTrim, boolean ignoreEmpty)` 切分字符串，忽略大小写
`static List<String>`	`splitIgnoreCase(String str, String separator, int limit, boolean isTrim, boolean ignoreEmpty)` 切分字符串，忽略大小写
`static List<String>`	`splitPath(String str)` 切分字符串路径，仅支持Unix分界符：/
`static List<String>`	`splitPath(String str, int limit)` 切分字符串路径，仅支持Unix分界符：/
`static String[]`	`splitPathToArray(String str)` 切分字符串路径，仅支持Unix分界符：/
`static String[]`	`splitPathToArray(String str, int limit)` 切分字符串路径，仅支持Unix分界符：/
`static String[]`	`splitToArray(CharSequence str, char separator, int limit)` 切分字符串
`static String[]`	`splitToArray(String str, char separator, int limit, boolean isTrim, boolean ignoreEmpty)` 切分字符串为字符串数组
`static String[]`	`splitToArray(String str, int limit)` 切分字符串为字符串数组
`static String[]`	`splitToArray(String str, Pattern separatorPattern, int limit, boolean isTrim, boolean ignoreEmpty)` 通过正则切分字符串为字符串数组
`static String[]`	`splitToArray(String str, String separator, int limit, boolean isTrim, boolean ignoreEmpty)` 切分字符串为字符串数组
`static List<String>`	`splitTrim(CharSequence str, char separator)` 切分字符串，去除切分后每个元素两边的空白符，去除空白项
`static List<String>`	`splitTrim(String str, char separator, boolean ignoreEmpty)` 切分字符串
`static List<String>`	`splitTrim(String str, char separator, int limit, boolean ignoreEmpty)` 切分字符串，大小写敏感，去除每个元素两边空白符
`static List<String>`	`splitTrim(String str, String separator, boolean ignoreEmpty)` 切分字符串，去除每个元素两边空格，忽略大小写
`static List<String>`	`splitTrim(String str, String separator, int limit, boolean ignoreEmpty)` 切分字符串，去除每个元素两边空格，忽略大小写
`static List<String>`	`splitTrimIgnoreCase(String str, String separator, int limit, boolean ignoreEmpty)` 切分字符串，去除每个元素两边空格，忽略大小写
`static boolean`	`startWith(CharSequence str, char c)` 字符串是否以给定字符开始
`static boolean`	`startWith(CharSequence str, CharSequence prefix)` 是否以指定字符串开头
`static boolean`	`startWith(CharSequence str, CharSequence prefix, boolean isIgnoreCase)` 是否以指定字符串开头如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
`static boolean`	`startWithIgnoreCase(CharSequence str, CharSequence prefix)` 是否以指定字符串开头，忽略大小写
`static String`	`str(byte[] data, Charset charset)` 解码字节码
`static String`	`str(Byte[] data, Charset charset)` 解码字节码
`static String`	`str(byte[] bytes, String charset)` 将byte数组转为字符串
`static String`	`str(Byte[] bytes, String charset)` 将Byte数组转为字符串
`static String`	`str(ByteBuffer data, Charset charset)` 将编码的byteBuffer数据转换为字符串
`static String`	`str(ByteBuffer data, String charset)` 将编码的byteBuffer数据转换为字符串
`static String`	`str(CharSequence cs)` `CharSequence` 转为字符串，null安全
`static String`	`str(Object obj, Charset charset)` 将对象转为字符串 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
`static String`	`str(Object obj, String charsetName)` 将对象转为字符串 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
`static StrBuilder`	`strBuilder()` 创建StrBuilder对象
`static StrBuilder`	`strBuilder(CharSequence... strs)` 创建StrBuilder对象
`static StrBuilder`	`strBuilder(int capacity)` 创建StrBuilder对象
`static String`	`strip(CharSequence str, CharSequence prefixOrSuffix)` 去除两边的指定字符串
`static String`	`strip(CharSequence str, CharSequence prefix, CharSequence suffix)` 去除两边的指定字符串
`static String`	`stripIgnoreCase(CharSequence str, CharSequence prefixOrSuffix)` 去除两边的指定字符串，忽略大小写
`static String`	`stripIgnoreCase(CharSequence str, CharSequence prefix, CharSequence suffix)` 去除两边的指定字符串，忽略大小写
`static String`	`sub(CharSequence str, int fromIndex, int toIndex)` 改进JDK subString index从0开始计算，最后一个字符为-1 如果from和to位置一样，返回 "" 如果from或to为负数，则按照length从后向前数位置，如果绝对值大于字符串长度，则from归到0，to归到length 如果经过修正的index中from大于to，则互换 abcdefgh 2 3 =》 c abcdefgh 2 -3 =》 cde
`static String`	`subAfter(CharSequence string, char separator, boolean isLastSeparator)` 截取分隔字符串之后的字符串，不包括分隔字符串如果给定的字符串为空串（null或""），返回原字符串如果分隔字符串为空串（null或""），则返回空串，如果分隔字符串未找到，返回空串，举例如下：
`static String`	`subAfter(CharSequence string, CharSequence separator, boolean isLastSeparator)` 截取分隔字符串之后的字符串，不包括分隔字符串如果给定的字符串为空串（null或""），返回原字符串如果分隔字符串为空串（null或""），则返回空串，如果分隔字符串未找到，返回空串，举例如下：
`static String`	`subBefore(CharSequence string, char separator, boolean isLastSeparator)` 截取分隔字符串之前的字符串，不包括分隔字符串如果给定的字符串为空串（null或""）或者分隔字符串为null，返回原字符串如果分隔字符串未找到，返回原字符串，举例如下：
`static String`	`subBefore(CharSequence string, CharSequence separator, boolean isLastSeparator)` 截取分隔字符串之前的字符串，不包括分隔字符串如果给定的字符串为空串（null或""）或者分隔字符串为null，返回原字符串如果分隔字符串为空串""，则返回空串，如果分隔字符串未找到，返回原字符串，举例如下：
`static String`	`subBetween(CharSequence str, CharSequence beforeAndAfter)` 截取指定字符串中间部分，不包括标识字符串
`static String`	`subBetween(CharSequence str, CharSequence before, CharSequence after)` 截取指定字符串中间部分，不包括标识字符串
`static String`	`subPre(CharSequence string, int toIndex)` 切割指定位置之前部分的字符串
`static String`	`substringAfterLast(String str, String separator)` Gets the substring after the last occurrence of a separator.
`static String`	`substringBeforeLast(String str, String separator)` Gets the substring before the last occurrence of a separator.
`static String`	`substringBetween(String str, String open, String close)`
`static String`	`subSuf(CharSequence string, int fromIndex)` 切割指定位置之后部分的字符串
`static String`	`swapCase(String str)` 切换给定字符串中的大小写。大写转小写，小写转大写。
`static String`	`toAES(String text, String token)` AES加密
`static String`	`toAES(String text, String token, String charset)` AES加密
`static String`	`toBase64(byte[] bts)` 将字节数据处理成base64字符串
`static String`	`toBase64(String oldStr)` 将String处理成base64字符串 (用默认的String编码集)
`static String`	`toBase64(String oldStr, String charset)` 将String处理成base64字符串 (用默认的String编码集)
`static String`	`toCamelCase(CharSequence name)` 将下划线方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。例如：hello_world=》helloWorld
`static String`	`toDES(String text, String token)` DES加密
`static String`	`toDES(String text, String token, String charset)` DES加密
`static String`	`toFullString(String input)` 转换为全角
`static String`	`toHalfString(String input)` 转换为半角
`static String`	`toMD5(byte[] data)` 将byte转换为MD5
`static String`	`toMD5(String data)` 将字符串转换为MD5
`static String`	`toMD5(String data, String charset)` 将字符串转换为MD5
`static String`	`toString(Class<?>[] parameterTypes)`
`static String`	`toString(Object obj)` 重写toString方法，处理了空指针问题 (默认如果对象为null则替换成"")
`static String`	`toString(Object obj, String defaultValue)` 重写toString方法，处理了空指针问题
`static String`	`toString(String[] values)`
`static String[]`	`toStringArray(Collection<String> collection)` Copy the given `Collection` into a `String` array.
`static String[]`	`toStringArray(Enumeration<String> enumeration)` Copy the given Enumeration into a `String` array.
`static String`	`toUnderlineCase(CharSequence camelCaseStr)` 将驼峰式命名的字符串转换为下划线方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。例如：HelloWorld=》hello_world
`static String`	`toUnicode(String input)` 将字符串转换为unicode编码
`static String`	`toUnicode(String str, boolean isSkipAscii)` 字符串编码为Unicode形式
`static String`	`toUrlStr(String input)` 将字符串转换为url参数形式(中文和特殊字符会以%xx表示)
`static String`	`toUrlStr(String input, String charset)` 将字符串转换为url参数形式(中文和特殊字符会以%xx表示)
`static String`	`trim(CharSequence str, int mode)` 除去字符串头尾部的空白符，如果字符串是null，依然返回null。
`static String`	`trim(String str)` 字符串去空格
`static String[]`	`trim(String[] array)` 分别去空格
`static String`	`trimToEmpty(String str)` Removes control characters (char <= 32) from both ends of this String returning an empty String ("") if the String is empty ("") after the trim or if it is `null`.
`static String`	`trimToNull(String str)` Removes control characters (char <= 32) from both ends of this String returning `null` if the String is empty ("") after the trim or if it is `null`.
`static String`	`uncapitalize(String str)`
`static String`	`unCompress(String val, String... charset)` 系统解压缩
`static String`	`unCompress2(String val, String... charset)` 自定义二级解压缩
`static String`	`unicodeToString(String input)` 将unicode编码还原为字符串
`static String`	`unicodeToString(String unicode, boolean isSkipAscii)` Unicode字符串转为普通字符串 Unicode字符串的表现方式为：\\uXXXX
`static String`	`unWrap(CharSequence str, char prefixAndSuffix)` 去掉字符包装，如果未被包装则返回原字符串
`static String`	`unWrap(CharSequence str, char prefix, char suffix)` 去掉字符包装，如果未被包装则返回原字符串
`static String`	`unWrap(CharSequence str, String prefix, String suffix)` 去掉字符包装，如果未被包装则返回原字符串
`static String`	`upperFirst(CharSequence str)` 大写首字母例如：str = name, return Name
`static String`	`upperFirstAndAddPre(CharSequence str, String preString)` 原字符串首字母大写并在其首部添加指定字符串例如：str=name, preString=get =》 return getName
`static String`	`urlStrToString(String input)` 将url参数形式的字符串转换为原始字符串(中文和特殊字符会以%xx表示)
`static String`	`urlStrToString(String input, String charset)` 将url参数形式的字符串转换为原始字符串(中文和特殊字符会以%xx表示)
`static String`	`utf8Str(Object obj)` 将对象转为字符串 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
`static String`	`wrap(CharSequence str, CharSequence prefixAndSuffix)` 包装指定字符串当前缀和后缀一致时使用此方法
`static String`	`wrap(CharSequence str, CharSequence prefix, CharSequence suffix)` 包装指定字符串
`static String[]`	`wrapAll(CharSequence prefixAndSuffix, CharSequence... strs)` 包装多个字符串
`static String[]`	`wrapAll(CharSequence prefix, CharSequence suffix, CharSequence... strs)` 包装多个字符串

Methods inherited from class org.aoju.bus.core.utils.TextUtils
append, append, append, append, append, append, charAt, clear, create, create, create, del, delTo, getChars, hasContent, insert, insert, insert, insert, insert, insert, isEmpty, length, reset, similar, similar, subSequence, subString, subString, toString, toString, toStringAndReset

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

Methods inherited from interface java.lang.CharSequence
chars, codePoints

- Field Detail
  - INDEX_NOT_FOUND
```
public static final int INDEX_NOT_FOUND
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - StringUtils
```
public StringUtils()
```
- Method Detail
  - trim
```
public static final String[] trim(String[] array)
```
    分别去空格
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    数组
  - trim
```
public static String trim(String str)
```
    字符串去空格
    
    Parameters:
    
    str - 原始字符串
    
    Returns:
    
    返回字符串
  - toString
```
public static String toString(Object obj)
```
    重写toString方法，处理了空指针问题 (默认如果对象为null则替换成"")
    
    Parameters:
    
    obj - String类型的Object对象
    
    Returns:
    
    转换后的字符串
  - toString
```
public static String toString(Object obj,
                              String defaultValue)
```
    重写toString方法，处理了空指针问题
    
    Parameters:
    
    obj - String类型的Object对象
    
    defaultValue - 如果obj是null，则以defaultValue的值返回
    
    Returns:
    
    转换后的字符串
  - isEmpty
```
public static boolean isEmpty(Object obj)
```
    校验对象是不是为null或者内容是""
    
    Parameters:
    
    obj - 字符串
    
    Returns:
    
    true/false
  - isNotEmpty
```
public static boolean isNotEmpty(String str)
```
  - isEmptyIfStr
```
public static boolean isEmptyIfStr(Object obj)
```
    如果对象是字符串是否为空串空的定义如下: 1、为null 2、为""
    
    Parameters:
    
    obj - 对象
    
    Returns:
    
    true/false
    
    Since:
    
    3.3.0
  - areNotEmpty
```
public static boolean areNotEmpty(String... values)
```
  - base64ToByte
```
public static byte[] base64ToByte(String str)
```
    将base64字符串处理成String字节
    
    Parameters:
    
    str - base64的字符串
    
    Returns:
    
    原字节数据
  - base64ToString
```
public static String base64ToString(String str)
```
    将base64字符串处理成String (用默认的String编码集)
    
    Parameters:
    
    str - base64的字符串
    
    Returns:
    
    可显示的字符串
  - base64ToString
```
public static String base64ToString(String str,
                                    String charset)
```
    将base64字符串处理成String (用默认的String编码集)
    
    Parameters:
    
    str - base64的字符串
    
    charset - 编码格式(UTF-8/GBK)
    
    Returns:
    
    可显示的字符串
  - toBase64
```
public static String toBase64(byte[] bts)
```
    将字节数据处理成base64字符串
    
    Parameters:
    
    bts - 字节数据
    
    Returns:
    
    base64编码后的字符串(用于传输)
  - toBase64
```
public static String toBase64(String oldStr)
```
    将String处理成base64字符串 (用默认的String编码集)
    
    Parameters:
    
    oldStr - 原字符串
    
    Returns:
    
    base64编码后的字符串(用于传输)
  - toBase64
```
public static String toBase64(String oldStr,
                              String charset)
```
    将String处理成base64字符串 (用默认的String编码集)
    
    Parameters:
    
    oldStr - 原字符串
    
    charset - 字符编码
    
    Returns:
    
    base64编码后的字符串(用于传输)
  - byteArrayToHex
```
public static String byteArrayToHex(byte[] byteArray)
```
    将字节数组换成16进制的字符串
    
    Parameters:
    
    byteArray - 字节数组
    
    Returns:
    
    string
  - hexStringToByte
```
public static byte[] hexStringToByte(String hex)
```
    bytes字符串转换为Byte值 src Byte字符串，每个Byte之间没有分隔符
    
    Parameters:
    
    hex - 字符串
    
    Returns:
    
    byte[]
  - toMD5
```
public static String toMD5(byte[] data)
```
    将byte转换为MD5
    
    Parameters:
    
    data - byte[]
    
    Returns:
    
    字符串
  - toMD5
```
public static String toMD5(String data)
```
    将字符串转换为MD5
    
    Parameters:
    
    data - String
    
    Returns:
    
    字符串
  - toMD5
```
public static String toMD5(String data,
                           String charset)
```
    将字符串转换为MD5
    
    Parameters:
    
    data - String
    
    charset - 字符集
    
    Returns:
    
    字符串
  - toFullString
```
public static String toFullString(String input)
```
    转换为全角
    
    Parameters:
    
    input - 需要转换的字符串
    
    Returns:
    
    全角字符串.
  - toHalfString
```
public static String toHalfString(String input)
```
    转换为半角
    
    Parameters:
    
    input - 需要转换的字符串
    
    Returns:
    
    半角字符串
  - toUnicode
```
public static String toUnicode(String input)
```
    将字符串转换为unicode编码
    
    Parameters:
    
    input - 要转换的字符串(主要是包含中文的字符串)
    
    Returns:
    
    转换后的unicode编码
  - toUnicode
```
public static String toUnicode(String str,
                               boolean isSkipAscii)
```
    字符串编码为Unicode形式
    
    Parameters:
    
    str - 被编码的字符串
    
    isSkipAscii - 是否跳过ASCII字符（只跳过可见字符）
    
    Returns:
    
    Unicode字符串
  - unicodeToString
```
public static String unicodeToString(String input)
```
    将unicode编码还原为字符串
    
    Parameters:
    
    input - unicode编码的字符串
    
    Returns:
    
    原始字符串
  - unicodeToString
```
public static String unicodeToString(String unicode,
                                     boolean isSkipAscii)
```
    Unicode字符串转为普通字符串 Unicode字符串的表现方式为：\\uXXXX
    
    Parameters:
    
    unicode - Unicode字符串
    
    isSkipAscii - 是跳过Ascii
    
    Returns:
    
    普通字符串
  - toUrlStr
```
public static String toUrlStr(String input)
```
    将字符串转换为url参数形式(中文和特殊字符会以%xx表示)
    
    Parameters:
    
    input - 字符串
    
    Returns:
    
    字符串
  - toUrlStr
```
public static String toUrlStr(String input,
                              String charset)
```
    将字符串转换为url参数形式(中文和特殊字符会以%xx表示)
    
    Parameters:
    
    input - 字符串
    
    charset - 编码
    
    Returns:
    
    字符串
  - urlStrToString
```
public static String urlStrToString(String input)
```
    将url参数形式的字符串转换为原始字符串(中文和特殊字符会以%xx表示)
    
    Parameters:
    
    input - 字符串
    
    Returns:
    
    字符串
  - urlStrToString
```
public static String urlStrToString(String input,
                                    String charset)
```
    将url参数形式的字符串转换为原始字符串(中文和特殊字符会以%xx表示)
    
    Parameters:
    
    input - 字符串
    
    charset - 编码
    
    Returns:
    
    字符串
  - toDES
```
public static String toDES(String text,
                           String token,
                           String charset)
```
    DES加密
    
    Parameters:
    
    text - 要加密的数据
    
    token - 约定密串
    
    charset - 原文的编码集
    
    Returns:
    
    加密后的密文
  - toDES
```
public static String toDES(String text,
                           String token)
```
    DES加密
    
    Parameters:
    
    text - 要加密的数据
    
    token - 约定密串
    
    Returns:
    
    加密后的密文
  - DESToString
```
public static String DESToString(String text,
                                 String token,
                                 String charset)
```
    DES解密
    
    Parameters:
    
    text - 要加密的数据
    
    token - 约定密串
    
    charset - 原文的编码集
    
    Returns:
    
    原文字符串
  - DESToString
```
public static String DESToString(String text,
                                 String token)
```
    DES解密
    
    Parameters:
    
    text - 要加密的数据
    
    token - 约定密串
    
    Returns:
    
    原文字符串
  - toAES
```
public static String toAES(String text,
                           String token,
                           String charset)
```
    AES加密
    
    Parameters:
    
    text - 要加密的数据
    
    token - 约定密串
    
    charset - 原数据字符集
    
    Returns:
    
    加密后的密文
  - toAES
```
public static String toAES(String text,
                           String token)
```
    AES加密
    
    Parameters:
    
    text - 要加密的数据
    
    token - 约定密串
    
    Returns:
    
    加密后的密文
  - AESToString
```
public static String AESToString(String text,
                                 String token,
                                 String charset)
```
    AES解密
    
    Parameters:
    
    text - 要加密的数据
    
    token - 约定密串
    
    charset - 原数据字符集
    
    Returns:
    
    解密后的原文
  - AESToString
```
public static String AESToString(String text,
                                 String token)
```
    AES解密
    
    Parameters:
    
    text - 要加密的数据
    
    token - 约定密串
    
    Returns:
    
    解密后的原文
  - compress2
```
public static String compress2(byte[] bts)
```
    自定义二级压缩(最终显示为base64后的串)
    
    Parameters:
    
    bts - 原始字符串
    
    Returns:
    
    压缩后的字符串
  - compress2
```
public static String compress2(String val,
                               String... charset)
```
    自定义二级压缩(最终显示为base64后的串)
    
    Parameters:
    
    val - 原始字符串
    
    charset - 字符编码
    
    Returns:
    
    压缩后的字符串
  - unCompress2
```
public static String unCompress2(String val,
                                 String... charset)
```
    自定义二级解压缩
    
    Parameters:
    
    val - base64后的压缩数据
    
    charset - 字符编码
    
    Returns:
    
    解压后的原数据
  - compress
```
public static String compress(byte[] bytes)
```
    系统压缩(返回base64后的压缩数据)
    
    Parameters:
    
    bytes - 字节
    
    Returns:
    
    string
  - compress
```
public static String compress(String val,
                              String... charset)
```
    系统压缩(返回base64后的压缩数据)
    
    Parameters:
    
    val - 字符
    
    charset - 编码
    
    Returns:
    
    string
  - unCompress
```
public static String unCompress(String val,
                                String... charset)
```
    系统解压缩
    
    Parameters:
    
    val - 字符
    
    charset - 编码
    
    Returns:
    
    string
  - isNotBlank
```
public static boolean isNotBlank(CharSequence cs)
```
  - isBlank
```
public static boolean isBlank(CharSequence cs)
```
  - substringBetween
```
public static String substringBetween(String str,
                                      String open,
                                      String close)
```
  - equals
```
public static boolean equals(CharSequence str1,
                             CharSequence str2)
```
    比较两个字符串（大小写敏感）。
```
 equals(null, null)   = true
 equals(null, "abc")  = false
 equals("abc", null)  = false
 equals("abc", "abc") = true
 equals("abc", "ABC") = false
 
```
    Parameters:
    
    str1 - 要比较的字符串1
    
    str2 - 要比较的字符串2
    
    Returns:
    
    如果两个字符串相同，或者都是null，则返回true
  - equalsIgnoreCase
```
public static boolean equalsIgnoreCase(CharSequence str1,
                                       CharSequence str2)
```
    比较两个字符串（大小写不敏感）。
```
 equalsIgnoreCase(null, null)   = true
 equalsIgnoreCase(null, "abc")  = false
 equalsIgnoreCase("abc", null)  = false
 equalsIgnoreCase("abc", "abc") = true
 equalsIgnoreCase("abc", "ABC") = true
 
```
    Parameters:
    
    str1 - 要比较的字符串1
    
    str2 - 要比较的字符串2
    
    Returns:
    
    如果两个字符串相同，或者都是null，则返回true
  - equals
```
public static boolean equals(CharSequence str1,
                             CharSequence str2,
                             boolean ignoreCase)
```
    比较两个字符串是否相等。
    
    Parameters:
    
    str1 - 要比较的字符串1
    
    str2 - 要比较的字符串2
    
    ignoreCase - 是否忽略大小写
    
    Returns:
    
    如果两个字符串相同，或者都是null，则返回true
    
    Since:
    
    3.2.0
  - format
```
public static String format(String val,
                            Object... argArray)
```
    格式化字符串此方法只是简单将占位符 {} 按照顺序替换为参数如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可例：通常使用：format("this is {} for {}", "a", "b") =》 this is a for b 转义{}： format("this is \\{} for {}", "a", "b") =》 this is \{} for a 转义\： format("this is \\\\{} for {}", "a", "b") =》 this is \a for b
    
    Parameters:
    
    val - 字符串模板
    
    argArray - 参数列表
    
    Returns:
    
    结果
  - utf8Str
```
public static String utf8Str(Object obj)
```
    将对象转为字符串 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
    
    Parameters:
    
    obj - 对象
    
    Returns:
    
    字符串
  - str
```
public static String str(Object obj,
                         String charsetName)
```
    将对象转为字符串 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
    
    Parameters:
    
    obj - 对象
    
    charsetName - 字符集
    
    Returns:
    
    字符串
  - str
```
public static String str(Object obj,
                         Charset charset)
```
    将对象转为字符串 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
    
    Parameters:
    
    obj - 对象
    
    charset - 字符集
    
    Returns:
    
    字符串
  - str
```
public static String str(byte[] bytes,
                         String charset)
```
    将byte数组转为字符串
    
    Parameters:
    
    bytes - byte数组
    
    charset - 字符集
    
    Returns:
    
    字符串
  - str
```
public static String str(byte[] data,
                         Charset charset)
```
    解码字节码
    
    Parameters:
    
    data - 字符串
    
    charset - 字符集，如果此字段为空，则解码的结果取决于平台
    
    Returns:
    
    解码后的字符串
  - str
```
public static String str(Byte[] bytes,
                         String charset)
```
    将Byte数组转为字符串
    
    Parameters:
    
    bytes - byte数组
    
    charset - 字符集
    
    Returns:
    
    字符串
  - str
```
public static String str(Byte[] data,
                         Charset charset)
```
    解码字节码
    
    Parameters:
    
    data - 字符串
    
    charset - 字符集，如果此字段为空，则解码的结果取决于平台
    
    Returns:
    
    解码后的字符串
  - str
```
public static String str(ByteBuffer data,
                         String charset)
```
    将编码的byteBuffer数据转换为字符串
    
    Parameters:
    
    data - 数据
    
    charset - 字符集，如果为空使用当前系统字符集
    
    Returns:
    
    字符串
  - str
```
public static String str(ByteBuffer data,
                         Charset charset)
```
    将编码的byteBuffer数据转换为字符串
    
    Parameters:
    
    data - 数据
    
    charset - 字符集，如果为空使用当前系统字符集
    
    Returns:
    
    字符串
  - str
```
public static String str(CharSequence cs)
```
    CharSequence 转为字符串，null安全
    
    Parameters:
    
    cs - CharSequence
    
    Returns:
    
    字符串
  - subPre
```
public static String subPre(CharSequence string,
                            int toIndex)
```
    切割指定位置之前部分的字符串
    
    Parameters:
    
    string - 字符串
    
    toIndex - 切割到的位置（不包括）
    
    Returns:
    
    切割后的剩余的前半部分字符串
  - subSuf
```
public static String subSuf(CharSequence string,
                            int fromIndex)
```
    切割指定位置之后部分的字符串
    
    Parameters:
    
    string - 字符串
    
    fromIndex - 切割开始的位置（包括）
    
    Returns:
    
    切割后后剩余的后半部分字符串
  - sub
```
public static String sub(CharSequence str,
                         int fromIndex,
                         int toIndex)
```
    改进JDK subString index从0开始计算，最后一个字符为-1 如果from和to位置一样，返回 "" 如果from或to为负数，则按照length从后向前数位置，如果绝对值大于字符串长度，则from归到0，to归到length 如果经过修正的index中from大于to，则互换 abcdefgh 2 3 =》 c abcdefgh 2 -3 =》 cde
    
    Parameters:
    
    str - String
    
    fromIndex - 开始的index（包括）
    
    toIndex - 结束的index（不包括）
    
    Returns:
    
    字串
  - splitPath
```
public static List<String> splitPath(String str)
```
    切分字符串路径，仅支持Unix分界符：/
    
    Parameters:
    
    str - 被切分的字符串
    
    Returns:
    
    切分后的集合
  - splitPath
```
public static List<String> splitPath(String str,
                                     int limit)
```
    切分字符串路径，仅支持Unix分界符：/
    
    Parameters:
    
    str - 被切分的字符串
    
    limit - 限制分片数
    
    Returns:
    
    切分后的集合
  - splitPathToArray
```
public static String[] splitPathToArray(String str)
```
    切分字符串路径，仅支持Unix分界符：/
    
    Parameters:
    
    str - 被切分的字符串
    
    Returns:
    
    切分后的集合
  - splitPathToArray
```
public static String[] splitPathToArray(String str,
                                        int limit)
```
    切分字符串路径，仅支持Unix分界符：/
    
    Parameters:
    
    str - 被切分的字符串
    
    limit - 限制分片数
    
    Returns:
    
    切分后的集合
  - splitTrim
```
public static List<String> splitTrim(CharSequence str,
                                     char separator)
```
    切分字符串，去除切分后每个元素两边的空白符，去除空白项
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    Returns:
    
    切分后的集合
    
    Since:
    
    3.1.2
  - splitTrim
```
public static List<String> splitTrim(String str,
                                     char separator,
                                     boolean ignoreEmpty)
```
    切分字符串
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    ignoreEmpty - 是否忽略空串
    
    Returns:
    
    切分后的集合
    
    Since:
    
    3.2.1
  - splitTrim
```
public static List<String> splitTrim(String str,
                                     String separator,
                                     boolean ignoreEmpty)
```
    切分字符串，去除每个元素两边空格，忽略大小写
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符串
    
    ignoreEmpty - 是否忽略空串
    
    Returns:
    
    切分后的集合
    
    Since:
    
    3.2.1
  - splitTrim
```
public static List<String> splitTrim(String str,
                                     char separator,
                                     int limit,
                                     boolean ignoreEmpty)
```
    切分字符串，大小写敏感，去除每个元素两边空白符
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    limit - 限制分片数，-1不限制
    
    ignoreEmpty - 是否忽略空串
    
    Returns:
    
    切分后的集合
  - splitTrim
```
public static List<String> splitTrim(String str,
                                     String separator,
                                     int limit,
                                     boolean ignoreEmpty)
```
    切分字符串，去除每个元素两边空格，忽略大小写
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符串
    
    limit - 限制分片数
    
    ignoreEmpty - 是否忽略空串
    
    Returns:
    
    切分后的集合
    
    Since:
    
    3.2.1
  - splitIgnoreCase
```
public static List<String> splitIgnoreCase(String str,
                                           char separator,
                                           int limit,
                                           boolean isTrim,
                                           boolean ignoreEmpty)
```
    切分字符串，忽略大小写
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    limit - 限制分片数，-1不限制
    
    isTrim - 是否去除切分字符串后每个元素两边的空格
    
    ignoreEmpty - 是否忽略空串
    
    Returns:
    
    切分后的集合
    
    Since:
    
    3.2.1
  - splitIgnoreCase
```
public static List<String> splitIgnoreCase(String str,
                                           String separator,
                                           int limit,
                                           boolean isTrim,
                                           boolean ignoreEmpty)
```
    切分字符串，忽略大小写
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符串
    
    limit - 限制分片数
    
    isTrim - 是否去除切分字符串后每个元素两边的空格
    
    ignoreEmpty - 是否忽略空串
    
    Returns:
    
    切分后的集合
    
    Since:
    
    3.2.1
  - splitTrimIgnoreCase
```
public static List<String> splitTrimIgnoreCase(String str,
                                               String separator,
                                               int limit,
                                               boolean ignoreEmpty)
```
    切分字符串，去除每个元素两边空格，忽略大小写
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符串
    
    limit - 限制分片数
    
    ignoreEmpty - 是否忽略空串
    
    Returns:
    
    切分后的集合
    
    Since:
    
    3.2.1
  - splitToArray
```
public static String[] splitToArray(CharSequence str,
                                    char separator,
                                    int limit)
```
    切分字符串
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    limit - 限制分片数
    
    Returns:
    
    切分后的集合
  - splitToArray
```
public static String[] splitToArray(String str,
                                    int limit)
```
    切分字符串为字符串数组
    
    Parameters:
    
    str - 被切分的字符串
    
    limit - 限制分片数
    
    Returns:
    
    切分后的集合
  - splitToArray
```
public static String[] splitToArray(String str,
                                    char separator,
                                    int limit,
                                    boolean isTrim,
                                    boolean ignoreEmpty)
```
    切分字符串为字符串数组
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    limit - 限制分片数
    
    isTrim - 是否去除切分字符串后每个元素两边的空格
    
    ignoreEmpty - 是否忽略空串
    
    Returns:
    
    切分后的集合
  - splitToArray
```
public static String[] splitToArray(String str,
                                    String separator,
                                    int limit,
                                    boolean isTrim,
                                    boolean ignoreEmpty)
```
    切分字符串为字符串数组
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    limit - 限制分片数
    
    isTrim - 是否去除切分字符串后每个元素两边的空格
    
    ignoreEmpty - 是否忽略空串
    
    Returns:
    
    切分后的集合
  - splitToArray
```
public static String[] splitToArray(String str,
                                    Pattern separatorPattern,
                                    int limit,
                                    boolean isTrim,
                                    boolean ignoreEmpty)
```
    通过正则切分字符串为字符串数组
    
    Parameters:
    
    str - 被切分的字符串
    
    separatorPattern - 分隔符正则Pattern
    
    limit - 限制分片数
    
    isTrim - 是否去除切分字符串后每个元素两边的空格
    
    ignoreEmpty - 是否忽略空串
    
    Returns:
    
    切分后的集合
  - splitByRegex
```
public static List<String> splitByRegex(String str,
                                        String separatorRegex,
                                        int limit,
                                        boolean isTrim,
                                        boolean ignoreEmpty)
```
    通过正则切分字符串
    
    Parameters:
    
    str - 字符串
    
    separatorRegex - 分隔符正则
    
    limit - 限制分片数
    
    isTrim - 是否去除切分字符串后每个元素两边的空格
    
    ignoreEmpty - 是否忽略空串
    
    Returns:
    
    切分后的集合
  - splitByLength
```
public static String[] splitByLength(String text,
                                     int len)
```
    Parameters:
    
    text - 每字符串
    
    len - 每一个小节的长度
    
    Returns:
    
    截取后的字符串数组
  - split
```
public static String split(String str)
```
    切分字符串
    
    Parameters:
    
    str - 被切分的字符串
    
    Returns:
    
    字符串
  - split
```
public static String split(String str,
                           CharSequence separator,
                           CharSequence reserve)
```
    切分字符串
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符
    
    reserve - 替换后的分隔符
    
    Returns:
    
    字符串
  - split
```
public static String[] split(CharSequence str,
                             CharSequence separator)
```
    切分字符串
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符
    
    Returns:
    
    字符串
  - split
```
public static List<String> split(String str,
                                 char separator)
```
    切分字符串，去除切分后每个元素两边的空白符，去除空白项
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    Returns:
    
    切分后的集合
    
    Since:
    
    3.1.2
  - split
```
public static List<String> split(CharSequence str,
                                 char separator)
```
    切分字符串 a#b#c =》 [a,b,c] a##b#c =》 [a,"",b,c]
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    Returns:
    
    切分后的集合
  - split
```
public static List<String> split(String str,
                                 int limit)
```
    使用空白符切分字符串切分后的字符串两边不包含空白符，空串或空白符串并不做为元素之一
    
    Parameters:
    
    str - 被切分的字符串
    
    limit - 限制分片数
    
    Returns:
    
    切分后的集合
  - split
```
public static List<String> split(CharSequence str,
                                 char separator,
                                 int limit)
```
    切分字符串，不去除切分后每个元素两边的空白符，不去除空白项
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    limit - 限制分片数，-1不限制
    
    Returns:
    
    切分后的集合
  - split
```
public static List<String> split(String str,
                                 char separator,
                                 boolean isTrim,
                                 boolean ignoreEmpty)
```
    切分字符串
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    isTrim - 是否去除切分字符串后每个元素两边的空格
    
    ignoreEmpty - 是否忽略空串
    
    Returns:
    
    切分后的集合
  - split
```
public static List<String> split(String str,
                                 String separator,
                                 boolean isTrim,
                                 boolean ignoreEmpty)
```
    切分字符串，不忽略大小写
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符串
    
    isTrim - 是否去除切分字符串后每个元素两边的空格
    
    ignoreEmpty - 是否忽略空串
    
    Returns:
    
    切分后的集合
  - split
```
public static List<String> split(String str,
                                 char separator,
                                 int limit,
                                 boolean isTrim,
                                 boolean ignoreEmpty)
```
    切分字符串，大小写敏感
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    limit - 限制分片数，-1不限制
    
    isTrim - 是否去除切分字符串后每个元素两边的空格
    
    ignoreEmpty - 是否忽略空串
    
    Returns:
    
    切分后的集合
  - split
```
public static List<String> split(String str,
                                 String separator,
                                 int limit,
                                 boolean isTrim,
                                 boolean ignoreEmpty)
```
    切分字符串，不忽略大小写
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符串
    
    limit - 限制分片数
    
    isTrim - 是否去除切分字符串后每个元素两边的空格
    
    ignoreEmpty - 是否忽略空串
    
    Returns:
    
    切分后的集合
  - split
```
public static List<String> split(String str,
                                 Pattern separatorPattern,
                                 int limit,
                                 boolean isTrim,
                                 boolean ignoreEmpty)
```
    通过正则切分字符串
    
    Parameters:
    
    str - 字符串
    
    separatorPattern - 分隔符正则Pattern
    
    limit - 限制分片数
    
    isTrim - 是否去除切分字符串后每个元素两边的空格
    
    ignoreEmpty - 是否忽略空串
    
    Returns:
    
    切分后的集合
  - split
```
public static List<String> split(String str,
                                 char separator,
                                 int limit,
                                 boolean isTrim,
                                 boolean ignoreEmpty,
                                 boolean ignoreCase)
```
    切分字符串
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    limit - 限制分片数，-1不限制
    
    isTrim - 是否去除切分字符串后每个元素两边的空格
    
    ignoreEmpty - 是否忽略空串
    
    ignoreCase - 是否忽略大小写
    
    Returns:
    
    切分后的集合
    
    Since:
    
    3.2.1
  - split
```
public static List<String> split(String str,
                                 String separator,
                                 int limit,
                                 boolean isTrim,
                                 boolean ignoreEmpty,
                                 boolean ignoreCase)
```
    切分字符串
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符串
    
    limit - 限制分片数
    
    isTrim - 是否去除切分字符串后每个元素两边的空格
    
    ignoreEmpty - 是否忽略空串
    
    ignoreCase - 是否忽略大小写
    
    Returns:
    
    切分后的集合
    
    Since:
    
    3.2.1
  - isEmpty
```
public static boolean isEmpty(Collection<?> collection)
```
    集合是否为空
    
    Parameters:
    
    collection - 集合
    
    Returns:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(Map<?,?> map)
```
    Map是否为空
    
    Parameters:
    
    map - 集合
    
    Returns:
    
    是否为空
  - contains
```
public static boolean contains(CharSequence str,
                               char searchChar)
```
    指定字符是否在字符串中出现过
    
    Parameters:
    
    str - 字符串
    
    searchChar - 被查找的字符
    
    Returns:
    
    是否包含
    
    Since:
    
    3.1.2
  - trim
```
public static String trim(CharSequence str,
                          int mode)
```
    除去字符串头尾部的空白符，如果字符串是null，依然返回null。
    
    Parameters:
    
    str - 要处理的字符串
    
    mode - -1表示trimStart，0表示trim全部， 1表示trimEnd
    
    Returns:
    
    除去指定字符后的的字符串，如果原字串为null，则返回null
  - startWith
```
public static boolean startWith(CharSequence str,
                                char c)
```
    字符串是否以给定字符开始
    
    Parameters:
    
    str - 字符串
    
    c - 字符
    
    Returns:
    
    是否开始
  - startWith
```
public static boolean startWith(CharSequence str,
                                CharSequence prefix,
                                boolean isIgnoreCase)
```
    是否以指定字符串开头如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
    
    Parameters:
    
    str - 被监测字符串
    
    prefix - 开头字符串
    
    isIgnoreCase - 是否忽略大小写
    
    Returns:
    
    是否以指定字符串开头
  - startWith
```
public static boolean startWith(CharSequence str,
                                CharSequence prefix)
```
    是否以指定字符串开头
    
    Parameters:
    
    str - 被监测字符串
    
    prefix - 开头字符串
    
    Returns:
    
    是否以指定字符串开头
  - startWithIgnoreCase
```
public static boolean startWithIgnoreCase(CharSequence str,
                                          CharSequence prefix)
```
    是否以指定字符串开头，忽略大小写
    
    Parameters:
    
    str - 被监测字符串
    
    prefix - 开头字符串
    
    Returns:
    
    是否以指定字符串开头
  - capitalize
```
public static String capitalize(String str)
```
  - uncapitalize
```
public static String uncapitalize(String str)
```
  - indexOf
```
public static int indexOf(CharSequence str,
                          char searchChar)
```
    指定范围内查找指定字符
    
    Parameters:
    
    str - 字符串
    
    searchChar - 被查找的字符
    
    Returns:
    
    位置
  - indexOf
```
public static int indexOf(CharSequence str,
                          char searchChar,
                          int start)
```
    指定范围内查找指定字符
    
    Parameters:
    
    str - 字符串
    
    searchChar - 被查找的字符
    
    start - 起始位置，如果小于0，从0开始查找
    
    Returns:
    
    位置
  - indexOf
```
public static int indexOf(CharSequence str,
                          char searchChar,
                          int start,
                          int end)
```
    指定范围内查找指定字符
    
    Parameters:
    
    str - 字符串
    
    searchChar - 被查找的字符
    
    start - 起始位置，如果小于0，从0开始查找
    
    end - 终止位置，如果超过str.length()则默认查找到字符串末尾
    
    Returns:
    
    位置
  - indexOfIgnoreCase
```
public static int indexOfIgnoreCase(CharSequence str,
                                    CharSequence searchStr)
```
    指定范围内查找字符串，忽略大小写
```
 StringUtils.indexOfIgnoreCase(null, *, *)          = -1
 StringUtils.indexOfIgnoreCase(*, null, *)          = -1
 StringUtils.indexOfIgnoreCase("", "", 0)           = 0
 StringUtils.indexOfIgnoreCase("aabaabaa", "A", 0)  = 0
 StringUtils.indexOfIgnoreCase("aabaabaa", "B", 0)  = 2
 StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 0) = 1
 StringUtils.indexOfIgnoreCase("aabaabaa", "B", 3)  = 5
 StringUtils.indexOfIgnoreCase("aabaabaa", "B", 9)  = -1
 StringUtils.indexOfIgnoreCase("aabaabaa", "B", -1) = 2
 StringUtils.indexOfIgnoreCase("aabaabaa", "", 2)   = 2
 StringUtils.indexOfIgnoreCase("abc", "", 9)        = -1
 
```
    Parameters:
    
    str - 字符串
    
    searchStr - 需要查找位置的字符串
    
    Returns:
    
    位置
    
    Since:
    
    3.2.1
  - indexOfIgnoreCase
```
public static int indexOfIgnoreCase(CharSequence str,
                                    CharSequence searchStr,
                                    int fromIndex)
```
    指定范围内查找字符串
```
 StringUtils.indexOfIgnoreCase(null, *, *)          = -1
 StringUtils.indexOfIgnoreCase(*, null, *)          = -1
 StringUtils.indexOfIgnoreCase("", "", 0)           = 0
 StringUtils.indexOfIgnoreCase("aabaabaa", "A", 0)  = 0
 StringUtils.indexOfIgnoreCase("aabaabaa", "B", 0)  = 2
 StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 0) = 1
 StringUtils.indexOfIgnoreCase("aabaabaa", "B", 3)  = 5
 StringUtils.indexOfIgnoreCase("aabaabaa", "B", 9)  = -1
 StringUtils.indexOfIgnoreCase("aabaabaa", "B", -1) = 2
 StringUtils.indexOfIgnoreCase("aabaabaa", "", 2)   = 2
 StringUtils.indexOfIgnoreCase("abc", "", 9)        = -1
 
```
    Parameters:
    
    str - 字符串
    
    searchStr - 需要查找位置的字符串
    
    fromIndex - 起始位置
    
    Returns:
    
    位置
    
    Since:
    
    3.2.1
  - indexOf
```
public static int indexOf(CharSequence str,
                          CharSequence searchStr,
                          int fromIndex,
                          boolean ignoreCase)
```
    指定范围内反向查找字符串
    
    Parameters:
    
    str - 字符串
    
    searchStr - 需要查找位置的字符串
    
    fromIndex - 起始位置
    
    ignoreCase - 是否忽略大小写
    
    Returns:
    
    位置
    
    Since:
    
    3.2.1
  - lastIndexOfIgnoreCase
```
public static int lastIndexOfIgnoreCase(CharSequence str,
                                        CharSequence searchStr)
```
    指定范围内查找字符串，忽略大小写
    
    Parameters:
    
    str - 字符串
    
    searchStr - 需要查找位置的字符串
    
    Returns:
    
    位置
    
    Since:
    
    3.2.1
  - lastIndexOfIgnoreCase
```
public static int lastIndexOfIgnoreCase(CharSequence str,
                                        CharSequence searchStr,
                                        int fromIndex)
```
    指定范围内查找字符串，忽略大小写
    
    Parameters:
    
    str - 字符串
    
    searchStr - 需要查找位置的字符串
    
    fromIndex - 起始位置，从后往前计数
    
    Returns:
    
    位置
    
    Since:
    
    3.2.1
  - lastIndexOf
```
public static int lastIndexOf(CharSequence str,
                              CharSequence searchStr,
                              int fromIndex,
                              boolean ignoreCase)
```
    指定范围内查找字符串
    
    Parameters:
    
    str - 字符串
    
    searchStr - 需要查找位置的字符串
    
    fromIndex - 起始位置，从后往前计数
    
    ignoreCase - 是否忽略大小写
    
    Returns:
    
    位置
    
    Since:
    
    3.2.1
  - ordinalIndexOf
```
public static int ordinalIndexOf(String str,
                                 String searchStr,
                                 int ordinal)
```
    返回字符串 searchStr 在字符串 str 中第 ordinal 次出现的位置。如果 str=null 或 searchStr=null 或 ordinal小于等于0 则返回-1
```
 StringUtils.ordinalIndexOf(null, *, *)          = -1
 StringUtils.ordinalIndexOf(*, null, *)          = -1
 StringUtils.ordinalIndexOf("", "", *)           = 0
 StringUtils.ordinalIndexOf("aabaabaa", "a", 1)  = 0
 StringUtils.ordinalIndexOf("aabaabaa", "a", 2)  = 1
 StringUtils.ordinalIndexOf("aabaabaa", "b", 1)  = 2
 StringUtils.ordinalIndexOf("aabaabaa", "b", 2)  = 5
 StringUtils.ordinalIndexOf("aabaabaa", "ab", 1) = 1
 StringUtils.ordinalIndexOf("aabaabaa", "ab", 2) = 4
 StringUtils.ordinalIndexOf("aabaabaa", "", 1)   = 0
 StringUtils.ordinalIndexOf("aabaabaa", "", 2)   = 0
 
```
    Parameters:
    
    str - 被检查的字符串，可以为null
    
    searchStr - 被查找的字符串，可以为null
    
    ordinal - 第几次出现的位置
    
    Returns:
    
    查找到的位置
    
    Since:
    
    3.2.3
  - isSubEquals
```
public static boolean isSubEquals(CharSequence str1,
                                  int start1,
                                  CharSequence str2,
                                  int start2,
                                  int length,
                                  boolean ignoreCase)
```
    截取两个字符串的不同部分（长度一致），判断截取的子串是否相同任意一个字符串为null返回false
    
    Parameters:
    
    str1 - 第一个字符串
    
    start1 - 第一个字符串开始的位置
    
    str2 - 第二个字符串
    
    start2 - 第二个字符串开始的位置
    
    length - 截取长度
    
    ignoreCase - 是否忽略大小写
    
    Returns:
    
    子串是否相同
    
    Since:
    
    3.2.1
  - hasBlank
```
public static boolean hasBlank(CharSequence... strs)
```
    是否包含空字符串
    
    Parameters:
    
    strs - 字符串列表
    
    Returns:
    
    是否包含空字符串
  - repeat
```
public static String repeat(char c,
                            int count)
```
    重复某个字符
    
    Parameters:
    
    c - 被重复的字符
    
    count - 重复的数目，如果小于等于0则返回""
    
    Returns:
    
    重复字符字符串
  - repeat
```
public static String repeat(CharSequence str,
                            int count)
```
    重复某个字符串
    
    Parameters:
    
    str - 被重复的字符
    
    count - 重复的数目
    
    Returns:
    
    重复字符字符串
  - reverse
```
public static String reverse(String str)
```
    反转字符串例如：abcd =》dcba
    
    Parameters:
    
    str - 被反转的字符串
    
    Returns:
    
    反转后的字符串
    
    Since:
    
    3.0.9
  - bytes
```
public static byte[] bytes(CharSequence str)
```
    编码字符串使用系统默认编码
    
    Parameters:
    
    str - 字符串
    
    Returns:
    
    编码后的字节码
  - bytes
```
public static byte[] bytes(CharSequence str,
                           String charset)
```
    编码字符串
    
    Parameters:
    
    str - 字符串
    
    charset - 字符集，如果此字段为空，则解码的结果取决于平台
    
    Returns:
    
    编码后的字节码
  - bytes
```
public static byte[] bytes(CharSequence str,
                           Charset charset)
```
    编码字符串
    
    Parameters:
    
    str - 字符串
    
    charset - 字符集，如果此字段为空，则解码的结果取决于平台
    
    Returns:
    
    编码后的字节码
  - toUnderlineCase
```
public static String toUnderlineCase(CharSequence camelCaseStr)
```
    将驼峰式命名的字符串转换为下划线方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。例如：HelloWorld=》hello_world
    
    Parameters:
    
    camelCaseStr - 转换前的驼峰式命名的字符串
    
    Returns:
    
    转换后下划线大写方式命名的字符串
  - removePreAndLowerFirst
```
public static String removePreAndLowerFirst(CharSequence str,
                                            int preLength)
```
    去掉首部指定长度的字符串并将剩余字符串首字母小写例如：str=setName, preLength=3 =》 return name
    
    Parameters:
    
    str - 被处理的字符串
    
    preLength - 去掉的长度
    
    Returns:
    
    处理后的字符串，不符合规范返回null
  - removePreAndLowerFirst
```
public static String removePreAndLowerFirst(CharSequence str,
                                            CharSequence prefix)
```
    去掉首部指定长度的字符串并将剩余字符串首字母小写例如：str=setName, prefix=set =》 return name
    
    Parameters:
    
    str - 被处理的字符串
    
    prefix - 前缀
    
    Returns:
    
    处理后的字符串，不符合规范返回null
  - upperFirstAndAddPre
```
public static String upperFirstAndAddPre(CharSequence str,
                                         String preString)
```
    原字符串首字母大写并在其首部添加指定字符串例如：str=name, preString=get =》 return getName
    
    Parameters:
    
    str - 被处理的字符串
    
    preString - 添加的首部
    
    Returns:
    
    处理后的字符串
  - upperFirst
```
public static String upperFirst(CharSequence str)
```
    大写首字母例如：str = name, return Name
    
    Parameters:
    
    str - 字符串
    
    Returns:
    
    字符串
  - lowerFirst
```
public static String lowerFirst(CharSequence str)
```
    小写首字母例如：str = Name, return name
    
    Parameters:
    
    str - 字符串
    
    Returns:
    
    字符串
  - substringBeforeLast
```
public static String substringBeforeLast(String str,
                                         String separator)
```
    Gets the substring before the last occurrence of a separator. The separator is not returned.
    
    Parameters:
    
    str - the String to get a substring from, may be null
    
    separator - the String to search for, may be null
    
    Returns:
    
    the substring before the last occurrence of the separator,
  - substringAfterLast
```
public static String substringAfterLast(String str,
                                        String separator)
```
    Gets the substring after the last occurrence of a separator. The separator is not returned.
    
    Parameters:
    
    str - the String to get a substring from, may be null
    
    separator - the String to search for, may be null
    
    Returns:
    
    the substring after the last occurrence of the separator,
  - toCamelCase
```
public static String toCamelCase(CharSequence name)
```
    将下划线方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。例如：hello_world=》helloWorld
    
    Parameters:
    
    name - 转换前的下划线大写方式命名的字符串
    
    Returns:
    
    转换后的驼峰式命名的字符串
  - nullToEmpty
```
public static String nullToEmpty(CharSequence str)
```
    当给定字符串为null时，转换为Empty
    
    Parameters:
    
    str - 被转换的字符串
    
    Returns:
    
    转换后的字符串
  - nullToDefault
```
public static String nullToDefault(CharSequence str,
                                   String defaultStr)
```
    如果字符串是null，则返回指定默认字符串，否则返回字符串本身。
```
 nullToDefault(null, "default")  = "default"
 nullToDefault("", "default")    = ""
 nullToDefault("  ", "default")  = "  "
 nullToDefault("bat", "default") = "bat"
 
```
    Parameters:
    
    str - 要转换的字符串
    
    defaultStr - 默认字符串
    
    Returns:
    
    字符串本身或指定的默认字符串
  - isAllCharMatch
```
public static boolean isAllCharMatch(CharSequence value,
                                     Matcher<Character> matcher)
```
    字符串的每一个字符是否都与定义的匹配器匹配
    
    Parameters:
    
    value - 字符串
    
    matcher - 匹配器
    
    Returns:
    
    是否全部匹配
    
    Since:
    
    3.2.3
  - replaceIgnoreCase
```
public static String replaceIgnoreCase(CharSequence str,
                                       CharSequence searchStr,
                                       CharSequence replacement)
```
    替换字符串中的指定字符串，忽略大小写
    
    Parameters:
    
    str - 字符串
    
    searchStr - 被查找的字符串
    
    replacement - 被替换的字符串
    
    Returns:
    
    替换后的字符串
    
    Since:
    
    4.0.3
  - replace
```
public static String replace(CharSequence str,
                             CharSequence searchStr,
                             CharSequence replacement)
```
    替换字符串中的指定字符串
    
    Parameters:
    
    str - 字符串
    
    searchStr - 被查找的字符串
    
    replacement - 被替换的字符串
    
    Returns:
    
    替换后的字符串
    
    Since:
    
    4.0.3
  - replace
```
public static String replace(CharSequence str,
                             CharSequence searchStr,
                             CharSequence replacement,
                             boolean ignoreCase)
```
    替换字符串中的指定字符串
    
    Parameters:
    
    str - 字符串
    
    searchStr - 被查找的字符串
    
    replacement - 被替换的字符串
    
    ignoreCase - 是否忽略大小写
    
    Returns:
    
    替换后的字符串
    
    Since:
    
    4.0.3
  - replace
```
public static String replace(CharSequence str,
                             int fromIndex,
                             CharSequence searchStr,
                             CharSequence replacement,
                             boolean ignoreCase)
```
    替换字符串中的指定字符串
    
    Parameters:
    
    str - 字符串
    
    fromIndex - 开始位置（包括）
    
    searchStr - 被查找的字符串
    
    replacement - 被替换的字符串
    
    ignoreCase - 是否忽略大小写
    
    Returns:
    
    替换后的字符串
    
    Since:
    
    4.0.3
  - replace
```
public static String replace(CharSequence str,
                             int startInclude,
                             int endExclude,
                             char replacedChar)
```
    替换指定字符串的指定区间内字符为固定字符
    
    Parameters:
    
    str - 字符串
    
    startInclude - 开始位置（包含）
    
    endExclude - 结束位置（不包含）
    
    replacedChar - 被替换的字符
    
    Returns:
    
    替换后的字符串
    
    Since:
    
    3.2.1
  - hide
```
public static String hide(CharSequence str,
                          int startInclude,
                          int endExclude)
```
    替换指定字符串的指定区间内字符为"*"
    
    Parameters:
    
    str - 字符串
    
    startInclude - 开始位置（包含）
    
    endExclude - 结束位置（不包含）
    
    Returns:
    
    替换后的字符串
    
    Since:
    
    4.1.14
  - replaceChars
```
public static String replaceChars(CharSequence str,
                                  String chars,
                                  CharSequence replacedStr)
```
    替换字符字符数组中所有的字符为replacedStr 提供的chars为所有需要被替换的字符，例如："\r\n"，则"\r"和"\n"都会被替换，哪怕他们单独存在
    
    Parameters:
    
    str - 被检查的字符串
    
    chars - 需要替换的字符列表，用一个字符串表示这个字符列表
    
    replacedStr - 替换成的字符串
    
    Returns:
    
    新字符串
    
    Since:
    
    3.2.2
  - replaceChars
```
public static String replaceChars(CharSequence str,
                                  char[] chars,
                                  CharSequence replacedStr)
```
    替换字符字符数组中所有的字符为replacedStr
    
    Parameters:
    
    str - 被检查的字符串
    
    chars - 需要替换的字符列表
    
    replacedStr - 替换成的字符串
    
    Returns:
    
    新字符串
    
    Since:
    
    3.2.2
  - cleanBlank
```
public static String cleanBlank(CharSequence str)
```
    清理空白字符
    
    Parameters:
    
    str - 被清理的字符串
    
    Returns:
    
    清理后的字符串
  - wrap
```
public static String wrap(CharSequence str,
                          CharSequence prefixAndSuffix)
```
    包装指定字符串当前缀和后缀一致时使用此方法
    
    Parameters:
    
    str - 被包装的字符串
    
    prefixAndSuffix - 前缀和后缀
    
    Returns:
    
    包装后的字符串
    
    Since:
    
    3.1.0
  - wrap
```
public static String wrap(CharSequence str,
                          CharSequence prefix,
                          CharSequence suffix)
```
    包装指定字符串
    
    Parameters:
    
    str - 被包装的字符串
    
    prefix - 前缀
    
    suffix - 后缀
    
    Returns:
    
    包装后的字符串
  - wrapAll
```
public static String[] wrapAll(CharSequence prefixAndSuffix,
                               CharSequence... strs)
```
    包装多个字符串
    
    Parameters:
    
    prefixAndSuffix - 前缀和后缀
    
    strs - 多个字符串
    
    Returns:
    
    包装的字符串数组
    
    Since:
    
    4.0.7
  - wrapAll
```
public static String[] wrapAll(CharSequence prefix,
                               CharSequence suffix,
                               CharSequence... strs)
```
    包装多个字符串
    
    Parameters:
    
    prefix - 前缀
    
    suffix - 后缀
    
    strs - 多个字符串
    
    Returns:
    
    包装的字符串数组
    
    Since:
    
    4.0.7
  - unWrap
```
public static String unWrap(CharSequence str,
                            String prefix,
                            String suffix)
```
    去掉字符包装，如果未被包装则返回原字符串
    
    Parameters:
    
    str - 字符串
    
    prefix - 前置字符串
    
    suffix - 后置字符串
    
    Returns:
    
    去掉包装字符的字符串
    
    Since:
    
    4.0.1
  - unWrap
```
public static String unWrap(CharSequence str,
                            char prefix,
                            char suffix)
```
    去掉字符包装，如果未被包装则返回原字符串
    
    Parameters:
    
    str - 字符串
    
    prefix - 前置字符
    
    suffix - 后置字符
    
    Returns:
    
    去掉包装字符的字符串
    
    Since:
    
    4.0.1
  - unWrap
```
public static String unWrap(CharSequence str,
                            char prefixAndSuffix)
```
    去掉字符包装，如果未被包装则返回原字符串
    
    Parameters:
    
    str - 字符串
    
    prefixAndSuffix - 前置和后置字符
    
    Returns:
    
    去掉包装字符的字符串
    
    Since:
    
    4.0.1
  - isWrap
```
public static boolean isWrap(CharSequence str,
                             String prefix,
                             String suffix)
```
    指定字符串是否被包装
    
    Parameters:
    
    str - 字符串
    
    prefix - 前缀
    
    suffix - 后缀
    
    Returns:
    
    是否被包装
  - isWrap
```
public static boolean isWrap(CharSequence str,
                             String wrapper)
```
    指定字符串是否被同一字符包装（前后都有这些字符串）
    
    Parameters:
    
    str - 字符串
    
    wrapper - 包装字符串
    
    Returns:
    
    是否被包装
  - isWrap
```
public static boolean isWrap(CharSequence str,
                             char wrapper)
```
    指定字符串是否被同一字符包装（前后都有这些字符串）
    
    Parameters:
    
    str - 字符串
    
    wrapper - 包装字符
    
    Returns:
    
    是否被包装
  - isWrap
```
public static boolean isWrap(CharSequence str,
                             char prefixChar,
                             char suffixChar)
```
    指定字符串是否被包装
    
    Parameters:
    
    str - 字符串
    
    prefixChar - 前缀
    
    suffixChar - 后缀
    
    Returns:
    
    是否被包装
  - endWith
```
public static boolean endWith(CharSequence str,
                              char c)
```
    字符串是否以给定字符结尾
    
    Parameters:
    
    str - 字符串
    
    c - 字符
    
    Returns:
    
    是否结尾
  - endWith
```
public static boolean endWith(CharSequence str,
                              CharSequence suffix,
                              boolean isIgnoreCase)
```
    是否以指定字符串结尾如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
    
    Parameters:
    
    str - 被监测字符串
    
    suffix - 结尾字符串
    
    isIgnoreCase - 是否忽略大小写
    
    Returns:
    
    是否以指定字符串结尾
  - endWith
```
public static boolean endWith(CharSequence str,
                              CharSequence suffix)
```
    是否以指定字符串结尾
    
    Parameters:
    
    str - 被监测字符串
    
    suffix - 结尾字符串
    
    Returns:
    
    是否以指定字符串结尾
  - endWithIgnoreCase
```
public static boolean endWithIgnoreCase(CharSequence str,
                                        CharSequence suffix)
```
    是否以指定字符串结尾，忽略大小写
    
    Parameters:
    
    str - 被监测字符串
    
    suffix - 结尾字符串
    
    Returns:
    
    是否以指定字符串结尾
  - removePrefix
```
public static String removePrefix(CharSequence str,
                                  CharSequence prefix)
```
    去掉指定前缀
    
    Parameters:
    
    str - 字符串
    
    prefix - 前缀
    
    Returns:
    
    切掉后的字符串，若前缀不是 preffix，返回原字符串
  - removePrefixIgnoreCase
```
public static String removePrefixIgnoreCase(CharSequence str,
                                            CharSequence prefix)
```
    忽略大小写去掉指定前缀
    
    Parameters:
    
    str - 字符串
    
    prefix - 前缀
    
    Returns:
    
    切掉后的字符串，若前缀不是 prefix，返回原字符串
  - removeSuffix
```
public static String removeSuffix(CharSequence str,
                                  CharSequence suffix)
```
    去掉指定后缀
    
    Parameters:
    
    str - 字符串
    
    suffix - 后缀
    
    Returns:
    
    切掉后的字符串，若后缀不是 suffix，返回原字符串
  - strip
```
public static String strip(CharSequence str,
                           CharSequence prefixOrSuffix)
```
    去除两边的指定字符串
    
    Parameters:
    
    str - 被处理的字符串
    
    prefixOrSuffix - 前缀或后缀
    
    Returns:
    
    处理后的字符串
    
    Since:
    
    3.1.2
  - strip
```
public static String strip(CharSequence str,
                           CharSequence prefix,
                           CharSequence suffix)
```
    去除两边的指定字符串
    
    Parameters:
    
    str - 被处理的字符串
    
    prefix - 前缀
    
    suffix - 后缀
    
    Returns:
    
    处理后的字符串
    
    Since:
    
    3.1.2
  - stripIgnoreCase
```
public static String stripIgnoreCase(CharSequence str,
                                     CharSequence prefixOrSuffix)
```
    去除两边的指定字符串，忽略大小写
    
    Parameters:
    
    str - 被处理的字符串
    
    prefixOrSuffix - 前缀或后缀
    
    Returns:
    
    处理后的字符串
    
    Since:
    
    3.1.2
  - stripIgnoreCase
```
public static String stripIgnoreCase(CharSequence str,
                                     CharSequence prefix,
                                     CharSequence suffix)
```
    去除两边的指定字符串，忽略大小写
    
    Parameters:
    
    str - 被处理的字符串
    
    prefix - 前缀
    
    suffix - 后缀
    
    Returns:
    
    处理后的字符串
    
    Since:
    
    3.1.2
  - addPrefixIfNot
```
public static String addPrefixIfNot(CharSequence str,
                                    CharSequence prefix)
```
    如果给定字符串不是以prefix开头的，在开头补充 prefix
    
    Parameters:
    
    str - 字符串
    
    prefix - 前缀
    
    Returns:
    
    补充后的字符串
  - addSuffixIfNot
```
public static String addSuffixIfNot(CharSequence str,
                                    CharSequence suffix)
```
    如果给定字符串不是以suffix结尾的，在尾部补充 suffix
    
    Parameters:
    
    str - 字符串
    
    suffix - 后缀
    
    Returns:
    
    补充后的字符串
  - containsAny
```
public static boolean containsAny(CharSequence str,
                                  CharSequence... testStrs)
```
    查找指定字符串是否包含指定字符串列表中的任意一个字符串
    
    Parameters:
    
    str - 指定字符串
    
    testStrs - 需要检查的字符串数组
    
    Returns:
    
    是否包含任意一个字符串
    
    Since:
    
    3.2.0
  - containsAny
```
public static boolean containsAny(CharSequence str,
                                  char... testChars)
```
    查找指定字符串是否包含指定字符列表中的任意一个字符
    
    Parameters:
    
    str - 指定字符串
    
    testChars - 需要检查的字符数组
    
    Returns:
    
    是否包含任意一个字符
    
    Since:
    
    4.1.11
  - containsOnly
```
public static boolean containsOnly(CharSequence str,
                                   char... testChars)
```
    检查指定字符串中是否只包含给定的字符
    
    Parameters:
    
    str - 字符串
    
    testChars - 检查的字符
    
    Returns:
    
    字符串含有非检查的字符，返回false
    
    Since:
    
    4.4.1
  - containsBlank
```
public static boolean containsBlank(CharSequence str)
```
    给定字符串是否包含空白符（空白符包括空格、制表符、全角空格和不间断空格）如果给定字符串为null或者""，则返回false
    
    Parameters:
    
    str - 字符串
    
    Returns:
    
    是否包含空白符
    
    Since:
    
    4.0.8
  - getContainsStr
```
public static String getContainsStr(CharSequence str,
                                    CharSequence... testStrs)
```
    查找指定字符串是否包含指定字符串列表中的任意一个字符串，如果包含返回找到的第一个字符串
    
    Parameters:
    
    str - 指定字符串
    
    testStrs - 需要检查的字符串数组
    
    Returns:
    
    被包含的第一个字符串
    
    Since:
    
    3.2.0
  - containsIgnoreCase
```
public static boolean containsIgnoreCase(CharSequence str,
                                         CharSequence testStr)
```
    是否包含特定字符，忽略大小写，如果给定两个参数都为null，返回true
    
    Parameters:
    
    str - 被检测字符串
    
    testStr - 被测试是否包含的字符串
    
    Returns:
    
    是否包含
  - containsAnyIgnoreCase
```
public static boolean containsAnyIgnoreCase(CharSequence str,
                                            CharSequence... testStrs)
```
    查找指定字符串是否包含指定字符串列表中的任意一个字符串忽略大小写
    
    Parameters:
    
    str - 指定字符串
    
    testStrs - 需要检查的字符串数组
    
    Returns:
    
    是否包含任意一个字符串
    
    Since:
    
    3.2.0
  - getContainsStrIgnoreCase
```
public static String getContainsStrIgnoreCase(CharSequence str,
                                              CharSequence... testStrs)
```
    查找指定字符串是否包含指定字符串列表中的任意一个字符串，如果包含返回找到的第一个字符串忽略大小写
    
    Parameters:
    
    str - 指定字符串
    
    testStrs - 需要检查的字符串数组
    
    Returns:
    
    被包含的第一个字符串
    
    Since:
    
    3.2.0
  - subBefore
```
public static String subBefore(CharSequence string,
                               CharSequence separator,
                               boolean isLastSeparator)
```
    截取分隔字符串之前的字符串，不包括分隔字符串如果给定的字符串为空串（null或""）或者分隔字符串为null，返回原字符串如果分隔字符串为空串""，则返回空串，如果分隔字符串未找到，返回原字符串，举例如下：
```
 StringUtils.subBefore(null, *)      = null
 StringUtils.subBefore("", *)        = ""
 StringUtils.subBefore("abc", "a")   = ""
 StringUtils.subBefore("abcba", "b") = "a"
 StringUtils.subBefore("abc", "c")   = "ab"
 StringUtils.subBefore("abc", "d")   = "abc"
 StringUtils.subBefore("abc", "")    = ""
 StringUtils.subBefore("abc", null)  = "abc"
 
```
    Parameters:
    
    string - 被查找的字符串
    
    separator - 分隔字符串（不包括）
    
    isLastSeparator - 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
    
    Returns:
    
    切割后的字符串
    
    Since:
    
    3.1.1
  - subBefore
```
public static String subBefore(CharSequence string,
                               char separator,
                               boolean isLastSeparator)
```
    截取分隔字符串之前的字符串，不包括分隔字符串如果给定的字符串为空串（null或""）或者分隔字符串为null，返回原字符串如果分隔字符串未找到，返回原字符串，举例如下：
```
 StringUtils.subBefore(null, *)      = null
 StringUtils.subBefore("", *)        = ""
 StringUtils.subBefore("abc", 'a')   = ""
 StringUtils.subBefore("abcba", 'b') = "a"
 StringUtils.subBefore("abc", 'c')   = "ab"
 StringUtils.subBefore("abc", 'd')   = "abc"
 
```
    Parameters:
    
    string - 被查找的字符串
    
    separator - 分隔字符串（不包括）
    
    isLastSeparator - 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
    
    Returns:
    
    切割后的字符串
    
    Since:
    
    4.1.15
  - subAfter
```
public static String subAfter(CharSequence string,
                              CharSequence separator,
                              boolean isLastSeparator)
```
    截取分隔字符串之后的字符串，不包括分隔字符串如果给定的字符串为空串（null或""），返回原字符串如果分隔字符串为空串（null或""），则返回空串，如果分隔字符串未找到，返回空串，举例如下：
```
 StringUtils.subAfter(null, *)      = null
 StringUtils.subAfter("", *)        = ""
 StringUtils.subAfter(*, null)      = ""
 StringUtils.subAfter("abc", "a")   = "bc"
 StringUtils.subAfter("abcba", "b") = "cba"
 StringUtils.subAfter("abc", "c")   = ""
 StringUtils.subAfter("abc", "d")   = ""
 StringUtils.subAfter("abc", "")    = "abc"
 
```
    Parameters:
    
    string - 被查找的字符串
    
    separator - 分隔字符串（不包括）
    
    isLastSeparator - 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
    
    Returns:
    
    切割后的字符串
    
    Since:
    
    3.1.1
  - subAfter
```
public static String subAfter(CharSequence string,
                              char separator,
                              boolean isLastSeparator)
```
    截取分隔字符串之后的字符串，不包括分隔字符串如果给定的字符串为空串（null或""），返回原字符串如果分隔字符串为空串（null或""），则返回空串，如果分隔字符串未找到，返回空串，举例如下：
```
 StringUtils.subAfter(null, *)      = null
 StringUtils.subAfter("", *)        = ""
 StringUtils.subAfter("abc", 'a')   = "bc"
 StringUtils.subAfter("abcba", 'b') = "cba"
 StringUtils.subAfter("abc", 'c')   = ""
 StringUtils.subAfter("abc", 'd')   = ""
 
```
    Parameters:
    
    string - 被查找的字符串
    
    separator - 分隔字符串（不包括）
    
    isLastSeparator - 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
    
    Returns:
    
    切割后的字符串
    
    Since:
    
    4.1.15
  - subBetween
```
public static String subBetween(CharSequence str,
                                CharSequence before,
                                CharSequence after)
```
    截取指定字符串中间部分，不包括标识字符串
    栗子：
```
 StringUtils.subBetween("wx[b]yz", "[", "]") = "b"
 StringUtils.subBetween(null, *, *)          = null
 StringUtils.subBetween(*, null, *)          = null
 StringUtils.subBetween(*, *, null)          = null
 StringUtils.subBetween("", "", "")          = ""
 StringUtils.subBetween("", "", "]")         = null
 StringUtils.subBetween("", "[", "]")        = null
 StringUtils.subBetween("yabcz", "", "")     = ""
 StringUtils.subBetween("yabcz", "y", "z")   = "abc"
 StringUtils.subBetween("yabczyabcz", "y", "z")   = "abc"
 
```
    Parameters:
    
    str - 被切割的字符串
    
    before - 截取开始的字符串标识
    
    after - 截取到的字符串标识
    
    Returns:
    
    截取后的字符串
    
    Since:
    
    3.1.1
  - subBetween
```
public static String subBetween(CharSequence str,
                                CharSequence beforeAndAfter)
```
    截取指定字符串中间部分，不包括标识字符串
    栗子：
```
 StringUtils.subBetween(null, *)            = null
 StringUtils.subBetween("", "")             = ""
 StringUtils.subBetween("", "tag")          = null
 StringUtils.subBetween("tagabctag", null)  = null
 StringUtils.subBetween("tagabctag", "")    = ""
 StringUtils.subBetween("tagabctag", "tag") = "abc"
 
```
    Parameters:
    
    str - 被切割的字符串
    
    beforeAndAfter - 截取开始和结束的字符串标识
    
    Returns:
    
    截取后的字符串
    
    Since:
    
    3.1.1
  - isSurround
```
public static boolean isSurround(CharSequence str,
                                 CharSequence prefix,
                                 CharSequence suffix)
```
    给定字符串是否被字符包围
    
    Parameters:
    
    str - 字符串
    
    prefix - 前缀
    
    suffix - 后缀
    
    Returns:
    
    是否包围，空串不包围
  - isSurround
```
public static boolean isSurround(CharSequence str,
                                 char prefix,
                                 char suffix)
```
    给定字符串是否被字符包围
    
    Parameters:
    
    str - 字符串
    
    prefix - 前缀
    
    suffix - 后缀
    
    Returns:
    
    是否包围，空串不包围
  - toString
```
public static String toString(Class<?>[] parameterTypes)
```
  - toString
```
public static String toString(String[] values)
```
  - isAnyBlank
```
public static boolean isAnyBlank(CharSequence... css)
```
    Checks if any of the CharSequences are empty ("") or null or whitespace only.
    Whitespace is defined by Character.isWhitespace(char).
```
 StringUtils.isAnyBlank((String) null)    = true
 StringUtils.isAnyBlank((String[]) null)  = false
 StringUtils.isAnyBlank(null, "foo")      = true
 StringUtils.isAnyBlank(null, null)       = true
 StringUtils.isAnyBlank("", "bar")        = true
 StringUtils.isAnyBlank("bob", "")        = true
 StringUtils.isAnyBlank("  bob  ", null)  = true
 StringUtils.isAnyBlank(" ", "bar")       = true
 StringUtils.isAnyBlank(new String[] {})  = false
 StringUtils.isAnyBlank(new String[]{""}) = true
 StringUtils.isAnyBlank("foo", "bar")     = false
 
```
    Parameters:
    
    css - the CharSequences to check, may be null or empty
    
    Returns:
    
    true if any of the CharSequences are empty or null or whitespace only
    
    Since:
    
    3.2
  - trimToNull
```
public static String trimToNull(String str)
```
    Removes control characters (char <= 32) from both ends of this String returning null if the String is empty ("") after the trim or if it is null.
```
 StringUtils.trimToNull(null)          = null
 StringUtils.trimToNull("")            = null
 StringUtils.trimToNull("     ")       = null
 StringUtils.trimToNull("abc")         = "abc"
 StringUtils.trimToNull("    abc    ") = "abc"
 
```
    Parameters:
    
    str - the String to be trimmed, may be null
    
    Returns:
    
    the trimmed String, null if only chars <= 32, empty or null String input
    
    Since:
    
    2.0
  - trimToEmpty
```
public static String trimToEmpty(String str)
```
    Removes control characters (char <= 32) from both ends of this String returning an empty String ("") if the String is empty ("") after the trim or if it is null.
```
 StringUtils.trimToEmpty(null)          = ""
 StringUtils.trimToEmpty("")            = ""
 StringUtils.trimToEmpty("     ")       = ""
 StringUtils.trimToEmpty("abc")         = "abc"
 StringUtils.trimToEmpty("    abc    ") = "abc"
 
```
    Parameters:
    
    str - the String to be trimmed, may be null
    
    Returns:
    
    the trimmed String, or an empty String if null input
    
    Since:
    
    2.0
  - replaceBlank
```
public static String replaceBlank(String str)
```
  - defaultString
```
public static String defaultString(String str,
                                   String defaultStr)
```
    Returns either the passed in String, or if the String is null, the value of defaultStr.
```
 StringUtils.defaultString(null, "NULL")  = "NULL"
 StringUtils.defaultString("", "NULL")    = ""
 StringUtils.defaultString("bat", "NULL") = "bat"
 
```
    Parameters:
    
    str - the String to check, may be null
    
    defaultStr - the default String to return if the input is null, may be null
    
    Returns:
    
    the passed in String, or the default if it was null
    
    See Also:
    
    String.valueOf(Object)
  - hasText
```
public static boolean hasText(String str)
```
    Check whether the given String contains actual text. More specifically, this method returns true if the String is not null, its length is greater than 0, and it contains at least one non-whitespace character.
    
    Parameters:
    
    str - the String to check (may be null)
    
    Returns:
    
    true if the String is not null, its length is greater than 0, and it does not contain whitespace only
  - 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
  - toStringArray
```
public static String[] toStringArray(Enumeration<String> enumeration)
```
    Copy the given Enumeration into a String array. The Enumeration must contain String elements only.
    
    Parameters:
    
    enumeration - the Enumeration to copy
    
    Returns:
    
    the String array
  - hasLength
```
public static boolean hasLength(String str)
```
    Check that the given String is neither null nor of length 0. Note: this method returns true for a String that purely consists of whitespace.
    
    Parameters:
    
    str - the String to check (may be null)
    
    Returns:
    
    true if the String is not null and has length
    
    See Also:
    
    hasText(String)
  - rightPad
```
public static String rightPad(String str,
                              int size,
                              String padStr)
```
    Right pad a String with a specified String.
    The String is padded to the size of size.
```
 StringUtils.rightPad(null, *, *)      = null
 StringUtils.rightPad("", 3, "z")      = "zzz"
 StringUtils.rightPad("bat", 3, "yz")  = "bat"
 StringUtils.rightPad("bat", 5, "yz")  = "batyz"
 StringUtils.rightPad("bat", 8, "yz")  = "batyzyzy"
 StringUtils.rightPad("bat", 1, "yz")  = "bat"
 StringUtils.rightPad("bat", -1, "yz") = "bat"
 StringUtils.rightPad("bat", 5, null)  = "bat  "
 StringUtils.rightPad("bat", 5, "")    = "bat  "
 
```
    Parameters:
    
    str - the String to pad out, may be null
    
    size - the size to pad to
    
    padStr - the String to pad with, null or empty treated as single space
    
    Returns:
    
    right padded String or original String if no padding is necessary, null if null String input
  - rightPad
```
public static String rightPad(String str,
                              int size,
                              char padChar)
```
    Right pad a String with a specified character.
    The String is padded to the size of size.
```
 StringUtils.rightPad(null, *, *)     = null
 StringUtils.rightPad("", 3, 'z')     = "zzz"
 StringUtils.rightPad("bat", 3, 'z')  = "bat"
 StringUtils.rightPad("bat", 5, 'z')  = "batzz"
 StringUtils.rightPad("bat", 1, 'z')  = "bat"
 StringUtils.rightPad("bat", -1, 'z') = "bat"
 
```
    Parameters:
    
    str - the String to pad out, may be null
    
    size - the size to pad to
    
    padChar - the character to pad with
    
    Returns:
    
    right padded String or original String if no padding is necessary, null if null String input
    
    Since:
    
    2.0
  - left
```
public static String left(String str,
                          int len)
```
    Gets the leftmost len characters of a String.
    If len characters are not available, or the String is null, the String will be returned without an exception. An empty String is returned if len is negative.
```
 StringUtils.left(null, *)    = null
 StringUtils.left(*, -ve)     = ""
 StringUtils.left("", *)      = ""
 StringUtils.left("abc", 0)   = ""
 StringUtils.left("abc", 2)   = "ab"
 StringUtils.left("abc", 4)   = "abc"
 
```
    Parameters:
    
    str - the String to get the leftmost characters from, may be null
    
    len - the length of the required String
    
    Returns:
    
    the leftmost characters, null if null String input
  - right
```
public static String right(String str,
                           int len)
```
    Gets the rightmost len characters of a String.
    If len characters are not available, or the String is null, the String will be returned without an an exception. An empty String is returned if len is negative.
```
 StringUtils.right(null, *)    = null
 StringUtils.right(*, -ve)     = ""
 StringUtils.right("", *)      = ""
 StringUtils.right("abc", 0)   = ""
 StringUtils.right("abc", 2)   = "bc"
 StringUtils.right("abc", 4)   = "abc"
 
```
    Parameters:
    
    str - the String to get the rightmost characters from, may be null
    
    len - the length of the required String
    
    Returns:
    
    the rightmost characters, null if null String input
  - mid
```
public static String mid(String str,
                         int pos,
                         int len)
```
    Gets len characters from the middle of a String.
    If len characters are not available, the remainder of the String will be returned without an exception. If the String is null, null will be returned. An empty String is returned if len is negative or exceeds the length of str.
```
 StringUtils.mid(null, *, *)    = null
 StringUtils.mid(*, *, -ve)     = ""
 StringUtils.mid("", 0, *)      = ""
 StringUtils.mid("abc", 0, 2)   = "ab"
 StringUtils.mid("abc", 0, 4)   = "abc"
 StringUtils.mid("abc", 2, 4)   = "c"
 StringUtils.mid("abc", 4, 2)   = ""
 StringUtils.mid("abc", -2, 2)  = "ab"
 
```
    Parameters:
    
    str - the String to get the characters from, may be null
    
    pos - the position to start from, negative treated as zero
    
    len - the length of the required String
    
    Returns:
    
    the middle characters, null if null String input
  - removeStart
```
public static String removeStart(String str,
                                 String remove)
```
    删除指定字符串是否在开始位置，否则返回源字符串 A null source string will return null. An empty ("") source string will return the empty string. A null search string will return the source string.
```
 StringUtils.removeStart(null, *)      = null
 StringUtils.removeStart("", *)        = ""
 StringUtils.removeStart(*, null)      = *
 StringUtils.removeStart("www.domain.com", "www.")   = "domain.com"
 StringUtils.removeStart("domain.com", "www.")       = "domain.com"
 StringUtils.removeStart("www.domain.com", "domain") = "www.domain.com"
 StringUtils.removeStart("abc", "")    = "abc"
 
```
    Parameters:
    
    str - the source String to search, may be null
    
    remove - the String to search for and remove, may be null
    
    Returns:
    
    the substring with the string removed if found, null if null String input
    
    Since:
    
    2.1
  - leftPad
```
public static String leftPad(String str,
                             int size)
```
    用指定的字符串填充一个字符串
```
 StringUtils.leftPad(null, *)   = null
 StringUtils.leftPad("", 3)     = "   "
 StringUtils.leftPad("bat", 3)  = "bat"
 StringUtils.leftPad("bat", 5)  = "  bat"
 StringUtils.leftPad("bat", 1)  = "bat"
 StringUtils.leftPad("bat", -1) = "bat"
 
```
    Parameters:
    
    str - the String to pad out, may be null
    
    size - the size to pad to
    
    Returns:
    
    left padded String or original String if no padding is necessary, null if null String input
  - leftPad
```
public static String leftPad(String str,
                             int size,
                             char padChar)
```
    用指定的字符串填充一个字符串
```
 StringUtils.leftPad(null, *, *)     = null
 StringUtils.leftPad("", 3, 'z')     = "zzz"
 StringUtils.leftPad("bat", 3, 'z')  = "bat"
 StringUtils.leftPad("bat", 5, 'z')  = "zzbat"
 StringUtils.leftPad("bat", 1, 'z')  = "bat"
 StringUtils.leftPad("bat", -1, 'z') = "bat"
 
```
    Parameters:
    
    str - the String to pad out, may be null
    
    size - the size to pad to
    
    padChar - the character to pad with
    
    Returns:
    
    left padded String or original String if no padding is necessary, null if null String input
    
    Since:
    
    2.0
  - leftPad
```
public static String leftPad(String str,
                             int size,
                             String padStr)
```
    用指定的字符串填充一个字符串
```
 StringUtils.leftPad(null, *, *)      = null
 StringUtils.leftPad("", 3, "z")      = "zzz"
 StringUtils.leftPad("bat", 3, "yz")  = "bat"
 StringUtils.leftPad("bat", 5, "yz")  = "yzbat"
 StringUtils.leftPad("bat", 8, "yz")  = "yzyzybat"
 StringUtils.leftPad("bat", 1, "yz")  = "bat"
 StringUtils.leftPad("bat", -1, "yz") = "bat"
 StringUtils.leftPad("bat", 5, null)  = "  bat"
 StringUtils.leftPad("bat", 5, "")    = "  bat"
 
```
    Parameters:
    
    str - the String to pad out, may be null
    
    size - the size to pad to
    
    padStr - the String to pad with, null or empty treated as single space
    
    Returns:
    
    left padded String or original String if no padding is necessary, null if null String input
  - length
```
public static int length(CharSequence cs)
```
    获取字符串的长度，如果为null返回0
    
    Parameters:
    
    cs - a 字符串
    
    Returns:
    
    字符串的长度，如果为null返回0
    
    Since:
    
    4.3.2
  - buildString
```
public static String buildString(Object original,
                                 String middle,
                                 int prefixLength)
```
    构建新的字符串
    
    Parameters:
    
    original - 原始对象
    
    middle - 中间隐藏信息
    
    prefixLength - 前边信息长度
    
    Returns:
    
    构建后的新字符串
    
    Since:
    
    0.0.8
  - concat
```
public static String concat(boolean isNullToEmpty,
                            CharSequence... strs)
```
    连接多个字符串为一个
    
    Parameters:
    
    isNullToEmpty - 是否null转为""
    
    strs - 字符串数组
    
    Returns:
    
    连接后的字符串
    
    Since:
    
    4.1.0
  - isUpperCase
```
public static boolean isUpperCase(CharSequence str)
```
    给定字符串中的字母是否全部为大写，判断依据如下：
```
 1. 大写字母包括A-Z
 2. 其它非字母的Unicode符都算作大写
 
```
    Parameters:
    
    str - 被检查的字符串
    
    Returns:
    
    是否全部为大写
    
    Since:
    
    4.2.2
  - isLowerCase
```
public static boolean isLowerCase(CharSequence str)
```
    给定字符串中的字母是否全部为小写，判断依据如下：
```
 1. 小写字母包括a-z
 2. 其它非字母的Unicode符都算作小写
 
```
    Parameters:
    
    str - 被检查的字符串
    
    Returns:
    
    是否全部为小写
    
    Since:
    
    4.2.2
  - byteLength
```
public static int byteLength(CharSequence cs,
                             Charset charset)
```
    给定字符串转为bytes后的byte数（byte长度）
    
    Parameters:
    
    cs - 字符串
    
    charset - 编码
    
    Returns:
    
    byte长度
    
    Since:
    
    4.5.2
  - swapCase
```
public static String swapCase(String str)
```
    切换给定字符串中的大小写。大写转小写，小写转大写。
```
 StringUtils.swapCase(null)                 = null
 StringUtils.swapCase("")                   = ""
 StringUtils.swapCase("The dog has a BONE") = "tHE DOG HAS A bone"
 
```
    Parameters:
    
    str - 字符串
    
    Returns:
    
    交换后的字符串
    
    Since:
    
    4.3.2
  - fillBefore
```
public static String fillBefore(String str,
                                char filledChar,
                                int len)
```
    将已有字符串填充为规定长度，如果已有字符串超过这个长度则返回这个字符串字符填充于字符串前
    
    Parameters:
    
    str - 被填充的字符串
    
    filledChar - 填充的字符
    
    len - 填充长度
    
    Returns:
    
    填充后的字符串
    
    Since:
    
    3.1.2
  - fillAfter
```
public static String fillAfter(String str,
                               char filledChar,
                               int len)
```
    将已有字符串填充为规定长度，如果已有字符串超过这个长度则返回这个字符串字符填充于字符串后
    
    Parameters:
    
    str - 被填充的字符串
    
    filledChar - 填充的字符
    
    len - 填充长度
    
    Returns:
    
    填充后的字符串
    
    Since:
    
    3.1.2
  - fill
```
public static String fill(String str,
                          char filledChar,
                          int len,
                          boolean isPre)
```
    将已有字符串填充为规定长度，如果已有字符串超过这个长度则返回这个字符串
    
    Parameters:
    
    str - 被填充的字符串
    
    filledChar - 填充的字符
    
    len - 填充长度
    
    isPre - 是否填充在前
    
    Returns:
    
    填充后的字符串
    
    Since:
    
    3.1.2
  - builder
```
public static StringBuilder builder()
```
    创建StringBuilder对象
    
    Returns:
    
    StringBuilder对象
  - strBuilder
```
public static StrBuilder strBuilder()
```
    创建StrBuilder对象
    
    Returns:
    
    StrBuilder对象
    
    Since:
    
    4.0.1
  - builder
```
public static StringBuilder builder(int capacity)
```
    创建StringBuilder对象
    
    Parameters:
    
    capacity - 初始大小
    
    Returns:
    
    StringBuilder对象
  - strBuilder
```
public static StrBuilder strBuilder(int capacity)
```
    创建StrBuilder对象
    
    Parameters:
    
    capacity - 初始大小
    
    Returns:
    
    StrBuilder对象
    
    Since:
    
    4.0.1
  - builder
```
public static StringBuilder builder(CharSequence... strs)
```
    创建StringBuilder对象
    
    Parameters:
    
    strs - 初始字符串列表
    
    Returns:
    
    StringBuilder对象
  - strBuilder
```
public static StrBuilder strBuilder(CharSequence... strs)
```
    创建StrBuilder对象
    
    Parameters:
    
    strs - 初始字符串列表
    
    Returns:
    
    StrBuilder对象
  - getReader
```
public static StringReader getReader(CharSequence str)
```
    获得StringReader
    
    Parameters:
    
    str - 字符串
    
    Returns:
    
    StringReader
  - getWriter
```
public static StringWriter getWriter()
```
    获得StringWriter
    
    Returns:
    
    StringWriter
  - count
```
public static int count(CharSequence content,
                        CharSequence strForSearch)
```
    统计指定内容中包含指定字符串的数量参数为 null 或者 "" 返回 0.
```
 StringUtils.count(null, *)       = 0
 StringUtils.count("", *)         = 0
 StringUtils.count("abba", null)  = 0
 StringUtils.count("abba", "")    = 0
 StringUtils.count("abba", "a")   = 2
 StringUtils.count("abba", "ab")  = 1
 StringUtils.count("abba", "xxx") = 0
 
```
    Parameters:
    
    content - 被查找的字符串
    
    strForSearch - 需要查找的字符串
    
    Returns:
    
    查找到的个数
  - count
```
public static int count(CharSequence content,
                        char charForSearch)
```
    统计指定内容中包含指定字符的数量
    
    Parameters:
    
    content - 内容
    
    charForSearch - 被统计的字符
    
    Returns:
    
    包含数量
  - cut
```
public static String[] cut(CharSequence str,
                           int partLength)
```
    将字符串切分为N等份
    
    Parameters:
    
    str - 字符串
    
    partLength - 每等份的长度
    
    Returns:
    
    切分后的数组
    
    Since:
    
    3.0.9
  - brief
```
public static String brief(CharSequence str,
                           int maxLength)
```
    将给定字符串，变成 "xxx...xxx" 形式的字符串
    
    Parameters:
    
    str - 字符串
    
    maxLength - 最大长度
    
    Returns:
    
    截取后的字符串
  - hasEmpty
```
public static boolean hasEmpty(CharSequence... strs)
```
    是否包含空字符串
    
    Parameters:
    
    strs - 字符串列表
    
    Returns:
    
    是否包含空字符串

Class StringUtils

Field Summary

Fields inherited from class org.aoju.bus.core.utils.TextUtils

Constructor Summary

Method Summary

Methods inherited from class org.aoju.bus.core.utils.TextUtils

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.CharSequence

Field Detail

INDEX_NOT_FOUND

Constructor Detail

StringUtils

Method Detail

trim

trim

toString

toString

isEmpty

isNotEmpty

isEmptyIfStr

areNotEmpty

base64ToByte

base64ToString

base64ToString

toBase64

toBase64

toBase64

byteArrayToHex

hexStringToByte

toMD5

toMD5

toMD5

toFullString

toHalfString

toUnicode

toUnicode

unicodeToString

unicodeToString

toUrlStr

toUrlStr

urlStrToString

urlStrToString

toDES

toDES

DESToString

DESToString

toAES

toAES

AESToString

AESToString

compress2

compress2

unCompress2

compress

compress

unCompress

isNotBlank

isBlank

substringBetween

equals

equalsIgnoreCase

equals

format

utf8Str

str

str

str

str

str

str

str

str

str

subPre

subSuf

sub

splitPath

splitPath

splitPathToArray

splitPathToArray