CharSequenceUtil (hutool 5.8.33 API)

java.lang.Object
- cn.hutool.core.text.CharSequenceUtil

Direct Known Subclasses:

StrUtil
```
public class CharSequenceUtil
extends Object
```
CharSequence 相关工具类封装

Since:

5.5.3

Author:

looly

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`EMPTY` 字符串常量：空字符串 `""`
`static int`	`INDEX_NOT_FOUND`
`static String`	`NULL` 字符串常量：`"null"` 注意：{@code "null" !
`static String`	`SPACE` 字符串常量：空格符 `" "`

Constructor Summary

Constructors
Constructor and Description

CharSequenceUtil()

Constructors
Constructor and Description
`CharSequenceUtil()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated 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`	`appendIfMissing(CharSequence str, CharSequence suffix, boolean ignoreCase, CharSequence... testSuffixes)` 如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串
`static String`	`appendIfMissing(CharSequence str, CharSequence suffix, CharSequence... suffixes)` 如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串不忽略大小写
`static String`	`appendIfMissingIgnoreCase(CharSequence str, CharSequence suffix, CharSequence... suffixes)` 如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串忽略大小写
`static String`	`blankToDefault(CharSequence str, String defaultStr)` 如果字符串是`null`或者""或者空白，则返回指定默认字符串，否则返回字符串本身。
`static String`	`brief(CharSequence str, int maxLength)` 将给定字符串，变成 "xxx...xxx" 形式的字符串 abcdefgh 9 -》 abcdefgh abcdefgh 8 -》 abcdefgh abcdefgh 7 -》 ab...gh abcdefgh 6 -》 ab...h abcdefgh 5 -》 a...h abcdefgh 4 -》 a..h abcdefgh 3 -》 a.h abcdefgh 2 -》 a.
`static StringBuilder`	`builder(CharSequence... strs)` 创建StringBuilder对象
`static ByteBuffer`	`byteBuffer(CharSequence str, String charset)` 字符串转换为byteBuffer
`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`	`center(CharSequence str, int size)` 居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串 CharSequenceUtil.center(null, *) = null CharSequenceUtil.center("", 4) = " " CharSequenceUtil.center("ab", -1) = "ab" CharSequenceUtil.center("ab", 4) = " ab " CharSequenceUtil.center("abcd", 2) = "abcd" CharSequenceUtil.center("a", 4) = " a "
`static String`	`center(CharSequence str, int size, char padChar)` 居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串 CharSequenceUtil.center(null, , ) = null CharSequenceUtil.center("", 4, ' ') = " " CharSequenceUtil.center("ab", -1, ' ') = "ab" CharSequenceUtil.center("ab", 4, ' ') = " ab " CharSequenceUtil.center("abcd", 2, ' ') = "abcd" CharSequenceUtil.center("a", 4, ' ') = " a " CharSequenceUtil.center("a", 4, 'y') = "yayy" CharSequenceUtil.center("abc", 7, ' ') = " abc "
`static String`	`center(CharSequence str, int size, CharSequence padStr)` 居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串 CharSequenceUtil.center(null, , ) = null CharSequenceUtil.center("", 4, " ") = " " CharSequenceUtil.center("ab", -1, " ") = "ab" CharSequenceUtil.center("ab", 4, " ") = " ab " CharSequenceUtil.center("abcd", 2, " ") = "abcd" CharSequenceUtil.center("a", 4, " ") = " a " CharSequenceUtil.center("a", 4, "yz") = "yayz" CharSequenceUtil.center("abc", 7, null) = " abc " CharSequenceUtil.center("abc", 7, "") = " abc "
`static String`	`cleanBlank(CharSequence str)` 清理空白字符
`static CharSequence`	`commonPrefix(CharSequence str1, CharSequence str2)` 字符串1和字符串2的公共前缀
`static CharSequence`	`commonSuffix(CharSequence str1, CharSequence str2)` 字符串1和字符串2的公共后缀
`static int`	`compare(CharSequence str1, CharSequence str2, boolean nullIsLess)` 比较两个字符串，用于排序 CharSequenceUtil.compare(null, null, ) = 0 CharSequenceUtil.compare(null , "a", true) < 0 CharSequenceUtil.compare(null , "a", false) > 0 CharSequenceUtil.compare("a", null, true) > 0 CharSequenceUtil.compare("a", null, false) < 0 CharSequenceUtil.compare("abc", "abc", ) = 0 CharSequenceUtil.compare("a", "b", ) < 0 CharSequenceUtil.compare("b", "a", ) > 0 CharSequenceUtil.compare("a", "B", ) > 0 CharSequenceUtil.compare("ab", "abc", ) < 0
`static int`	`compareIgnoreCase(CharSequence str1, CharSequence str2, boolean nullIsLess)` 比较两个字符串，用于排序，大小写不敏感 CharSequenceUtil.compareIgnoreCase(null, null, ) = 0 CharSequenceUtil.compareIgnoreCase(null , "a", true) < 0 CharSequenceUtil.compareIgnoreCase(null , "a", false) > 0 CharSequenceUtil.compareIgnoreCase("a", null, true) > 0 CharSequenceUtil.compareIgnoreCase("a", null, false) < 0 CharSequenceUtil.compareIgnoreCase("abc", "abc", ) = 0 CharSequenceUtil.compareIgnoreCase("abc", "ABC", ) = 0 CharSequenceUtil.compareIgnoreCase("a", "b", ) < 0 CharSequenceUtil.compareIgnoreCase("b", "a", ) > 0 CharSequenceUtil.compareIgnoreCase("a", "B", ) < 0 CharSequenceUtil.compareIgnoreCase("A", "b", ) < 0 CharSequenceUtil.compareIgnoreCase("ab", "abc", ) < 0
`static int`	`compareVersion(CharSequence version1, CharSequence version2)` 比较两个版本 null版本排在最小：即： CharSequenceUtil.compareVersion(null, "v1") < 0 CharSequenceUtil.compareVersion("v1", "v1") = 0 CharSequenceUtil.compareVersion(null, null) = 0 CharSequenceUtil.compareVersion("v1", null) > 0 CharSequenceUtil.compareVersion("1.0.0", "1.0.2") < 0 CharSequenceUtil.compareVersion("1.0.2", "1.0.2a") < 0 CharSequenceUtil.compareVersion("1.13.0", "1.12.1c") > 0 CharSequenceUtil.compareVersion("V0.0.20170102", "V0.0.20170101") > 0
`static String`	`concat(boolean isNullToEmpty, CharSequence... strs)` 连接多个字符串为一个
`static boolean`	`contains(CharSequence str, char searchChar)` 指定字符是否在字符串中出现过
`static boolean`	`contains(CharSequence str, CharSequence searchStr)` 指定字符串是否在字符串中出现过
`static boolean`	`containsAll(CharSequence str, CharSequence... testChars)` 检查指定字符串中是否含给定的所有字符串
`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)` 检查指定字符串中是否只包含给定的字符这里的containsOnly并不是必须全部给定的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`	`desensitized(CharSequence str, DesensitizedUtil.DesensitizedType desensitizedType)` 脱敏，使用默认的脱敏策略 CharSequenceUtil.desensitized("100", DesensitizedUtil.DesensitizedType.USER_ID)) = "0" CharSequenceUtil.desensitized("段正淳", DesensitizedUtil.DesensitizedType.CHINESE_NAME)) = "段" CharSequenceUtil.desensitized("51343620000320711X", DesensitizedUtil.DesensitizedType.ID_CARD)) = "5***********1X" CharSequenceUtil.desensitized("09157518479", DesensitizedUtil.DesensitizedType.FIXED_PHONE)) = "0915*79" CharSequenceUtil.desensitized("18049531999", DesensitizedUtil.DesensitizedType.MOBILE_PHONE)) = "1801999" CharSequenceUtil.desensitized("北京市海淀区马连洼街道289号", DesensitizedUtil.DesensitizedType.ADDRESS)) = "北京市海淀区马****" CharSequenceUtil.desensitized("duandazhi-jack@gmail.com.cn", DesensitizedUtil.DesensitizedType.EMAIL)) = "d*********@gmail.com.cn" CharSequenceUtil.desensitized("1234567890", DesensitizedUtil.DesensitizedType.PASSWORD)) = "******" CharSequenceUtil.desensitized("苏D40000", DesensitizedUtil.DesensitizedType.CAR_LICENSE)) = "苏D40" CharSequenceUtil.desensitized("11011111222233333256", DesensitizedType.BANK_CARD)) = "1101 * ** 3256"
`static String`	`emptyIfNull(CharSequence str)` 当给定字符串为null时，转换为Empty
`static String`	`emptyToDefault(CharSequence str, String defaultStr)` 如果字符串是`null`或者""，则返回指定默认字符串，否则返回字符串本身。
`static String`	`emptyToNull(CharSequence str)` 当给定字符串为空字符串时，转换为`null`
`static boolean`	`endWith(CharSequence str, char c)` 字符串是否以给定字符结尾
`static boolean`	`endWith(CharSequence str, CharSequence suffix)` 是否以指定字符串结尾
`static boolean`	`endWith(CharSequence str, CharSequence suffix, boolean ignoreCase)` 是否以指定字符串结尾如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
`static boolean`	`endWith(CharSequence str, CharSequence suffix, boolean ignoreCase, boolean ignoreEquals)` 是否以指定字符串结尾如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
`static boolean`	`endWithAny(CharSequence str, CharSequence... suffixes)` 给定字符串是否以任何一个字符串结尾给定字符串和数组为空都返回false
`static boolean`	`endWithAnyIgnoreCase(CharSequence str, CharSequence... suffixes)` 给定字符串是否以任何一个字符串结尾（忽略大小写）给定字符串和数组为空都返回false
`static boolean`	`endWithIgnoreCase(CharSequence str, CharSequence suffix)` 是否以指定字符串结尾，忽略大小写
`static boolean`	`equals(CharSequence str1, CharSequence str2)` 比较两个字符串（大小写敏感）。
`static boolean`	`equals(CharSequence str1, CharSequence str2, boolean ignoreCase)` 比较两个字符串是否相等，规则如下 str1和str2都为`null` 忽略大小写使用`String.equalsIgnoreCase(String)`判断相等不忽略大小写使用`String.contentEquals(CharSequence)`判断相等
`static boolean`	`equalsAny(CharSequence str1, boolean ignoreCase, CharSequence... strs)` 给定字符串是否与提供的中任一字符串相同，相同则返回`true`，没有相同的返回`false` 如果参与比对的字符串列表为空，返回`false`
`static boolean`	`equalsAny(CharSequence str1, CharSequence... strs)` 给定字符串是否与提供的中任一字符串相同，相同则返回`true`，没有相同的返回`false` 如果参与比对的字符串列表为空，返回`false`
`static boolean`	`equalsAnyIgnoreCase(CharSequence str1, CharSequence... strs)` 给定字符串是否与提供的中任一字符串相同（忽略大小写），相同则返回`true`，没有相同的返回`false` 如果参与比对的字符串列表为空，返回`false`
`static boolean`	`equalsCharAt(CharSequence str, int position, char c)` 字符串指定位置的字符是否与给定字符相同如果字符串为null，返回false 如果给定的位置大于字符串长度，返回false 如果给定的位置小于0，返回false
`static boolean`	`equalsIgnoreCase(CharSequence str1, CharSequence str2)` 比较两个字符串（大小写不敏感）。
`static String`	`filter(CharSequence str, Filter<Character> filter)` 过滤字符串
`static <T extends CharSequence> T`	`firstNonBlank(T... strs)` 返回第一个非blank 元素
`static <T extends CharSequence> T`	`firstNonEmpty(T... strs)` 返回第一个非empty 元素
`static <T extends CharSequence> T`	`firstNonNull(T... strs)` 返回第一个非`null` 元素
`static String`	`fixLength(CharSequence str, char fixedChar, int length)` 在给定字符串末尾填充指定字符，以达到给定长度如果字符串本身的长度大于等于length，返回原字符串
`static String`	`format(CharSequence template, Object... params)` 格式化文本, {} 表示占位符此方法只是简单将占位符 {} 按照顺序替换为参数如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可例：通常使用：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`	`genGetter(CharSequence fieldName)` 生成get方法名
`static String`	`genSetter(CharSequence fieldName)` 生成set方法名例如：name 返回 setName
`static String`	`getContainsStr(CharSequence str, CharSequence... testStrs)` 查找指定字符串是否包含指定字符串列表中的任意一个字符串，如果包含返回找到的第一个字符串
`static String`	`getContainsStrIgnoreCase(CharSequence str, CharSequence... testStrs)` 查找指定字符串是否包含指定字符串列表中的任意一个字符串，如果包含返回找到的第一个字符串忽略大小写
`static String`	`getGeneralField(CharSequence getOrSetMethodName)` 获得set或get或is方法对应的标准属性名例如：setName 返回 name getName =》name setName =》name isName =》name
`static boolean`	`hasBlank(CharSequence... strs)` 指定字符串数组中，是否包含空字符串。
`static boolean`	`hasEmpty(CharSequence... strs)` 是否包含空字符串。
`static boolean`	`hasLetter(CharSequence str)` 指定字符串数组中，是否包含空字符串。
`static String`	`hide(CharSequence str, int startInclude, int endExclude)` 替换指定字符串的指定区间内字符为"" 俗称：脱敏功能，后面其他功能，可以见：DesensitizedUtil(脱敏工具类) CharSequenceUtil.hide(null,,)=null CharSequenceUtil.hide("",0,)="" CharSequenceUtil.hide("jackduan@163.com",-1,4) ***duan@163.com CharSequenceUtil.hide("jackduan@163.com",2,3) jakduan@163.com CharSequenceUtil.hide("jackduan@163.com",3,2) jackduan@163.com CharSequenceUtil.hide("jackduan@163.com",16,16) jackduan@163.com CharSequenceUtil.hide("jackduan@163.com",16,17) jackduan@163.com
`static String`	`indexedFormat(CharSequence pattern, Object... arguments)` 有序的格式化文本，使用{number}做为占位符通常使用：format("this is {0} for {1}", "a", "b") =》 this is a for b
`static int`	`indexOf(CharSequence str, char searchChar)` 指定范围内查找指定字符
`static int`	`indexOf(CharSequence str, char searchChar, int start)` 指定范围内查找指定字符
`static int`	`indexOf(CharSequence text, char searchChar, int start, int end)` 指定范围内查找指定字符
`static int`	`indexOf(CharSequence text, CharSequence searchStr, int from, boolean ignoreCase)` 指定范围内查找字符串
`static int`	`indexOfIgnoreCase(CharSequence str, CharSequence searchStr)` 指定范围内查找字符串，忽略大小写 CharSequenceUtil.indexOfIgnoreCase(null, , ) = -1 CharSequenceUtil.indexOfIgnoreCase(, null, ) = -1 CharSequenceUtil.indexOfIgnoreCase("", "", 0) = 0 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "A", 0) = 0 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "B", 0) = 2 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "AB", 0) = 1 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "B", 3) = 5 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "B", 9) = -1 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "B", -1) = 2 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "", 2) = 2 CharSequenceUtil.indexOfIgnoreCase("abc", "", 9) = -1
`static int`	`indexOfIgnoreCase(CharSequence str, CharSequence searchStr, int fromIndex)` 指定范围内查找字符串 CharSequenceUtil.indexOfIgnoreCase(null, , ) = -1 CharSequenceUtil.indexOfIgnoreCase(, null, ) = -1 CharSequenceUtil.indexOfIgnoreCase("", "", 0) = 0 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "A", 0) = 0 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "B", 0) = 2 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "AB", 0) = 1 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "B", 3) = 5 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "B", 9) = -1 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "B", -1) = 2 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "", 2) = 2 CharSequenceUtil.indexOfIgnoreCase("abc", "", 9) = -1
`static boolean`	`isAllBlank(CharSequence... strs)` 指定字符串数组中的元素，是否全部为空字符串。
`static boolean`	`isAllCharMatch(CharSequence value, Matcher<Character> matcher)` 字符串的每一个字符是否都与定义的匹配器匹配
`static boolean`	`isAllEmpty(CharSequence... strs)` 指定字符串数组中的元素，是否全部为空字符串。
`static boolean`	`isAllNotBlank(CharSequence... args)` 是否存都不为`null`或空对象或空白符的对象，通过`hasBlank(CharSequence...)`
`static boolean`	`isAllNotEmpty(CharSequence... args)` 指定字符串数组中的元素，是否都不为空字符串。
`static boolean`	`isBlank(CharSequence str)` 字符串是否为空白，空白的定义如下： `null` 空字符串：`""` 空格、全角空格、制表符、换行符，等不可见字符例： `CharSequenceUtil.isBlank(null) // true` `CharSequenceUtil.isBlank("") // true` `CharSequenceUtil.isBlank(" \t\n") // true` `CharSequenceUtil.isBlank("abc") // false` 注意：该方法与 `isEmpty(CharSequence)` 的区别是：该方法会校验空白字符，且性能相对于 `isEmpty(CharSequence)` 略慢。
`static boolean`	`isBlankOrUndefined(CharSequence str)` 检查字符串是否为null、空白串、“null”、“undefined”
`static boolean`	`isCharEquals(CharSequence str)` 检查给定字符串的所有字符是否都一样
`static boolean`	`isEmpty(CharSequence str)` 字符串是否为空，空的定义如下： `null` 空字符串：`""` 例： `CharSequenceUtil.isEmpty(null) // true` `CharSequenceUtil.isEmpty("") // true` `CharSequenceUtil.isEmpty(" \t\n") // false` `CharSequenceUtil.isEmpty("abc") // false` 注意：该方法与 `isBlank(CharSequence)` 的区别是：该方法不校验空白字符。
`static boolean`	`isEmptyOrUndefined(CharSequence str)` 检查字符串是否为null、“”、“null”、“undefined”
`static boolean`	`isLowerCase(CharSequence str)` 给定字符串中的字母是否全部为小写，判断依据如下： 1.
`static boolean`	`isNotBlank(CharSequence str)` 字符串是否为非空白，非空白的定义如下：不为 `null` 不为空字符串：`""` 不为空格、全角空格、制表符、换行符，等不可见字符例： `CharSequenceUtil.isNotBlank(null) // false` `CharSequenceUtil.isNotBlank("") // false` `CharSequenceUtil.isNotBlank(" \t\n") // false` `CharSequenceUtil.isNotBlank("abc") // true` 注意：该方法与 `isNotEmpty(CharSequence)` 的区别是：该方法会校验空白字符，且性能相对于 `isNotEmpty(CharSequence)` 略慢。
`static boolean`	`isNotEmpty(CharSequence str)` 字符串是否为非空白，非空白的定义如下：不为 `null` 不为空字符串：`""` 例： `CharSequenceUtil.isNotEmpty(null) // false` `CharSequenceUtil.isNotEmpty("") // false` `CharSequenceUtil.isNotEmpty(" \t\n") // true` `CharSequenceUtil.isNotEmpty("abc") // true` 注意：该方法与 `isNotBlank(CharSequence)` 的区别是：该方法不校验空白字符。
`static boolean`	`isNullOrUndefined(CharSequence str)` 检查字符串是否为null、“null”、“undefined”
`static boolean`	`isNumeric(CharSequence str)` 检查字符串是否都为数字组成
`static boolean`	`isSubEquals(CharSequence str1, int start1, CharSequence str2, boolean ignoreCase)` 截取第一个字串的部分字符，与第二个字符串比较（长度一致），判断截取的子串是否相同任意一个字符串为null返回false
`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)` 给定字符串中的字母是否全部为大写，判断依据如下： 1.
`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 <T> String`	`join(CharSequence conjunction, Iterable<T> iterable)` 以 conjunction 为分隔符将多个对象转换为字符串
`static String`	`join(CharSequence conjunction, Object... objs)` 以 conjunction 为分隔符将多个对象转换为字符串
`static int`	`lastIndexOf(CharSequence text, CharSequence searchStr, int from, boolean ignoreCase)` 指定范围内查找字符串 fromIndex 为搜索起始位置，从后往前计数
`static int`	`lastIndexOfIgnoreCase(CharSequence str, CharSequence searchStr)` 指定范围内查找字符串，忽略大小写
`static int`	`lastIndexOfIgnoreCase(CharSequence str, CharSequence searchStr, int fromIndex)` 指定范围内查找字符串，忽略大小写 fromIndex 为搜索起始位置，从后往前计数
`static int`	`length(CharSequence cs)` 获取字符串的长度，如果为null返回0
`static String`	`lowerFirst(CharSequence str)` 小写首字母例如：str = Name, return name
`static String`	`maxLength(CharSequence string, int length)` 限制字符串长度，如果超过指定长度，截取指定长度并在末尾加"..."
`static String`	`move(CharSequence str, int startInclude, int endExclude, int moveLength)` 循环位移指定位置的字符串为指定距离当moveLength大于0向右位移，小于0向左位移，0不位移当moveLength大于字符串长度时采取循环位移策略，即位移到头后从头（尾）位移，例如长度为10，位移13则表示位移3
`static String`	`normalize(CharSequence str)` 对字符串归一化处理，如 "Á" 可以使用 "u00C1"或 "u0041u0301"表示，实际测试中两个字符串并不equals 因此使用此方法归一为一种表示形式，默认按照W3C通常建议的，在NFC中交换文本。
`static String`	`nullToDefault(CharSequence str, String defaultStr)` 如果字符串是 `null`，则返回指定默认字符串，否则返回字符串本身。
`static String`	`nullToEmpty(CharSequence str)` 当给定字符串为null时，转换为Empty
`static int`	`ordinalIndexOf(CharSequence str, CharSequence searchStr, int ordinal)` 返回字符串 searchStr 在字符串 str 中第 ordinal 次出现的位置。
`static String`	`padAfter(CharSequence str, int length, char padChar)` 补充字符串以满足最小长度，如果提供的字符串大于指定长度，截断之 CharSequenceUtil.padAfter(null, , );//null CharSequenceUtil.padAfter("1", 3, '0');//"100" CharSequenceUtil.padAfter("123", 2, '0');//"23" CharSequenceUtil.padAfter("123", -1, '0')//"" 空串
`static String`	`padAfter(CharSequence str, int length, CharSequence padStr)` 补充字符串以满足最小长度 CharSequenceUtil.padAfter(null, , );//null CharSequenceUtil.padAfter("1", 3, "ABC");//"1AB" CharSequenceUtil.padAfter("123", 2, "ABC");//"23"
`static String`	`padPre(CharSequence str, int length, char padChar)` 补充字符串以满足最小长度，如果提供的字符串大于指定长度，截断之同：leftPad (org.apache.commons.lang3.leftPad) CharSequenceUtil.padPre(null, , );//null CharSequenceUtil.padPre("1", 3, '0');//"001" CharSequenceUtil.padPre("123", 2, '0');//"12"
`static String`	`padPre(CharSequence str, int length, CharSequence padStr)` 补充字符串以满足指定长度，如果提供的字符串大于指定长度，截断之同：leftPad (org.apache.commons.lang3.leftPad) CharSequenceUtil.padPre(null, , );//null CharSequenceUtil.padPre("1", 3, "ABC");//"AB1" CharSequenceUtil.padPre("123", 2, "ABC");//"12" CharSequenceUtil.padPre("1039", -1, "0");//"103"
`static String`	`prependIfMissing(CharSequence str, CharSequence prefix, boolean ignoreCase, CharSequence... prefixes)` 如果给定字符串不是以给定的一个或多个字符串为开头，则在首部添加起始字符串
`static String`	`prependIfMissing(CharSequence str, CharSequence prefix, CharSequence... prefixes)` 如果给定字符串不是以给定的一个或多个字符串为开头，则在首部添加起始字符串不忽略大小写
`static String`	`prependIfMissingIgnoreCase(CharSequence str, CharSequence prefix, CharSequence... prefixes)` 如果给定字符串不是以给定的一个或多个字符串为开头，则在首部添加起始字符串忽略大小写
`static String`	`removeAll(CharSequence str, char... chars)` 去除字符串中指定的多个字符，如有多个则全部去除
`static String`	`removeAll(CharSequence str, CharSequence strToRemove)` 移除字符串中所有给定字符串例：removeAll("aa-bb-cc-dd", "-") =》 aabbccdd
`static String`	`removeAllLineBreaks(CharSequence str)` 去除所有换行符，包括： 1.
`static String`	`removeAllPrefix(CharSequence str, CharSequence prefix)` 去掉指定所有前缀，如： `str=abcdef, prefix=ab => return cdef str=ababcdef, prefix=ab => return cdef str=ababcdef, prefix="" => return ababcdef str=ababcdef, prefix=null => return ababcdef`
`static String`	`removeAllSuffix(CharSequence str, CharSequence suffix)` 去掉指定所有后缀，如： `str=11abab, suffix=ab => return 11 str=11ab, suffix=ab => return 11 str=11ab, suffix="" => return 11ab str=11ab, suffix=null => return 11ab`
`static String`	`removeAny(CharSequence str, CharSequence... strsToRemove)` 移除字符串中所有给定字符串，当某个字符串出现多次，则全部移除例：removeAny("aa-bb-cc-dd", "a", "b") =》 --cc-dd
`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`	`removeSufAndLowerFirst(CharSequence str, CharSequence suffix)` 去掉指定后缀，并小写首字母
`static String`	`removeSuffix(CharSequence str, CharSequence suffix)` 去掉指定后缀
`static String`	`removeSuffixIgnoreCase(CharSequence str, CharSequence suffix)` 忽略大小写去掉指定后缀
`static String`	`repeat(char c, int count)` 重复某个字符 CharSequenceUtil.repeat('e', 0) = "" CharSequenceUtil.repeat('e', 3) = "eee" CharSequenceUtil.repeat('e', -2) = ""
`static String`	`repeat(CharSequence str, int count)` 重复某个字符串
`static String`	`repeatAndJoin(CharSequence str, int count, CharSequence delimiter)` 重复某个字符串并通过分界符连接 CharSequenceUtil.repeatAndJoin("?"
`static String`	`repeatByLength(CharSequence str, int padLen)` 重复某个字符串到指定长度
`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)` Deprecated. 歧义，请使用`replaceByCodePoint(CharSequence, int, int, char)`
`static String`	`replace(CharSequence str, int startInclude, int endExclude, CharSequence replacedStr)` Deprecated. 歧义，请使用`replaceByCodePoint(CharSequence, int, int, CharSequence)`
`static String`	`replace(CharSequence str, Pattern pattern, Func1<Matcher,String> replaceFun)` 替换所有正则匹配的文本，并使用自定义函数决定如何替换 replaceFun可以通过`Matcher`提取出匹配到的内容的不同部分，然后经过重新处理、组装变成新的内容放回原位。
`static String`	`replace(CharSequence str, String regex, Func1<Matcher,String> replaceFun)` 替换所有正则匹配的文本，并使用自定义函数决定如何替换
`static String`	`replaceByCodePoint(CharSequence str, int startInclude, int endExclude, char replacedChar)` 替换指定字符串的指定区间内字符为固定字符此方法使用`CharSequence.codePoints()`完成拆分替换
`static String`	`replaceByCodePoint(CharSequence str, int startInclude, int endExclude, CharSequence replacedStr)` 替换指定字符串的指定区间内字符为指定字符串，字符串只重复一次此方法使用`CharSequence.codePoints()`完成拆分替换
`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`	`replaceFirst(CharSequence str, CharSequence searchStr, CharSequence replacedStr)` 替换字符串中第一个指定字符串
`static String`	`replaceFirst(CharSequence str, CharSequence searchStr, CharSequence replacedStr, boolean ignoreCase)` 替换字符串中第一个指定字符串
`static String`	`replaceIgnoreCase(CharSequence str, CharSequence searchStr, CharSequence replacement)` 替换字符串中的指定字符串，忽略大小写
`static String`	`replaceLast(CharSequence str, CharSequence searchStr, CharSequence replacedStr)` 替换字符串中最后一个指定字符串
`static String`	`replaceLast(CharSequence str, CharSequence searchStr, CharSequence replacedStr, boolean ignoreCase)` 替换字符串中最后一个指定字符串
`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, boolean isTrim, boolean ignoreEmpty)` 切分字符串，不限制分片数量
`static List<String>`	`split(CharSequence str, char separator, int limit)` 切分字符串，不去除切分后每个元素两边的空白符，不去除空白项
`static List<String>`	`split(CharSequence str, char separator, int limit, boolean isTrim, boolean ignoreEmpty)` 切分字符串
`static <R> List<R>`	`split(CharSequence str, char separator, int limit, boolean ignoreEmpty, Function<String,R> mapping)` 切分字符串
`static List<String>`	`split(CharSequence str, CharSequence separator)` 切分字符串，如果分隔符不存在则返回原字符串
`static List<String>`	`split(CharSequence str, CharSequence separator, boolean isTrim, boolean ignoreEmpty)` 切分字符串
`static List<String>`	`split(CharSequence str, CharSequence separator, int limit, boolean isTrim, boolean ignoreEmpty)` 切分字符串
`static String[]`	`split(CharSequence str, int len)` 根据给定长度，将给定字符串截取为多个部分
`static String[]`	`splitToArray(CharSequence str, char separator)` 切分字符串
`static String[]`	`splitToArray(CharSequence text, char separator, int limit)` 切分字符串
`static String[]`	`splitToArray(CharSequence str, CharSequence separator)` 切分字符串，如果分隔符不存在则返回原字符串
`static int[]`	`splitToInt(CharSequence str, char separator)` 切分字符串为int数组
`static int[]`	`splitToInt(CharSequence str, CharSequence separator)` 切分字符串为int数组
`static long[]`	`splitToLong(CharSequence str, char separator)` 切分字符串为long数组
`static long[]`	`splitToLong(CharSequence str, CharSequence separator)` 切分字符串为long数组
`static List<String>`	`splitTrim(CharSequence str, char separator)` 切分字符串，去除切分后每个元素两边的空白符，去除空白项
`static List<String>`	`splitTrim(CharSequence str, char separator, int limit)` 切分字符串，去除切分后每个元素两边的空白符，去除空白项
`static List<String>`	`splitTrim(CharSequence str, CharSequence separator)` 切分字符串，去除切分后每个元素两边的空白符，去除空白项
`static List<String>`	`splitTrim(CharSequence str, CharSequence separator, int limit)` 切分字符串，去除切分后每个元素两边的空白符，去除空白项
`static boolean`	`startWith(CharSequence str, char c)` 字符串是否以给定字符开始
`static boolean`	`startWith(CharSequence str, CharSequence prefix)` 是否以指定字符串开头
`static boolean`	`startWith(CharSequence str, CharSequence prefix, boolean ignoreCase)` 是否以指定字符串开头如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
`static boolean`	`startWith(CharSequence str, CharSequence prefix, boolean ignoreCase, boolean ignoreEquals)` 是否以指定字符串开头如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false CharSequenceUtil.startWith("123", "123", false, true); -- false CharSequenceUtil.startWith("ABCDEF", "abc", true, true); -- true CharSequenceUtil.startWith("abc", "abc", true, true); -- false
`static boolean`	`startWithAny(CharSequence str, CharSequence... prefixes)` 给定字符串是否以任何一个字符串开始给定字符串和数组为空都返回false
`static boolean`	`startWithAnyIgnoreCase(CharSequence str, CharSequence... prefixes)` 给定字符串是否以任何一个字符串开始（忽略大小写）给定字符串和数组为空都返回false
`static boolean`	`startWithIgnoreCase(CharSequence str, CharSequence prefix)` 是否以指定字符串开头，忽略大小写
`static boolean`	`startWithIgnoreEquals(CharSequence str, CharSequence prefix)` 是否以指定字符串开头，忽略相等字符串的情况
`static String`	`str(CharSequence cs)` `CharSequence` 转为字符串，null安全
`static StrBuilder`	`strBuilder(CharSequence... strs)` 创建StrBuilder对象
`static String`	`strip(CharSequence str, CharSequence prefixOrSuffix)` 去除两边的指定字符串
`static String`	`strip(CharSequence str, CharSequence prefix, CharSequence suffix)` 去除两边的指定字符串两边字符如果存在，则去除，不存在不做处理 `"aaa_STRIPPED_bbb", "a", "b" -> "aa_STRIPPED_bb" "aaa_STRIPPED_bbb", null, null -> "aaa_STRIPPED_bbb" "aaa_STRIPPED_bbb", "", "" -> "aaa_STRIPPED_bbb" "aaa_STRIPPED_bbb", "", "b" -> "aaa_STRIPPED_bb" "aaa_STRIPPED_bbb", null, "b" -> "aaa_STRIPPED_bb" "aaa_STRIPPED_bbb", "a", "" -> "aa_STRIPPED_bbb" "aaa_STRIPPED_bbb", "a", null -> "aa_STRIPPED_bbb" "a", "a", "a" -> ""`
`static String`	`strip(CharSequence str, CharSequence prefix, CharSequence suffix, boolean ignoreCase)` 去除两边的指定字符串两边字符如果存在，则去除，不存在不做处理 `"aaa_STRIPPED_bbb", "a", "b" -> "aa_STRIPPED_bb" "aaa_STRIPPED_bbb", null, null -> "aaa_STRIPPED_bbb" "aaa_STRIPPED_bbb", "", "" -> "aaa_STRIPPED_bbb" "aaa_STRIPPED_bbb", "", "b" -> "aaa_STRIPPED_bb" "aaa_STRIPPED_bbb", null, "b" -> "aaa_STRIPPED_bb" "aaa_STRIPPED_bbb", "a", "" -> "aa_STRIPPED_bbb" "aaa_STRIPPED_bbb", "a", null -> "aa_STRIPPED_bbb" "a", "a", "a" -> ""`
`static String`	`stripAll(CharSequence str, CharSequence prefixOrSuffix)` 去除两边所有的指定字符串 `"aaa_STRIPPED_bbb", "a" -> "_STRIPPED_bbb" "aaa_STRIPPED_bbb", "a", "b" -> "_STRIPPED_" "aaa_STRIPPED_bbb", "" -> "aaa_STRIPPED_bbb"`
`static String`	`stripAll(CharSequence str, CharSequence prefix, CharSequence suffix)` 去除两边所有的指定字符串 `"aaa_STRIPPED_bbb", "a", "b" -> "_STRIPPED_" "aaa_STRIPPED_bbb", null, null -> "aaa_STRIPPED_bbb" "aaa_STRIPPED_bbb", "", "" -> "aaa_STRIPPED_bbb" "aaa_STRIPPED_bbb", "", "b" -> "aaa_STRIPPED_" "aaa_STRIPPED_bbb", null, "b" -> "aaa_STRIPPED_" "aaa_STRIPPED_bbb", "a", "" -> "_STRIPPED_bbb" "aaa_STRIPPED_bbb", "a", null -> "_STRIPPED_bbb" // special test "aaaaaabbb", "aaa", null -> "bbb" "aaaaaaabbb", "aa", null -> "abbb" "aaaaaaaaa", "aaa", "aa" -> "" "a", "a", "a" -> ""`
`static String`	`stripIgnoreCase(CharSequence str, CharSequence prefixOrSuffix)` 去除两边的指定字符串，忽略大小写
`static String`	`stripIgnoreCase(CharSequence str, CharSequence prefix, CharSequence suffix)` 去除两边的指定字符串，忽略大小写
`static String`	`sub(CharSequence str, int fromIndexInclude, int toIndexExclude)` 改进JDK subString index从0开始计算，最后一个字符为-1 如果from和to位置一样，返回 "" 如果from或to为负数，则按照length从后向前数位置，如果绝对值大于字符串长度，则from归到0，to归到length 如果经过修正的index中from大于to，则互换from和to example: abcdefgh 2 3 =》 c abcdefgh 2 -3 =》 cde
`static String`	`subAfter(CharSequence string, char separator, boolean isLastSeparator)` 截取分隔字符串之后的字符串，不包括分隔字符串如果给定的字符串为空串（null或""），返回原字符串如果分隔字符串为空串（null或""），则返回空串，如果分隔字符串未找到，返回空串，举例如下： CharSequenceUtil.subAfter(null, , false) = null CharSequenceUtil.subAfter("", , false) = "" CharSequenceUtil.subAfter("abc", 'a', false) = "bc" CharSequenceUtil.subAfter("abcba", 'b', false) = "cba" CharSequenceUtil.subAfter("abc", 'c', false) = "" CharSequenceUtil.subAfter("abc", 'd', false) = ""
`static String`	`subAfter(CharSequence string, CharSequence separator, boolean isLastSeparator)` 截取分隔字符串之后的字符串，不包括分隔字符串如果给定的字符串为空串（null或""），返回原字符串如果分隔字符串为空串（null或""），则返回空串，如果分隔字符串未找到，返回空串，举例如下： CharSequenceUtil.subAfter(null, , false) = null CharSequenceUtil.subAfter("", , false) = "" CharSequenceUtil.subAfter(*, null, false) = "" CharSequenceUtil.subAfter("abc", "a", false) = "bc" CharSequenceUtil.subAfter("abcba", "b", false) = "cba" CharSequenceUtil.subAfter("abc", "c", false) = "" CharSequenceUtil.subAfter("abc", "d", false) = "" CharSequenceUtil.subAfter("abc", "", false) = "abc"
`static String`	`subBefore(CharSequence string, char separator, boolean isLastSeparator)` 截取分隔字符串之前的字符串，不包括分隔字符串如果给定的字符串为空串（null或""）或者分隔字符串为null，返回原字符串如果分隔字符串未找到，返回原字符串，举例如下： CharSequenceUtil.subBefore(null, , false) = null CharSequenceUtil.subBefore("", , false) = "" CharSequenceUtil.subBefore("abc", 'a', false) = "" CharSequenceUtil.subBefore("abcba", 'b', false) = "a" CharSequenceUtil.subBefore("abc", 'c', false) = "ab" CharSequenceUtil.subBefore("abc", 'd', false) = "abc"
`static String`	`subBefore(CharSequence string, CharSequence separator, boolean isLastSeparator)` 截取分隔字符串之前的字符串，不包括分隔字符串如果给定的字符串为空串（null或""）或者分隔字符串为null，返回原字符串如果分隔字符串为空串""，则返回空串，如果分隔字符串未找到，返回原字符串，举例如下： CharSequenceUtil.subBefore(null, , false) = null CharSequenceUtil.subBefore("", , false) = "" CharSequenceUtil.subBefore("abc", "a", false) = "" CharSequenceUtil.subBefore("abcba", "b", false) = "a" CharSequenceUtil.subBefore("abc", "c", false) = "ab" CharSequenceUtil.subBefore("abc", "d", false) = "abc" CharSequenceUtil.subBefore("abc", "", false) = "" CharSequenceUtil.subBefore("abc", null, false) = "abc"
`static String`	`subBetween(CharSequence str, CharSequence beforeAndAfter)` 截取指定字符串中间部分，不包括标识字符串栗子： CharSequenceUtil.subBetween(null, *) = null CharSequenceUtil.subBetween("", "") = "" CharSequenceUtil.subBetween("", "tag") = null CharSequenceUtil.subBetween("tagabctag", null) = null CharSequenceUtil.subBetween("tagabctag", "") = "" CharSequenceUtil.subBetween("tagabctag", "tag") = "abc"
`static String`	`subBetween(CharSequence str, CharSequence before, CharSequence after)` 截取指定字符串中间部分，不包括标识字符串栗子： CharSequenceUtil.subBetween("wx[b]yz", "[", "]") = "b" CharSequenceUtil.subBetween(null, , ) = null CharSequenceUtil.subBetween(, null, ) = null CharSequenceUtil.subBetween(, , null) = null CharSequenceUtil.subBetween("", "", "") = "" CharSequenceUtil.subBetween("", "", "]") = null CharSequenceUtil.subBetween("", "[", "]") = null CharSequenceUtil.subBetween("yabcz", "", "") = "" CharSequenceUtil.subBetween("yabcz", "y", "z") = "abc" CharSequenceUtil.subBetween("yabczyabcz", "y", "z") = "abc"
`static String[]`	`subBetweenAll(CharSequence str, CharSequence prefixAndSuffix)` 截取指定字符串多段中间部分，不包括标识字符串栗子： CharSequenceUtil.subBetweenAll(null, ) = [] CharSequenceUtil.subBetweenAll(, null) = [] CharSequenceUtil.subBetweenAll(, ) = [] CharSequenceUtil.subBetweenAll("", "") = [] CharSequenceUtil.subBetweenAll("", "#") = [] CharSequenceUtil.subBetweenAll("gotanks", "") = [] CharSequenceUtil.subBetweenAll("#gotanks#", "#") = ["gotanks"] CharSequenceUtil.subBetweenAll("#hello# #world#!"
`static String[]`	`subBetweenAll(CharSequence str, CharSequence prefix, CharSequence suffix)` 截取指定字符串多段中间部分，不包括标识字符串栗子： CharSequenceUtil.subBetweenAll("wx[b]y[z]", "[", "]") = ["b","z"] CharSequenceUtil.subBetweenAll(null, , ) = [] CharSequenceUtil.subBetweenAll(, null, ) = [] CharSequenceUtil.subBetweenAll(, , null) = [] CharSequenceUtil.subBetweenAll("", "", "") = [] CharSequenceUtil.subBetweenAll("", "", "]") = [] CharSequenceUtil.subBetweenAll("", "[", "]") = [] CharSequenceUtil.subBetweenAll("yabcz", "", "") = [] CharSequenceUtil.subBetweenAll("yabcz", "y", "z") = ["abc"] CharSequenceUtil.subBetweenAll("yabczyabcz", "y", "z") = ["abc","abc"] CharSequenceUtil.subBetweenAll("[yabc[zy]abcz]", "[", "]"); = ["zy"] 重叠时只截取内部，
`static String`	`subByCodePoint(CharSequence str, int fromIndex, int toIndex)` 通过CodePoint截取字符串，可以截断Emoji
`static String`	`subPre(CharSequence string, int toIndexExclude)` 切割指定位置之前部分的字符串
`static String`	`subPreGbk(CharSequence str, int len, boolean halfUp)` 截取部分字符串，这里一个汉字的长度认为是2 可以自定义halfUp，如len为10，如果截取后最后一个字符是半个字符，`true`表示保留，则长度是11，否则长度9
`static String`	`subPreGbk(CharSequence str, int len, CharSequence suffix)` 截取部分字符串，这里一个汉字的长度认为是2
`static String`	`subSuf(CharSequence string, int fromIndex)` 切割指定位置之后部分的字符串
`static String`	`subSufByLength(CharSequence string, int length)` 切割指定长度的后部分的字符串 CharSequenceUtil.subSufByLength("abcde", 3) = "cde" CharSequenceUtil.subSufByLength("abcde", 0) = "" CharSequenceUtil.subSufByLength("abcde", -5) = "" CharSequenceUtil.subSufByLength("abcde", -1) = "" CharSequenceUtil.subSufByLength("abcde", 5) = "abcde" CharSequenceUtil.subSufByLength("abcde", 10) = "abcde" CharSequenceUtil.subSufByLength(null, 3) = null
`static String`	`subWithLength(String input, int fromIndex, int length)` 截取字符串,从指定位置开始,截取指定长度的字符串如果fromIndex为正数，则向后截取指定length长度，如果为负数，则向前截取length长度。
`static String`	`swapCase(String str)` 切换给定字符串中的大小写。
`static String`	`toCamelCase(CharSequence name)` 将下划线方式命名的字符串转换为驼峰式。
`static String`	`toCamelCase(CharSequence name, char symbol)` 将连接符方式命名的字符串转换为驼峰式。
`static String`	`toSymbolCase(CharSequence str, char symbol)` 将驼峰式命名的字符串转换为使用符号连接方式。
`static int`	`totalLength(CharSequence... strs)` 给定字符串数组的总长度 null字符长度定义为0
`static String`	`toUnderlineCase(CharSequence str)` 将驼峰式命名的字符串转换为下划线方式。
`static String`	`trim(CharSequence str)` 除去字符串头尾部的空白，如果字符串是`null`，依然返回`null`。
`static String`	`trim(CharSequence str, int mode)` 除去字符串头尾部的空白符，如果字符串是`null`，依然返回`null`。
`static String`	`trim(CharSequence str, int mode, Predicate<Character> predicate)` 按照断言，除去字符串头尾部的断言为真的字符，如果字符串是`null`，依然返回`null`。
`static String`	`trimEnd(CharSequence str)` 除去字符串尾部的空白，如果字符串是`null`，则返回`null`。
`static String`	`trimStart(CharSequence str)` 除去字符串头部的空白，如果字符串是`null`，则返回`null`。
`static String`	`trimToEmpty(CharSequence str)` 除去字符串头尾部的空白，如果字符串是`null`，返回`""`。
`static String`	`trimToNull(CharSequence str)` 除去字符串头尾部的空白，如果字符串是`null`或者""，返回`null`。
`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 byte[]`	`utf8Bytes(CharSequence str)` 编码字符串，编码为UTF-8
`static String`	`wrap(CharSequence str, CharSequence prefixAndSuffix)` 包装指定字符串当前缀和后缀一致时使用此方法
`static String`	`wrap(CharSequence str, CharSequence prefix, CharSequence suffix)` 包装指定字符串
`static String[]`	`wrapAll(CharSequence prefix, CharSequence suffix, CharSequence... strs)` 包装多个字符串
`static String[]`	`wrapAllIfMissing(CharSequence prefix, CharSequence suffix, CharSequence... strs)` 包装多个字符串，如果已经包装，则不再包装
`static String[]`	`wrapAllWithPair(CharSequence prefixAndSuffix, CharSequence... strs)` 使用单个字符包装多个字符串
`static String[]`	`wrapAllWithPairIfMissing(CharSequence prefixAndSuffix, CharSequence... strs)` 使用成对的字符包装多个字符串，如果已经包装，则不再包装
`static String`	`wrapIfMissing(CharSequence str, CharSequence prefix, CharSequence suffix)` 包装指定字符串，如果前缀或后缀已经包含对应的字符串，则不再包装

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

- Field Detail
  - INDEX_NOT_FOUND
```
public static final int INDEX_NOT_FOUND
```
    See Also:
    
    Constant Field Values
  - NULL
```
public static final String NULL
```
    字符串常量："null"
    注意："null" != null
    
    See Also:
    
    Constant Field Values
  - EMPTY
```
public static final String EMPTY
```
    字符串常量：空字符串 ""
    
    See Also:
    
    Constant Field Values
  - SPACE
```
public static final String SPACE
```
    字符串常量：空格符 " "
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - CharSequenceUtil
```
public CharSequenceUtil()
```
- Method Detail
  - isBlank
```
public static boolean isBlank(CharSequence str)
```
    字符串是否为空白，空白的定义如下：
    1. null
    2. 空字符串：""
    3. 空格、全角空格、制表符、换行符，等不可见字符
    例：
    - CharSequenceUtil.isBlank(null) // true
    - CharSequenceUtil.isBlank("") // true
    - CharSequenceUtil.isBlank(" \t\n") // true
    - CharSequenceUtil.isBlank("abc") // false
    注意：该方法与 isEmpty(CharSequence) 的区别是：该方法会校验空白字符，且性能相对于 isEmpty(CharSequence) 略慢。
    
    建议：
    - 该方法建议仅对于客户端（或第三方接口）传入的参数使用该方法。
    - 需要同时校验多个字符串时，建议采用 hasBlank(CharSequence...) 或 isAllBlank(CharSequence...)
    Parameters:
    
    str - 被检测的字符串
    
    Returns:
    
    若为空白，则返回 true
    
    See Also:
    
    isEmpty(CharSequence)
  - isNotBlank
```
public static boolean isNotBlank(CharSequence str)
```
    字符串是否为非空白，非空白的定义如下：
    1. 不为 null
    2. 不为空字符串：""
    3. 不为空格、全角空格、制表符、换行符，等不可见字符
    例：
    - CharSequenceUtil.isNotBlank(null) // false
    - CharSequenceUtil.isNotBlank("") // false
    - CharSequenceUtil.isNotBlank(" \t\n") // false
    - CharSequenceUtil.isNotBlank("abc") // true
    注意：该方法与 isNotEmpty(CharSequence) 的区别是：该方法会校验空白字符，且性能相对于 isNotEmpty(CharSequence) 略慢。
    
    建议：仅对于客户端（或第三方接口）传入的参数使用该方法。
    Parameters:
    
    str - 被检测的字符串
    
    Returns:
    
    是否为非空
    
    See Also:
    
    isBlank(CharSequence)
  - hasBlank
```
public static boolean hasBlank(CharSequence... strs)
```
    指定字符串数组中，是否包含空字符串。
    
    如果指定的字符串数组的长度为 0，或者其中的任意一个元素是空字符串，则返回 true。
    
    例：
    - CharSequenceUtil.hasBlank() // true
    - CharSequenceUtil.hasBlank("", null, " ") // true
    - CharSequenceUtil.hasBlank("123", " ") // true
    - CharSequenceUtil.hasBlank("123", "abc") // false
    注意：该方法与 isAllBlank(CharSequence...) 的区别在于：
    - hasBlank(CharSequence...) 等价于 isBlank(...) || isBlank(...) || ...
    - isAllBlank(CharSequence...) 等价于 isBlank(...) && isBlank(...) && ...
    Parameters:
    
    strs - 字符串列表
    
    Returns:
    
    是否包含空字符串
  - isAllBlank
```
public static boolean isAllBlank(CharSequence... strs)
```
    指定字符串数组中的元素，是否全部为空字符串。
    
    如果指定的字符串数组的长度为 0，或者所有元素都是空字符串，则返回 true。
    
    例：
    - CharSequenceUtil.isAllBlank() // true
    - CharSequenceUtil.isAllBlank("", null, " ") // true
    - CharSequenceUtil.isAllBlank("123", " ") // false
    - CharSequenceUtil.isAllBlank("123", "abc") // false
    注意：该方法与 hasBlank(CharSequence...) 的区别在于：
    - hasBlank(CharSequence...) 等价于 isBlank(...) || isBlank(...) || ...
    - isAllBlank(CharSequence...) 等价于 isBlank(...) && isBlank(...) && ...
    Parameters:
    
    strs - 字符串列表
    
    Returns:
    
    所有字符串是否为空白
  - isEmpty
```
public static boolean isEmpty(CharSequence str)
```
    字符串是否为空，空的定义如下：
    1. null
    2. 空字符串：""
    例：
    - CharSequenceUtil.isEmpty(null) // true
    - CharSequenceUtil.isEmpty("") // true
    - CharSequenceUtil.isEmpty(" \t\n") // false
    - CharSequenceUtil.isEmpty("abc") // false
    注意：该方法与 isBlank(CharSequence) 的区别是：该方法不校验空白字符。
    
    建议：
    - 该方法建议用于工具类或任何可以预期的方法参数的校验中。
    - 需要同时校验多个字符串时，建议采用 hasEmpty(CharSequence...) 或 isAllEmpty(CharSequence...)
    Parameters:
    
    str - 被检测的字符串
    
    Returns:
    
    是否为空
    
    See Also:
    
    isBlank(CharSequence)
  - isNotEmpty
```
public static boolean isNotEmpty(CharSequence str)
```
    字符串是否为非空白，非空白的定义如下：
    1. 不为 null
    2. 不为空字符串：""
    例：
    - CharSequenceUtil.isNotEmpty(null) // false
    - CharSequenceUtil.isNotEmpty("") // false
    - CharSequenceUtil.isNotEmpty(" \t\n") // true
    - CharSequenceUtil.isNotEmpty("abc") // true
    注意：该方法与 isNotBlank(CharSequence) 的区别是：该方法不校验空白字符。
    
    建议：该方法建议用于工具类或任何可以预期的方法参数的校验中。
    Parameters:
    
    str - 被检测的字符串
    
    Returns:
    
    是否为非空
    
    See Also:
    
    isEmpty(CharSequence)
  - emptyIfNull
```
public static String emptyIfNull(CharSequence str)
```
    当给定字符串为null时，转换为Empty
    
    Parameters:
    
    str - 被检查的字符串
    
    Returns:
    
    原字符串或者空串
    
    Since:
    
    4.6.3
    
    See Also:
    
    nullToEmpty(CharSequence)
  - 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:
    
    字符串本身或指定的默认字符串
  - emptyToDefault
```
public static String emptyToDefault(CharSequence str,
                                    String defaultStr)
```
    如果字符串是null或者""，则返回指定默认字符串，否则返回字符串本身。
```
 emptyToDefault(null, "default")  = "default"
 emptyToDefault("", "default")    = "default"
 emptyToDefault("  ", "default")  = "  "
 emptyToDefault("bat", "default") = "bat"
 
```
    Parameters:
    
    str - 要转换的字符串
    
    defaultStr - 默认字符串
    
    Returns:
    
    字符串本身或指定的默认字符串
    
    Since:
    
    4.1.0
  - blankToDefault
```
public static String blankToDefault(CharSequence str,
                                    String defaultStr)
```
    如果字符串是null或者""或者空白，则返回指定默认字符串，否则返回字符串本身。
```
 blankToDefault(null, "default")  = "default"
 blankToDefault("", "default")    = "default"
 blankToDefault("  ", "default")  = "default"
 blankToDefault("bat", "default") = "bat"
 
```
    Parameters:
    
    str - 要转换的字符串
    
    defaultStr - 默认字符串
    
    Returns:
    
    字符串本身或指定的默认字符串
    
    Since:
    
    4.1.0
  - emptyToNull
```
public static String emptyToNull(CharSequence str)
```
    当给定字符串为空字符串时，转换为null
    
    Parameters:
    
    str - 被转换的字符串
    
    Returns:
    
    转换后的字符串
  - hasEmpty
```
public static boolean hasEmpty(CharSequence... strs)
```
    是否包含空字符串。
    
    如果指定的字符串数组的长度为 0，或者其中的任意一个元素是空字符串，则返回 true。
    
    例：
    - CharSequenceUtil.hasEmpty() // true
    - CharSequenceUtil.hasEmpty("", null) // true
    - CharSequenceUtil.hasEmpty("123", "") // true
    - CharSequenceUtil.hasEmpty("123", "abc") // false
    - CharSequenceUtil.hasEmpty(" ", "\t", "\n") // false
    注意：该方法与 isAllEmpty(CharSequence...) 的区别在于：
    - hasEmpty(CharSequence...) 等价于 isEmpty(...) || isEmpty(...) || ...
    - isAllEmpty(CharSequence...) 等价于 isEmpty(...) && isEmpty(...) && ...
    Parameters:
    
    strs - 字符串列表
    
    Returns:
    
    是否包含空字符串
  - isAllEmpty
```
public static boolean isAllEmpty(CharSequence... strs)
```
    指定字符串数组中的元素，是否全部为空字符串。
    
    如果指定的字符串数组的长度为 0，或者所有元素都是空字符串，则返回 true。
    
    例：
    - CharSequenceUtil.isAllEmpty() // true
    - CharSequenceUtil.isAllEmpty("", null) // true
    - CharSequenceUtil.isAllEmpty("123", "") // false
    - CharSequenceUtil.isAllEmpty("123", "abc") // false
    - CharSequenceUtil.isAllEmpty(" ", "\t", "\n") // false
    注意：该方法与 hasEmpty(CharSequence...) 的区别在于：
    - hasEmpty(CharSequence...) 等价于 isEmpty(...) || isEmpty(...) || ...
    - isAllEmpty(CharSequence...) 等价于 isEmpty(...) && isEmpty(...) && ...
    Parameters:
    
    strs - 字符串列表
    
    Returns:
    
    所有字符串是否为空白
  - isAllNotEmpty
```
public static boolean isAllNotEmpty(CharSequence... args)
```
    指定字符串数组中的元素，是否都不为空字符串。
    
    如果指定的字符串数组的长度不为 0，或者所有元素都不是空字符串，则返回 true。
    
    例：
    - CharSequenceUtil.isAllNotEmpty() // false
    - CharSequenceUtil.isAllNotEmpty("", null) // false
    - CharSequenceUtil.isAllNotEmpty("123", "") // false
    - CharSequenceUtil.isAllNotEmpty("123", "abc") // true
    - CharSequenceUtil.isAllNotEmpty(" ", "\t", "\n") // true
    注意：该方法与 isAllEmpty(CharSequence...) 的区别在于：
    - isAllEmpty(CharSequence...) 等价于 isEmpty(...) && isEmpty(...) && ...
    - isAllNotEmpty(CharSequence...) 等价于 !isEmpty(...) && !isEmpty(...) && ...
    Parameters:
    
    args - 字符串数组
    
    Returns:
    
    所有字符串是否都不为为空白
    
    Since:
    
    5.3.6
  - isAllNotBlank
```
public static boolean isAllNotBlank(CharSequence... args)
```
    是否存都不为null或空对象或空白符的对象，通过hasBlank(CharSequence...) 判断元素
    
    Parameters:
    
    args - 被检查的对象,一个或者多个
    
    Returns:
    
    是否都不为空
    
    Since:
    
    5.3.6
  - isNullOrUndefined
```
public static boolean isNullOrUndefined(CharSequence str)
```
    检查字符串是否为null、“null”、“undefined”
    
    Parameters:
    
    str - 被检查的字符串
    
    Returns:
    
    是否为null、“null”、“undefined”
    
    Since:
    
    4.0.10
  - isEmptyOrUndefined
```
public static boolean isEmptyOrUndefined(CharSequence str)
```
    检查字符串是否为null、“”、“null”、“undefined”
    
    Parameters:
    
    str - 被检查的字符串
    
    Returns:
    
    是否为null、“”、“null”、“undefined”
    
    Since:
    
    4.0.10
  - isBlankOrUndefined
```
public static boolean isBlankOrUndefined(CharSequence str)
```
    检查字符串是否为null、空白串、“null”、“undefined”
    
    Parameters:
    
    str - 被检查的字符串
    
    Returns:
    
    是否为null、空白串、“null”、“undefined”
    
    Since:
    
    4.0.10
  - trim
```
public static String trim(CharSequence str)
```
    除去字符串头尾部的空白，如果字符串是null，依然返回null。
    注意，和String.trim()不同，此方法使用CharUtil.isBlankChar(char) 来判定空白，因而可以除去英文字符集之外的其它空白，如中文空格。
```
 trim(null)          = null
 trim("")            = ""
 trim("     ")       = ""
 trim("abc")         = "abc"
 trim("    abc    ") = "abc"
 
```
    Parameters:
    
    str - 要处理的字符串
    
    Returns:
    
    除去头尾空白的字符串，如果原字串为null，则返回null
  - trimToEmpty
```
public static String trimToEmpty(CharSequence str)
```
    除去字符串头尾部的空白，如果字符串是null，返回""。
```
 CharSequenceUtil.trimToEmpty(null)          = ""
 CharSequenceUtil.trimToEmpty("")            = ""
 CharSequenceUtil.trimToEmpty("     ")       = ""
 CharSequenceUtil.trimToEmpty("abc")         = "abc"
 CharSequenceUtil.trimToEmpty("    abc    ") = "abc"
 
```
    Parameters:
    
    str - 字符串
    
    Returns:
    
    去除两边空白符后的字符串, 如果为null返回""
    
    Since:
    
    3.1.1
  - trimToNull
```
public static String trimToNull(CharSequence str)
```
    除去字符串头尾部的空白，如果字符串是null或者""，返回null。
```
 CharSequenceUtil.trimToNull(null)          = null
 CharSequenceUtil.trimToNull("")            = null
 CharSequenceUtil.trimToNull("     ")       = null
 CharSequenceUtil.trimToNull("abc")         = "abc"
 CharSequenceUtil.trimToEmpty("    abc    ") = "abc"
 
```
    Parameters:
    
    str - 字符串
    
    Returns:
    
    去除两边空白符后的字符串, 如果为空返回null
    
    Since:
    
    3.2.1
  - trimStart
```
public static String trimStart(CharSequence str)
```
    除去字符串头部的空白，如果字符串是null，则返回null。
    注意，和String.trim()不同，此方法使用CharUtil.isBlankChar(char) 来判定空白，因而可以除去英文字符集之外的其它空白，如中文空格。
```
 trimStart(null)         = null
 trimStart("")           = ""
 trimStart("abc")        = "abc"
 trimStart("  abc")      = "abc"
 trimStart("abc  ")      = "abc  "
 trimStart(" abc ")      = "abc "
 
```
    Parameters:
    
    str - 要处理的字符串
    
    Returns:
    
    除去空白的字符串，如果原字串为null或结果字符串为""，则返回 null
  - trimEnd
```
public static String trimEnd(CharSequence str)
```
    除去字符串尾部的空白，如果字符串是null，则返回null。
    注意，和String.trim()不同，此方法使用CharUtil.isBlankChar(char) 来判定空白，因而可以除去英文字符集之外的其它空白，如中文空格。
```
 trimEnd(null)       = null
 trimEnd("")         = ""
 trimEnd("abc")      = "abc"
 trimEnd("  abc")    = "  abc"
 trimEnd("abc  ")    = "abc"
 trimEnd(" abc ")    = " abc"
 
```
    Parameters:
    
    str - 要处理的字符串
    
    Returns:
    
    除去空白的字符串，如果原字串为null或结果字符串为""，则返回 null
  - trim
```
public static String trim(CharSequence str,
                          int mode)
```
    除去字符串头尾部的空白符，如果字符串是null，依然返回null。
    
    Parameters:
    
    str - 要处理的字符串
    
    mode - -1表示trimStart，0表示trim全部， 1表示trimEnd
    
    Returns:
    
    除去指定字符后的的字符串，如果原字串为null，则返回null
  - trim
```
public static String trim(CharSequence str,
                          int mode,
                          Predicate<Character> predicate)
```
    按照断言，除去字符串头尾部的断言为真的字符，如果字符串是null，依然返回null。
    
    Parameters:
    
    str - 要处理的字符串
    
    mode - -1表示trimStart，0表示trim全部， 1表示trimEnd
    
    predicate - 断言是否过掉字符，返回true表述过滤掉，false表示不过滤
    
    Returns:
    
    除去指定字符后的的字符串，如果原字串为null，则返回null
    
    Since:
    
    5.7.4
  - startWith
```
public static boolean startWith(CharSequence str,
                                char c)
```
    字符串是否以给定字符开始
    
    Parameters:
    
    str - 字符串
    
    c - 字符
    
    Returns:
    
    是否开始
  - startWith
```
public static boolean startWith(CharSequence str,
                                CharSequence prefix,
                                boolean ignoreCase)
```
    是否以指定字符串开头
    如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
    
    Parameters:
    
    str - 被监测字符串
    
    prefix - 开头字符串
    
    ignoreCase - 是否忽略大小写
    
    Returns:
    
    是否以指定字符串开头
    
    Since:
    
    5.4.3
  - startWith
```
public static boolean startWith(CharSequence str,
                                CharSequence prefix,
                                boolean ignoreCase,
                                boolean ignoreEquals)
```
    是否以指定字符串开头
    如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
```
     CharSequenceUtil.startWith("123", "123", false, true);   -- false
     CharSequenceUtil.startWith("ABCDEF", "abc", true, true); -- true
     CharSequenceUtil.startWith("abc", "abc", true, true);    -- false
 
```
    Parameters:
    
    str - 被监测字符串
    
    prefix - 开头字符串
    
    ignoreCase - 是否忽略大小写
    
    ignoreEquals - 是否忽略字符串相等的情况
    
    Returns:
    
    是否以指定字符串开头
    
    Since:
    
    5.4.3
  - startWith
```
public static boolean startWith(CharSequence str,
                                CharSequence prefix)
```
    是否以指定字符串开头
    
    Parameters:
    
    str - 被监测字符串
    
    prefix - 开头字符串
    
    Returns:
    
    是否以指定字符串开头
  - startWithIgnoreEquals
```
public static boolean startWithIgnoreEquals(CharSequence str,
                                            CharSequence prefix)
```
    是否以指定字符串开头，忽略相等字符串的情况
    
    Parameters:
    
    str - 被监测字符串
    
    prefix - 开头字符串
    
    Returns:
    
    是否以指定字符串开头并且两个字符串不相等
  - startWithIgnoreCase
```
public static boolean startWithIgnoreCase(CharSequence str,
                                          CharSequence prefix)
```
    是否以指定字符串开头，忽略大小写
    
    Parameters:
    
    str - 被监测字符串
    
    prefix - 开头字符串
    
    Returns:
    
    是否以指定字符串开头
  - startWithAny
```
public static boolean startWithAny(CharSequence str,
                                   CharSequence... prefixes)
```
    给定字符串是否以任何一个字符串开始
    给定字符串和数组为空都返回false
    
    Parameters:
    
    str - 给定字符串
    
    prefixes - 需要检测的开始字符串
    
    Returns:
    
    给定字符串是否以任何一个字符串开始
    
    Since:
    
    3.0.6
  - startWithAnyIgnoreCase
```
public static boolean startWithAnyIgnoreCase(CharSequence str,
                                             CharSequence... prefixes)
```
    给定字符串是否以任何一个字符串开始（忽略大小写）
    给定字符串和数组为空都返回false
    
    Parameters:
    
    str - 给定字符串
    
    prefixes - 需要检测的开始字符串
    
    Returns:
    
    给定字符串是否以任何一个字符串开始
    
    Since:
    
    5.8.1
  - endWith
```
public static boolean endWith(CharSequence str,
                              char c)
```
    字符串是否以给定字符结尾
    
    Parameters:
    
    str - 字符串
    
    c - 字符
    
    Returns:
    
    是否结尾
  - endWith
```
public static boolean endWith(CharSequence str,
                              CharSequence suffix,
                              boolean ignoreCase)
```
    是否以指定字符串结尾
    如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
    
    Parameters:
    
    str - 被监测字符串
    
    suffix - 结尾字符串
    
    ignoreCase - 是否忽略大小写
    
    Returns:
    
    是否以指定字符串结尾
  - endWith
```
public static boolean endWith(CharSequence str,
                              CharSequence suffix,
                              boolean ignoreCase,
                              boolean ignoreEquals)
```
    是否以指定字符串结尾
    如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
    
    Parameters:
    
    str - 被监测字符串
    
    suffix - 结尾字符串
    
    ignoreCase - 是否忽略大小写
    
    ignoreEquals - 是否忽略字符串相等的情况
    
    Returns:
    
    是否以指定字符串结尾
    
    Since:
    
    5.8.0
  - 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:
    
    是否以指定字符串结尾
  - endWithAny
```
public static boolean endWithAny(CharSequence str,
                                 CharSequence... suffixes)
```
    给定字符串是否以任何一个字符串结尾
    给定字符串和数组为空都返回false
    
    Parameters:
    
    str - 给定字符串
    
    suffixes - 需要检测的结尾字符串
    
    Returns:
    
    给定字符串是否以任何一个字符串结尾
    
    Since:
    
    3.0.6
  - endWithAnyIgnoreCase
```
public static boolean endWithAnyIgnoreCase(CharSequence str,
                                           CharSequence... suffixes)
```
    给定字符串是否以任何一个字符串结尾（忽略大小写）
    给定字符串和数组为空都返回false
    
    Parameters:
    
    str - 给定字符串
    
    suffixes - 需要检测的结尾字符串
    
    Returns:
    
    给定字符串是否以任何一个字符串结尾
    
    Since:
    
    5.5.9
  - contains
```
public static boolean contains(CharSequence str,
                               char searchChar)
```
    指定字符是否在字符串中出现过
    
    Parameters:
    
    str - 字符串
    
    searchChar - 被查找的字符
    
    Returns:
    
    是否包含
    
    Since:
    
    3.1.2
  - contains
```
public static boolean contains(CharSequence str,
                               CharSequence searchStr)
```
    指定字符串是否在字符串中出现过
    
    Parameters:
    
    str - 字符串
    
    searchStr - 被查找的字符串
    
    Returns:
    
    是否包含
    
    Since:
    
    5.1.1
  - 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)
```
    检查指定字符串中是否只包含给定的字符
    这里的containsOnly并不是必须全部给定的testChars都需要有，而是一个子集。testChars是个限定集合，检查字符串中的字符是否在这个限定集合中。
```
   StrUtil.containsOnly("asdas", 'a', 'd', 's','l');   --> true
 
```
    Parameters:
    
    str - 字符串
    
    testChars - 检查的字符
    
    Returns:
    
    字符串含有非检查的字符，返回false
    
    Since:
    
    4.4.1
  - containsAll
```
public static boolean containsAll(CharSequence str,
                                  CharSequence... 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
  - 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 text,
                          char searchChar,
                          int start,
                          int end)
```
    指定范围内查找指定字符
    
    Parameters:
    
    text - 字符串
    
    searchChar - 被查找的字符
    
    start - 起始位置，如果小于0，从0开始查找
    
    end - 终止位置，如果超过str.length()则默认查找到字符串末尾
    
    Returns:
    
    位置
  - indexOfIgnoreCase
```
public static int indexOfIgnoreCase(CharSequence str,
                                    CharSequence searchStr)
```
    指定范围内查找字符串，忽略大小写
```
 CharSequenceUtil.indexOfIgnoreCase(null, *, *)          = -1
 CharSequenceUtil.indexOfIgnoreCase(*, null, *)          = -1
 CharSequenceUtil.indexOfIgnoreCase("", "", 0)           = 0
 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "A", 0)  = 0
 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "B", 0)  = 2
 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "AB", 0) = 1
 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "B", 3)  = 5
 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "B", 9)  = -1
 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "B", -1) = 2
 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "", 2)   = 2
 CharSequenceUtil.indexOfIgnoreCase("abc", "", 9)        = -1
 
```
    Parameters:
    
    str - 字符串
    
    searchStr - 需要查找位置的字符串
    
    Returns:
    
    位置
    
    Since:
    
    3.2.1
  - indexOfIgnoreCase
```
public static int indexOfIgnoreCase(CharSequence str,
                                    CharSequence searchStr,
                                    int fromIndex)
```
    指定范围内查找字符串
```
 CharSequenceUtil.indexOfIgnoreCase(null, *, *)          = -1
 CharSequenceUtil.indexOfIgnoreCase(*, null, *)          = -1
 CharSequenceUtil.indexOfIgnoreCase("", "", 0)           = 0
 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "A", 0)  = 0
 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "B", 0)  = 2
 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "AB", 0) = 1
 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "B", 3)  = 5
 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "B", 9)  = -1
 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "B", -1) = 2
 CharSequenceUtil.indexOfIgnoreCase("aabaabaa", "", 2)   = 2
 CharSequenceUtil.indexOfIgnoreCase("abc", "", 9)        = -1
 
```
    Parameters:
    
    str - 字符串
    
    searchStr - 需要查找位置的字符串
    
    fromIndex - 起始位置
    
    Returns:
    
    位置
    
    Since:
    
    3.2.1
  - indexOf
```
public static int indexOf(CharSequence text,
                          CharSequence searchStr,
                          int from,
                          boolean ignoreCase)
```
    指定范围内查找字符串
    
    Parameters:
    
    text - 字符串，空则返回-1
    
    searchStr - 需要查找位置的字符串，空则返回-1
    
    from - 起始位置（包含）
    
    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)
```
    指定范围内查找字符串，忽略大小写
    fromIndex 为搜索起始位置，从后往前计数
    
    Parameters:
    
    str - 字符串
    
    searchStr - 需要查找位置的字符串
    
    fromIndex - 起始位置，从后往前计数
    
    Returns:
    
    位置
    
    Since:
    
    3.2.1
  - lastIndexOf
```
public static int lastIndexOf(CharSequence text,
                              CharSequence searchStr,
                              int from,
                              boolean ignoreCase)
```
    指定范围内查找字符串
    fromIndex 为搜索起始位置，从后往前计数
    
    Parameters:
    
    text - 字符串
    
    searchStr - 需要查找位置的字符串
    
    from - 起始位置，从后往前计数
    
    ignoreCase - 是否忽略大小写
    
    Returns:
    
    位置
    
    Since:
    
    3.2.1
  - ordinalIndexOf
```
public static int ordinalIndexOf(CharSequence str,
                                 CharSequence searchStr,
                                 int ordinal)
```
    返回字符串 searchStr 在字符串 str 中第 ordinal 次出现的位置。
    如果 str=null 或 searchStr=null 或 ordinal≤0 则返回-1
    此方法来自：Apache-Commons-Lang
    例子（*代表任意字符）：
```
 CharSequenceUtil.ordinalIndexOf(null, *, *)          = -1
 CharSequenceUtil.ordinalIndexOf(*, null, *)          = -1
 CharSequenceUtil.ordinalIndexOf("", "", *)           = 0
 CharSequenceUtil.ordinalIndexOf("aabaabaa", "a", 1)  = 0
 CharSequenceUtil.ordinalIndexOf("aabaabaa", "a", 2)  = 1
 CharSequenceUtil.ordinalIndexOf("aabaabaa", "b", 1)  = 2
 CharSequenceUtil.ordinalIndexOf("aabaabaa", "b", 2)  = 5
 CharSequenceUtil.ordinalIndexOf("aabaabaa", "ab", 1) = 1
 CharSequenceUtil.ordinalIndexOf("aabaabaa", "ab", 2) = 4
 CharSequenceUtil.ordinalIndexOf("aabaabaa", "", 1)   = 0
 CharSequenceUtil.ordinalIndexOf("aabaabaa", "", 2)   = 0
 
```
    Parameters:
    
    str - 被检查的字符串，可以为null
    
    searchStr - 被查找的字符串，可以为null
    
    ordinal - 第几次出现的位置
    
    Returns:
    
    查找到的位置
    
    Since:
    
    3.2.3
  - removeAll
```
public static String removeAll(CharSequence str,
                               CharSequence strToRemove)
```
    移除字符串中所有给定字符串
    例：removeAll("aa-bb-cc-dd", "-") =》 aabbccdd
    
    Parameters:
    
    str - 字符串
    
    strToRemove - 被移除的字符串
    
    Returns:
    
    移除后的字符串
  - removeAny
```
public static String removeAny(CharSequence str,
                               CharSequence... strsToRemove)
```
    移除字符串中所有给定字符串，当某个字符串出现多次，则全部移除
    例：removeAny("aa-bb-cc-dd", "a", "b") =》 --cc-dd
    
    Parameters:
    
    str - 字符串
    
    strsToRemove - 被移除的字符串
    
    Returns:
    
    移除后的字符串
    
    Since:
    
    5.3.8
  - removeAll
```
public static String removeAll(CharSequence str,
                               char... chars)
```
    去除字符串中指定的多个字符，如有多个则全部去除
    
    Parameters:
    
    str - 字符串
    
    chars - 字符列表
    
    Returns:
    
    去除后的字符
    
    Since:
    
    4.2.2
  - removeAllLineBreaks
```
public static String removeAllLineBreaks(CharSequence str)
```
    去除所有换行符，包括：
```
 1. \r
 1. \n
 
```
    Parameters:
    
    str - 字符串
    
    Returns:
    
    处理后的字符串
    
    Since:
    
    4.2.2
  - 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
  - removePrefix
```
public static String removePrefix(CharSequence str,
                                  CharSequence prefix)
```
    去掉指定前缀
    
    Parameters:
    
    str - 字符串
    
    prefix - 前缀
    
    Returns:
    
    切掉后的字符串，若前缀不是 preffix，返回原字符串
  - removeAllPrefix
```
public static String removeAllPrefix(CharSequence str,
                                     CharSequence prefix)
```
    去掉指定所有前缀，如：
```
     str=abcdef, prefix=ab => return cdef
     str=ababcdef, prefix=ab => return cdef
     str=ababcdef, prefix="" => return ababcdef
     str=ababcdef, prefix=null => return ababcdef
 
```
    Parameters:
    
    str - 字符串，空返回原字符串
    
    prefix - 前缀，空返回原字符串
    
    Returns:
    
    去掉所有前缀的字符串，若前缀不是 preffix，返回原字符串
    
    Since:
    
    5.8.30
  - 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，返回原字符串
  - removeAllSuffix
```
public static String removeAllSuffix(CharSequence str,
                                     CharSequence suffix)
```
    去掉指定所有后缀，如：
```
     str=11abab, suffix=ab => return 11
     str=11ab, suffix=ab => return 11
     str=11ab, suffix="" => return 11ab
     str=11ab, suffix=null => return 11ab
 
```
    Parameters:
    
    str - 字符串，空返回原字符串
    
    suffix - 后缀字符串，空返回原字符串
    
    Returns:
    
    去掉所有后缀的字符串，若后缀不是 suffix，返回原字符串
    
    Since:
    
    5.8.30
  - removeSufAndLowerFirst
```
public static String removeSufAndLowerFirst(CharSequence str,
                                            CharSequence suffix)
```
    去掉指定后缀，并小写首字母
    
    Parameters:
    
    str - 字符串
    
    suffix - 后缀
    
    Returns:
    
    切掉后的字符串，若后缀不是 suffix，返回原字符串
  - removeSuffixIgnoreCase
```
public static String removeSuffixIgnoreCase(CharSequence str,
                                            CharSequence suffix)
```
    忽略大小写去掉指定后缀
    
    Parameters:
    
    str - 字符串
    
    suffix - 后缀
    
    Returns:
    
    切掉后的字符串，若后缀不是 suffix，返回原字符串
  - cleanBlank
```
public static String cleanBlank(CharSequence str)
```
    清理空白字符
    
    Parameters:
    
    str - 被清理的字符串
    
    Returns:
    
    清理后的字符串
  - 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
  - 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)
```
    去除两边的指定字符串
    两边字符如果存在，则去除，不存在不做处理
```
 "aaa_STRIPPED_bbb", "a", "b"  -> "aa_STRIPPED_bb"
 "aaa_STRIPPED_bbb", null, null  -> "aaa_STRIPPED_bbb"
 "aaa_STRIPPED_bbb", "", ""  -> "aaa_STRIPPED_bbb"
 "aaa_STRIPPED_bbb", "", "b"  -> "aaa_STRIPPED_bb"
 "aaa_STRIPPED_bbb", null, "b"  -> "aaa_STRIPPED_bb"
 "aaa_STRIPPED_bbb", "a", ""  -> "aa_STRIPPED_bbb"
 "aaa_STRIPPED_bbb", "a", null  -> "aa_STRIPPED_bbb"

 "a", "a", "a"  -> ""
 
 
```
    Parameters:
    
    str - 被处理的字符串
    
    prefix - 前缀
    
    suffix - 后缀
    
    Returns:
    
    处理后的字符串
    
    Since:
    
    3.1.2
  - strip
```
public static String strip(CharSequence str,
                           CharSequence prefix,
                           CharSequence suffix,
                           boolean ignoreCase)
```
    去除两边的指定字符串
    两边字符如果存在，则去除，不存在不做处理
```
 "aaa_STRIPPED_bbb", "a", "b"  -> "aa_STRIPPED_bb"
 "aaa_STRIPPED_bbb", null, null  -> "aaa_STRIPPED_bbb"
 "aaa_STRIPPED_bbb", "", ""  -> "aaa_STRIPPED_bbb"
 "aaa_STRIPPED_bbb", "", "b"  -> "aaa_STRIPPED_bb"
 "aaa_STRIPPED_bbb", null, "b"  -> "aaa_STRIPPED_bb"
 "aaa_STRIPPED_bbb", "a", ""  -> "aa_STRIPPED_bbb"
 "aaa_STRIPPED_bbb", "a", null  -> "aa_STRIPPED_bbb"

 "a", "a", "a"  -> ""
 
 
```
    Parameters:
    
    str - 被处理的字符串
    
    prefix - 前缀
    
    suffix - 后缀
    
    ignoreCase - 是否忽略大小写
    
    Returns:
    
    处理后的字符串
    
    Since:
    
    3.1.2
  - stripAll
```
public static String stripAll(CharSequence str,
                              CharSequence prefixOrSuffix)
```
    去除两边所有的指定字符串
```
 "aaa_STRIPPED_bbb", "a"  -> "_STRIPPED_bbb"
 "aaa_STRIPPED_bbb", "a", "b"  -> "_STRIPPED_"
 "aaa_STRIPPED_bbb", ""  -> "aaa_STRIPPED_bbb"
 
 
```
    Parameters:
    
    str - 被处理的字符串
    
    prefixOrSuffix - 前缀或后缀
    
    Returns:
    
    处理后的字符串
    
    Since:
    
    5.8.30
  - stripAll
```
public static String stripAll(CharSequence str,
                              CharSequence prefix,
                              CharSequence suffix)
```
    去除两边所有的指定字符串
```
 "aaa_STRIPPED_bbb", "a", "b"  -> "_STRIPPED_"
 "aaa_STRIPPED_bbb", null, null  -> "aaa_STRIPPED_bbb"
 "aaa_STRIPPED_bbb", "", ""  -> "aaa_STRIPPED_bbb"
 "aaa_STRIPPED_bbb", "", "b"  -> "aaa_STRIPPED_"
 "aaa_STRIPPED_bbb", null, "b"  -> "aaa_STRIPPED_"
 "aaa_STRIPPED_bbb", "a", ""  -> "_STRIPPED_bbb"
 "aaa_STRIPPED_bbb", "a", null  -> "_STRIPPED_bbb"

 // special test
 "aaaaaabbb", "aaa", null  -> "bbb"
 "aaaaaaabbb", "aa", null  -> "abbb"

 "aaaaaaaaa", "aaa", "aa"  -> ""
 "a", "a", "a"  -> ""
 
 
```
    Parameters:
    
    str - 被处理的字符串
    
    prefix - 前缀
    
    suffix - 后缀
    
    Returns:
    
    处理后的字符串
    
    Since:
    
    5.8.30
  - addPrefixIfNot
```
public static String addPrefixIfNot(CharSequence str,
                                    CharSequence prefix)
```
    如果给定字符串不是以prefix开头的，在开头补充 prefix
    
    Parameters:
    
    str - 字符串
    
    prefix - 前缀
    
    Returns:
    
    补充后的字符串
    
    See Also:
    
    prependIfMissing(CharSequence, CharSequence, CharSequence...)
  - addSuffixIfNot
```
public static String addSuffixIfNot(CharSequence str,
                                    CharSequence suffix)
```
    如果给定字符串不是以suffix结尾的，在尾部补充 suffix
    
    Parameters:
    
    str - 字符串
    
    suffix - 后缀
    
    Returns:
    
    补充后的字符串
    
    See Also:
    
    appendIfMissing(CharSequence, CharSequence, CharSequence...)
  - splitToLong
```
public static long[] splitToLong(CharSequence str,
                                 char separator)
```
    切分字符串为long数组
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符
    
    Returns:
    
    切分后long数组
    
    Since:
    
    4.0.6
  - splitToLong
```
public static long[] splitToLong(CharSequence str,
                                 CharSequence separator)
```
    切分字符串为long数组
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符串
    
    Returns:
    
    切分后long数组
    
    Since:
    
    4.0.6
  - splitToInt
```
public static int[] splitToInt(CharSequence str,
                               char separator)
```
    切分字符串为int数组
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符
    
    Returns:
    
    切分后long数组
    
    Since:
    
    4.0.6
  - splitToInt
```
public static int[] splitToInt(CharSequence str,
                               CharSequence separator)
```
    切分字符串为int数组
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符串
    
    Returns:
    
    切分后long数组
    
    Since:
    
    4.0.6
  - 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:
    
    切分后的集合
  - splitToArray
```
public static String[] splitToArray(CharSequence str,
                                    CharSequence separator)
```
    切分字符串，如果分隔符不存在则返回原字符串
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符
    
    Returns:
    
    字符串
    
    Since:
    
    5.6.7
  - splitToArray
```
public static String[] splitToArray(CharSequence str,
                                    char separator)
```
    切分字符串
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    Returns:
    
    切分后的数组
  - splitToArray
```
public static String[] splitToArray(CharSequence text,
                                    char separator,
                                    int limit)
```
    切分字符串
    
    Parameters:
    
    text - 被切分的字符串
    
    separator - 分隔符字符
    
    limit - 限制分片数
    
    Returns:
    
    切分后的数组
  - split
```
public static List<String> split(CharSequence str,
                                 char separator,
                                 int limit)
```
    切分字符串，不去除切分后每个元素两边的空白符，不去除空白项
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    limit - 限制分片数，-1不限制
    
    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(CharSequence str,
                                     CharSequence separator)
```
    切分字符串，去除切分后每个元素两边的空白符，去除空白项
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    Returns:
    
    切分后的集合
    
    Since:
    
    3.2.0
  - splitTrim
```
public static List<String> splitTrim(CharSequence str,
                                     char separator,
                                     int limit)
```
    切分字符串，去除切分后每个元素两边的空白符，去除空白项
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    limit - 限制分片数，-1不限制
    
    Returns:
    
    切分后的集合
    
    Since:
    
    3.1.0
  - splitTrim
```
public static List<String> splitTrim(CharSequence str,
                                     CharSequence separator,
                                     int limit)
```
    切分字符串，去除切分后每个元素两边的空白符，去除空白项
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    limit - 限制分片数，-1不限制
    
    Returns:
    
    切分后的集合
    
    Since:
    
    3.2.0
  - split
```
public static List<String> split(CharSequence str,
                                 char separator,
                                 boolean isTrim,
                                 boolean ignoreEmpty)
```
    切分字符串，不限制分片数量
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    isTrim - 是否去除切分字符串后每个元素两边的空格
    
    ignoreEmpty - 是否忽略空串
    
    Returns:
    
    切分后的集合
    
    Since:
    
    3.0.8
  - split
```
public static List<String> split(CharSequence str,
                                 char separator,
                                 int limit,
                                 boolean isTrim,
                                 boolean ignoreEmpty)
```
    切分字符串
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    limit - 限制分片数，-1不限制
    
    isTrim - 是否去除切分字符串后每个元素两边的空格
    
    ignoreEmpty - 是否忽略空串
    
    Returns:
    
    切分后的集合
    
    Since:
    
    3.0.8
  - split
```
public static <R> List<R> split(CharSequence str,
                                char separator,
                                int limit,
                                boolean ignoreEmpty,
                                Function<String,R> mapping)
```
    切分字符串
    
    Type Parameters:
    
    R - 切分后元素类型
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    limit - 限制分片数，-1不限制
    
    ignoreEmpty - 是否忽略空串
    
    mapping - 切分后的字符串元素的转换方法
    
    Returns:
    
    切分后的集合，元素类型是经过 mapping 转换后的
    
    Since:
    
    5.7.14
  - split
```
public static List<String> split(CharSequence str,
                                 CharSequence separator)
```
    切分字符串，如果分隔符不存在则返回原字符串
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符
    
    Returns:
    
    字符串
    
    Since:
    
    5.7.1
  - split
```
public static List<String> split(CharSequence str,
                                 CharSequence separator,
                                 boolean isTrim,
                                 boolean ignoreEmpty)
```
    切分字符串
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    isTrim - 是否去除切分字符串后每个元素两边的空格
    
    ignoreEmpty - 是否忽略空串
    
    Returns:
    
    切分后的集合
    
    Since:
    
    5.6.7
  - split
```
public static List<String> split(CharSequence str,
                                 CharSequence separator,
                                 int limit,
                                 boolean isTrim,
                                 boolean ignoreEmpty)
```
    切分字符串
    
    Parameters:
    
    str - 被切分的字符串
    
    separator - 分隔符字符
    
    limit - 限制分片数，-1不限制
    
    isTrim - 是否去除切分字符串后每个元素两边的空格
    
    ignoreEmpty - 是否忽略空串
    
    Returns:
    
    切分后的集合
    
    Since:
    
    3.2.0
  - split
```
public static String[] split(CharSequence str,
                             int len)
```
    根据给定长度，将给定字符串截取为多个部分
    
    Parameters:
    
    str - 字符串
    
    len - 每一个小节的长度
    
    Returns:
    
    截取后的字符串数组
    
    See Also:
    
    StrSplitter.splitByLength(CharSequence, int)
  - cut
```
public static String[] cut(CharSequence str,
                           int partLength)
```
    将字符串切分为N等份
    
    Parameters:
    
    str - 字符串
    
    partLength - 每等份的长度
    
    Returns:
    
    切分后的数组
    
    Since:
    
    3.0.6
  - sub
```
public static String sub(CharSequence str,
                         int fromIndexInclude,
                         int toIndexExclude)
```
    改进JDK subString
    index从0开始计算，最后一个字符为-1
    如果from和to位置一样，返回 ""
    如果from或to为负数，则按照length从后向前数位置，如果绝对值大于字符串长度，则from归到0，to归到length
    如果经过修正的index中from大于to，则互换from和to example:
    abcdefgh 2 3 =》 c
    abcdefgh 2 -3 =》 cde
    
    Parameters:
    
    str - String
    
    fromIndexInclude - 开始的index（包括）
    
    toIndexExclude - 结束的index（不包括）
    
    Returns:
    
    字串
  - subByCodePoint
```
public static String subByCodePoint(CharSequence str,
                                    int fromIndex,
                                    int toIndex)
```
    通过CodePoint截取字符串，可以截断Emoji
    
    Parameters:
    
    str - String
    
    fromIndex - 开始的index（包括）
    
    toIndex - 结束的index（不包括）
    
    Returns:
    
    字串
  - subPreGbk
```
public static String subPreGbk(CharSequence str,
                               int len,
                               CharSequence suffix)
```
    截取部分字符串，这里一个汉字的长度认为是2
    
    Parameters:
    
    str - 字符串
    
    len - bytes切割到的位置（包含）
    
    suffix - 切割后加上后缀
    
    Returns:
    
    切割后的字符串
    
    Since:
    
    3.1.1
  - subPreGbk
```
public static String subPreGbk(CharSequence str,
                               int len,
                               boolean halfUp)
```
    截取部分字符串，这里一个汉字的长度认为是2
    可以自定义halfUp，如len为10，如果截取后最后一个字符是半个字符，true表示保留，则长度是11，否则长度9
    
    Parameters:
    
    str - 字符串
    
    len - bytes切割到的位置（包含）
    
    halfUp - 遇到截取一半的GBK字符，是否保留。
    
    Returns:
    
    切割后的字符串
    
    Since:
    
    5.7.17
  - subPre
```
public static String subPre(CharSequence string,
                            int toIndexExclude)
```
    切割指定位置之前部分的字符串
    
    Parameters:
    
    string - 字符串
    
    toIndexExclude - 切割到的位置（不包括）
    
    Returns:
    
    切割后的剩余的前半部分字符串
  - subSuf
```
public static String subSuf(CharSequence string,
                            int fromIndex)
```
    切割指定位置之后部分的字符串
    
    Parameters:
    
    string - 字符串
    
    fromIndex - 切割开始的位置（包括）
    
    Returns:
    
    切割后后剩余的后半部分字符串
  - subSufByLength
```
public static String subSufByLength(CharSequence string,
                                    int length)
```
    切割指定长度的后部分的字符串
```
 CharSequenceUtil.subSufByLength("abcde", 3)      =    "cde"
 CharSequenceUtil.subSufByLength("abcde", 0)      =    ""
 CharSequenceUtil.subSufByLength("abcde", -5)     =    ""
 CharSequenceUtil.subSufByLength("abcde", -1)     =    ""
 CharSequenceUtil.subSufByLength("abcde", 5)       =    "abcde"
 CharSequenceUtil.subSufByLength("abcde", 10)     =    "abcde"
 CharSequenceUtil.subSufByLength(null, 3)               =    null
 
```
    Parameters:
    
    string - 字符串
    
    length - 切割长度
    
    Returns:
    
    切割后后剩余的后半部分字符串
    
    Since:
    
    4.0.1
  - subWithLength
```
public static String subWithLength(String input,
                                   int fromIndex,
                                   int length)
```
    截取字符串,从指定位置开始,截取指定长度的字符串
    如果fromIndex为正数，则向后截取指定length长度，如果为负数，则向前截取length长度。
    
    Parameters:
    
    input - 原始字符串
    
    fromIndex - 开始的index,包括
    
    length - 要截取的长度
    
    Returns:
    
    截取后的字符串
  - subBefore
```
public static String subBefore(CharSequence string,
                               CharSequence separator,
                               boolean isLastSeparator)
```
    截取分隔字符串之前的字符串，不包括分隔字符串
    如果给定的字符串为空串（null或""）或者分隔字符串为null，返回原字符串
    如果分隔字符串为空串""，则返回空串，如果分隔字符串未找到，返回原字符串，举例如下：
```
 CharSequenceUtil.subBefore(null, *, false)      = null
 CharSequenceUtil.subBefore("", *, false)        = ""
 CharSequenceUtil.subBefore("abc", "a", false)   = ""
 CharSequenceUtil.subBefore("abcba", "b", false) = "a"
 CharSequenceUtil.subBefore("abc", "c", false)   = "ab"
 CharSequenceUtil.subBefore("abc", "d", false)   = "abc"
 CharSequenceUtil.subBefore("abc", "", false)    = ""
 CharSequenceUtil.subBefore("abc", null, false)  = "abc"
 
```
    Parameters:
    
    string - 被查找的字符串
    
    separator - 分隔字符串（不包括）
    
    isLastSeparator - 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
    
    Returns:
    
    切割后的字符串
    
    Since:
    
    3.1.1
  - subBefore
```
public static String subBefore(CharSequence string,
                               char separator,
                               boolean isLastSeparator)
```
    截取分隔字符串之前的字符串，不包括分隔字符串
    如果给定的字符串为空串（null或""）或者分隔字符串为null，返回原字符串
    如果分隔字符串未找到，返回原字符串，举例如下：
```
 CharSequenceUtil.subBefore(null, *, false)      = null
 CharSequenceUtil.subBefore("", *, false)        = ""
 CharSequenceUtil.subBefore("abc", 'a', false)   = ""
 CharSequenceUtil.subBefore("abcba", 'b', false) = "a"
 CharSequenceUtil.subBefore("abc", 'c', false)   = "ab"
 CharSequenceUtil.subBefore("abc", 'd', false)   = "abc"
 
```
    Parameters:
    
    string - 被查找的字符串
    
    separator - 分隔字符串（不包括）
    
    isLastSeparator - 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
    
    Returns:
    
    切割后的字符串
    
    Since:
    
    4.1.15
  - subAfter
```
public static String subAfter(CharSequence string,
                              CharSequence separator,
                              boolean isLastSeparator)
```
    截取分隔字符串之后的字符串，不包括分隔字符串
    如果给定的字符串为空串（null或""），返回原字符串
    如果分隔字符串为空串（null或""），则返回空串，如果分隔字符串未找到，返回空串，举例如下：
```
 CharSequenceUtil.subAfter(null, *, false)      = null
 CharSequenceUtil.subAfter("", *, false)        = ""
 CharSequenceUtil.subAfter(*, null, false)      = ""
 CharSequenceUtil.subAfter("abc", "a", false)   = "bc"
 CharSequenceUtil.subAfter("abcba", "b", false) = "cba"
 CharSequenceUtil.subAfter("abc", "c", false)   = ""
 CharSequenceUtil.subAfter("abc", "d", false)   = ""
 CharSequenceUtil.subAfter("abc", "", false)    = "abc"
 
```
    Parameters:
    
    string - 被查找的字符串
    
    separator - 分隔字符串（不包括）
    
    isLastSeparator - 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
    
    Returns:
    
    切割后的字符串
    
    Since:
    
    3.1.1
  - subAfter
```
public static String subAfter(CharSequence string,
                              char separator,
                              boolean isLastSeparator)
```
    截取分隔字符串之后的字符串，不包括分隔字符串
    如果给定的字符串为空串（null或""），返回原字符串
    如果分隔字符串为空串（null或""），则返回空串，如果分隔字符串未找到，返回空串，举例如下：
```
 CharSequenceUtil.subAfter(null, *, false)      = null
 CharSequenceUtil.subAfter("", *, false)        = ""
 CharSequenceUtil.subAfter("abc", 'a', false)   = "bc"
 CharSequenceUtil.subAfter("abcba", 'b', false) = "cba"
 CharSequenceUtil.subAfter("abc", 'c', false)   = ""
 CharSequenceUtil.subAfter("abc", 'd', false)   = ""
 
```
    Parameters:
    
    string - 被查找的字符串
    
    separator - 分隔字符串（不包括）
    
    isLastSeparator - 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
    
    Returns:
    
    切割后的字符串
    
    Since:
    
    4.1.15
  - subBetween
```
public static String subBetween(CharSequence str,
                                CharSequence before,
                                CharSequence after)
```
    截取指定字符串中间部分，不包括标识字符串
    
    栗子：
```
 CharSequenceUtil.subBetween("wx[b]yz", "[", "]") = "b"
 CharSequenceUtil.subBetween(null, *, *)          = null
 CharSequenceUtil.subBetween(*, null, *)          = null
 CharSequenceUtil.subBetween(*, *, null)          = null
 CharSequenceUtil.subBetween("", "", "")          = ""
 CharSequenceUtil.subBetween("", "", "]")         = null
 CharSequenceUtil.subBetween("", "[", "]")        = null
 CharSequenceUtil.subBetween("yabcz", "", "")     = ""
 CharSequenceUtil.subBetween("yabcz", "y", "z")   = "abc"
 CharSequenceUtil.subBetween("yabczyabcz", "y", "z")   = "abc"
 
```
    Parameters:
    
    str - 被切割的字符串
    
    before - 截取开始的字符串标识
    
    after - 截取到的字符串标识
    
    Returns:
    
    截取后的字符串
    
    Since:
    
    3.1.1
  - subBetween
```
public static String subBetween(CharSequence str,
                                CharSequence beforeAndAfter)
```
    截取指定字符串中间部分，不包括标识字符串
    
    栗子：
```
 CharSequenceUtil.subBetween(null, *)            = null
 CharSequenceUtil.subBetween("", "")             = ""
 CharSequenceUtil.subBetween("", "tag")          = null
 CharSequenceUtil.subBetween("tagabctag", null)  = null
 CharSequenceUtil.subBetween("tagabctag", "")    = ""
 CharSequenceUtil.subBetween("tagabctag", "tag") = "abc"
 
```
    Parameters:
    
    str - 被切割的字符串
    
    beforeAndAfter - 截取开始和结束的字符串标识
    
    Returns:
    
    截取后的字符串
    
    Since:
    
    3.1.1
  - subBetweenAll
```
public static String[] subBetweenAll(CharSequence str,
                                     CharSequence prefix,
                                     CharSequence suffix)
```
    截取指定字符串多段中间部分，不包括标识字符串
    
    栗子：
```
 CharSequenceUtil.subBetweenAll("wx[b]y[z]", "[", "]")          = ["b","z"]
 CharSequenceUtil.subBetweenAll(null, *, *)                             = []
 CharSequenceUtil.subBetweenAll(*, null, *)                             = []
 CharSequenceUtil.subBetweenAll(*, *, null)                             = []
 CharSequenceUtil.subBetweenAll("", "", "")                             = []
 CharSequenceUtil.subBetweenAll("", "", "]")                            = []
 CharSequenceUtil.subBetweenAll("", "[", "]")                           = []
 CharSequenceUtil.subBetweenAll("yabcz", "", "")                        = []
 CharSequenceUtil.subBetweenAll("yabcz", "y", "z")                      = ["abc"]
 CharSequenceUtil.subBetweenAll("yabczyabcz", "y", "z")                 = ["abc","abc"]
 CharSequenceUtil.subBetweenAll("[yabc[zy]abcz]", "[", "]");   = ["zy"]           重叠时只截取内部，
 
```
    Parameters:
    
    str - 被切割的字符串
    
    prefix - 截取开始的字符串标识
    
    suffix - 截取到的字符串标识
    
    Returns:
    
    截取后的字符串
    
    Since:
    
    5.2.5
  - subBetweenAll
```
public static String[] subBetweenAll(CharSequence str,
                                     CharSequence prefixAndSuffix)
```
    截取指定字符串多段中间部分，不包括标识字符串
    
    栗子：
```
 CharSequenceUtil.subBetweenAll(null, *)                                = []
 CharSequenceUtil.subBetweenAll(*, null)                                = []
 CharSequenceUtil.subBetweenAll(*, *)                           = []
 CharSequenceUtil.subBetweenAll("", "")                                 = []
 CharSequenceUtil.subBetweenAll("", "#")                                = []
 CharSequenceUtil.subBetweenAll("gotanks", "")                  = []
 CharSequenceUtil.subBetweenAll("#gotanks#", "#")               = ["gotanks"]
 CharSequenceUtil.subBetweenAll("#hello# #world#!", "#")   = ["hello", "world"]
 CharSequenceUtil.subBetweenAll("#hello# world#!", "#");   = ["hello"]
 
```
    Parameters:
    
    str - 被切割的字符串
    
    prefixAndSuffix - 截取开始和结束的字符串标识
    
    Returns:
    
    截取后的字符串
    
    Since:
    
    5.5.0
  - repeat
```
public static String repeat(char c,
                            int count)
```
    重复某个字符
```
 CharSequenceUtil.repeat('e', 0)  = ""
 CharSequenceUtil.repeat('e', 3)  = "eee"
 CharSequenceUtil.repeat('e', -2) = ""
 
```
    Parameters:
    
    c - 被重复的字符
    
    count - 重复的数目，如果小于等于0则返回""
    
    Returns:
    
    重复字符字符串
  - repeat
```
public static String repeat(CharSequence str,
                            int count)
```
    重复某个字符串
    
    Parameters:
    
    str - 被重复的字符
    
    count - 重复的数目
    
    Returns:
    
    重复字符字符串
  - repeatByLength
```
public static String repeatByLength(CharSequence str,
                                    int padLen)
```
    重复某个字符串到指定长度
    
    Parameters:
    
    str - 被重复的字符
    
    padLen - 指定长度
    
    Returns:
    
    重复字符字符串
    
    Since:
    
    4.3.2
  - repeatAndJoin
```
public static String repeatAndJoin(CharSequence str,
                                   int count,
                                   CharSequence delimiter)
```
    重复某个字符串并通过分界符连接
```
 CharSequenceUtil.repeatAndJoin("?", 5, ",")   = "?,?,?,?,?"
 CharSequenceUtil.repeatAndJoin("?", 0, ",")   = ""
 CharSequenceUtil.repeatAndJoin("?", 5, null) = "?????"
 
```
    Parameters:
    
    str - 被重复的字符串
    
    count - 数量
    
    delimiter - 分界符
    
    Returns:
    
    连接后的字符串
    
    Since:
    
    4.0.1
  - 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)
```
    比较两个字符串是否相等，规则如下
    - str1和str2都为null
    - 忽略大小写使用String.equalsIgnoreCase(String)判断相等
    - 不忽略大小写使用String.contentEquals(CharSequence)判断相等
    Parameters:
    
    str1 - 要比较的字符串1
    
    str2 - 要比较的字符串2
    
    ignoreCase - 是否忽略大小写
    
    Returns:
    
    如果两个字符串相同，或者都是null，则返回true
    
    Since:
    
    3.2.0
  - equalsAnyIgnoreCase
```
public static boolean equalsAnyIgnoreCase(CharSequence str1,
                                          CharSequence... strs)
```
    给定字符串是否与提供的中任一字符串相同（忽略大小写），相同则返回true，没有相同的返回false
    如果参与比对的字符串列表为空，返回false
    
    Parameters:
    
    str1 - 给定需要检查的字符串
    
    strs - 需要参与比对的字符串列表
    
    Returns:
    
    是否相同
    
    Since:
    
    4.3.2
  - equalsAny
```
public static boolean equalsAny(CharSequence str1,
                                CharSequence... strs)
```
    给定字符串是否与提供的中任一字符串相同，相同则返回true，没有相同的返回false
    如果参与比对的字符串列表为空，返回false
    
    Parameters:
    
    str1 - 给定需要检查的字符串
    
    strs - 需要参与比对的字符串列表
    
    Returns:
    
    是否相同
    
    Since:
    
    4.3.2
  - equalsAny
```
public static boolean equalsAny(CharSequence str1,
                                boolean ignoreCase,
                                CharSequence... strs)
```
    给定字符串是否与提供的中任一字符串相同，相同则返回true，没有相同的返回false
    如果参与比对的字符串列表为空，返回false
    
    Parameters:
    
    str1 - 给定需要检查的字符串
    
    ignoreCase - 是否忽略大小写
    
    strs - 需要参与比对的字符串列表
    
    Returns:
    
    是否相同
    
    Since:
    
    4.3.2
  - equalsCharAt
```
public static boolean equalsCharAt(CharSequence str,
                                   int position,
                                   char c)
```
    字符串指定位置的字符是否与给定字符相同
    如果字符串为null，返回false
    如果给定的位置大于字符串长度，返回false
    如果给定的位置小于0，返回false
    
    Parameters:
    
    str - 字符串
    
    position - 位置
    
    c - 需要对比的字符
    
    Returns:
    
    字符串指定位置的字符是否与给定字符相同
    
    Since:
    
    3.3.1
  - isSubEquals
```
public static boolean isSubEquals(CharSequence str1,
                                  int start1,
                                  CharSequence str2,
                                  boolean ignoreCase)
```
    截取第一个字串的部分字符，与第二个字符串比较（长度一致），判断截取的子串是否相同
    任意一个字符串为null返回false
    
    Parameters:
    
    str1 - 第一个字符串
    
    start1 - 第一个字符串开始的位置
    
    str2 - 第二个字符串
    
    ignoreCase - 是否忽略大小写
    
    Returns:
    
    子串是否相同
    
    Since:
    
    3.2.1
  - 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
  - format
```
public static String format(CharSequence template,
                            Object... params)
```
    格式化文本, {} 表示占位符
    此方法只是简单将占位符 {} 按照顺序替换为参数
    如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可
    例：
    通常使用：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:
    
    template - 文本模板，被替换的部分用 {} 表示，如果模板为null，返回"null"
    
    params - 参数值
    
    Returns:
    
    格式化后的文本，如果模板为null，返回"null"
  - indexedFormat
```
public static String indexedFormat(CharSequence pattern,
                                   Object... arguments)
```
    有序的格式化文本，使用{number}做为占位符
    通常使用：format("this is {0} for {1}", "a", "b") =》 this is a for b
    
    Parameters:
    
    pattern - 文本格式
    
    arguments - 参数
    
    Returns:
    
    格式化后的文本
  - utf8Bytes
```
public static byte[] utf8Bytes(CharSequence str)
```
    编码字符串，编码为UTF-8
    
    Parameters:
    
    str - 字符串
    
    Returns:
    
    编码后的字节码
  - 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:
    
    编码后的字节码
  - byteBuffer
```
public static ByteBuffer byteBuffer(CharSequence str,
                                    String charset)
```
    字符串转换为byteBuffer
    
    Parameters:
    
    str - 字符串
    
    charset - 编码
    
    Returns:
    
    byteBuffer
  - 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:
    
    包装后的字符串
  - wrapAllWithPair
```
public static String[] wrapAllWithPair(CharSequence prefixAndSuffix,
                                       CharSequence... strs)
```
    使用单个字符包装多个字符串
    
    Parameters:
    
    prefixAndSuffix - 前缀和后缀
    
    strs - 多个字符串
    
    Returns:
    
    包装的字符串数组
    
    Since:
    
    5.4.1
  - wrapAll
```
public static String[] wrapAll(CharSequence prefix,
                               CharSequence suffix,
                               CharSequence... strs)
```
    包装多个字符串
    
    Parameters:
    
    prefix - 前缀
    
    suffix - 后缀
    
    strs - 多个字符串
    
    Returns:
    
    包装的字符串数组
    
    Since:
    
    4.0.7
  - wrapIfMissing
```
public static String wrapIfMissing(CharSequence str,
                                   CharSequence prefix,
                                   CharSequence suffix)
```
    包装指定字符串，如果前缀或后缀已经包含对应的字符串，则不再包装
    
    Parameters:
    
    str - 被包装的字符串
    
    prefix - 前缀
    
    suffix - 后缀
    
    Returns:
    
    包装后的字符串
  - wrapAllWithPairIfMissing
```
public static String[] wrapAllWithPairIfMissing(CharSequence prefixAndSuffix,
                                                CharSequence... strs)
```
    使用成对的字符包装多个字符串，如果已经包装，则不再包装
    
    Parameters:
    
    prefixAndSuffix - 前缀和后缀
    
    strs - 多个字符串
    
    Returns:
    
    包装的字符串数组
    
    Since:
    
    5.4.1
  - wrapAllIfMissing
```
public static String[] wrapAllIfMissing(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:
    
    是否被包装
  - padPre
```
public static String padPre(CharSequence str,
                            int length,
                            CharSequence padStr)
```
    补充字符串以满足指定长度，如果提供的字符串大于指定长度，截断之同：leftPad (org.apache.commons.lang3.leftPad)
```
 CharSequenceUtil.padPre(null, *, *);//null
 CharSequenceUtil.padPre("1", 3, "ABC");//"AB1"
 CharSequenceUtil.padPre("123", 2, "ABC");//"12"
 CharSequenceUtil.padPre("1039", -1, "0");//"103"
 
```
    Parameters:
    
    str - 字符串
    
    length - 长度
    
    padStr - 补充的字符
    
    Returns:
    
    补充后的字符串
  - padPre
```
public static String padPre(CharSequence str,
                            int length,
                            char padChar)
```
    补充字符串以满足最小长度，如果提供的字符串大于指定长度，截断之同：leftPad (org.apache.commons.lang3.leftPad)
```
 CharSequenceUtil.padPre(null, *, *);//null
 CharSequenceUtil.padPre("1", 3, '0');//"001"
 CharSequenceUtil.padPre("123", 2, '0');//"12"
 
```
    Parameters:
    
    str - 字符串
    
    length - 长度
    
    padChar - 补充的字符
    
    Returns:
    
    补充后的字符串
  - padAfter
```
public static String padAfter(CharSequence str,
                              int length,
                              char padChar)
```
    补充字符串以满足最小长度，如果提供的字符串大于指定长度，截断之
```
 CharSequenceUtil.padAfter(null, *, *);//null
 CharSequenceUtil.padAfter("1", 3, '0');//"100"
 CharSequenceUtil.padAfter("123", 2, '0');//"23"
 CharSequenceUtil.padAfter("123", -1, '0')//"" 空串
 
```
    Parameters:
    
    str - 字符串，如果为null，直接返回null
    
    length - 长度
    
    padChar - 补充的字符
    
    Returns:
    
    补充后的字符串
  - padAfter
```
public static String padAfter(CharSequence str,
                              int length,
                              CharSequence padStr)
```
    补充字符串以满足最小长度
```
 CharSequenceUtil.padAfter(null, *, *);//null
 CharSequenceUtil.padAfter("1", 3, "ABC");//"1AB"
 CharSequenceUtil.padAfter("123", 2, "ABC");//"23"
 
```
    Parameters:
    
    str - 字符串，如果为null，直接返回null
    
    length - 长度
    
    padStr - 补充的字符
    
    Returns:
    
    补充后的字符串
    
    Since:
    
    4.3.2
  - center
```
public static String center(CharSequence str,
                            int size)
```
    居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串
```
 CharSequenceUtil.center(null, *)   = null
 CharSequenceUtil.center("", 4)     = "    "
 CharSequenceUtil.center("ab", -1)  = "ab"
 CharSequenceUtil.center("ab", 4)   = " ab "
 CharSequenceUtil.center("abcd", 2) = "abcd"
 CharSequenceUtil.center("a", 4)    = " a  "
 
```
    Parameters:
    
    str - 字符串
    
    size - 指定长度
    
    Returns:
    
    补充后的字符串
    
    Since:
    
    4.3.2
  - center
```
public static String center(CharSequence str,
                            int size,
                            char padChar)
```
    居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串
```
 CharSequenceUtil.center(null, *, *)     = null
 CharSequenceUtil.center("", 4, ' ')     = "    "
 CharSequenceUtil.center("ab", -1, ' ')  = "ab"
 CharSequenceUtil.center("ab", 4, ' ')   = " ab "
 CharSequenceUtil.center("abcd", 2, ' ') = "abcd"
 CharSequenceUtil.center("a", 4, ' ')    = " a  "
 CharSequenceUtil.center("a", 4, 'y')   = "yayy"
 CharSequenceUtil.center("abc", 7, ' ')   = "  abc  "
 
```
    Parameters:
    
    str - 字符串
    
    size - 指定长度
    
    padChar - 两边补充的字符
    
    Returns:
    
    补充后的字符串
    
    Since:
    
    4.3.2
  - center
```
public static String center(CharSequence str,
                            int size,
                            CharSequence padStr)
```
    居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串
```
 CharSequenceUtil.center(null, *, *)     = null
 CharSequenceUtil.center("", 4, " ")     = "    "
 CharSequenceUtil.center("ab", -1, " ")  = "ab"
 CharSequenceUtil.center("ab", 4, " ")   = " ab "
 CharSequenceUtil.center("abcd", 2, " ") = "abcd"
 CharSequenceUtil.center("a", 4, " ")    = " a  "
 CharSequenceUtil.center("a", 4, "yz")   = "yayz"
 CharSequenceUtil.center("abc", 7, null) = "  abc  "
 CharSequenceUtil.center("abc", 7, "")   = "  abc  "
 
```
    Parameters:
    
    str - 字符串
    
    size - 指定长度
    
    padStr - 两边补充的字符串
    
    Returns:
    
    补充后的字符串
  - str
```
public static String str(CharSequence cs)
```
    CharSequence 转为字符串，null安全
    
    Parameters:
    
    cs - CharSequence
    
    Returns:
    
    字符串
  - count
```
public static int count(CharSequence content,
                        CharSequence strForSearch)
```
    统计指定内容中包含指定字符串的数量
    参数为 null 或者 "" 返回 0.
```
 CharSequenceUtil.count(null, *)       = 0
 CharSequenceUtil.count("", *)         = 0
 CharSequenceUtil.count("abba", null)  = 0
 CharSequenceUtil.count("abba", "")    = 0
 CharSequenceUtil.count("abba", "a")   = 2
 CharSequenceUtil.count("abba", "ab")  = 1
 CharSequenceUtil.count("abba", "xxx") = 0
 
```
    Parameters:
    
    content - 被查找的字符串
    
    strForSearch - 需要查找的字符串
    
    Returns:
    
    查找到的个数
  - count
```
public static int count(CharSequence content,
                        char charForSearch)
```
    统计指定内容中包含指定字符的数量
    
    Parameters:
    
    content - 内容
    
    charForSearch - 被统计的字符
    
    Returns:
    
    包含数量
  - compare
```
public static int compare(CharSequence str1,
                          CharSequence str2,
                          boolean nullIsLess)
```
    比较两个字符串，用于排序
```
 CharSequenceUtil.compare(null, null, *)     = 0
 CharSequenceUtil.compare(null , "a", true)  < 0
 CharSequenceUtil.compare(null , "a", false) > 0
 CharSequenceUtil.compare("a", null, true)   > 0
 CharSequenceUtil.compare("a", null, false)  < 0
 CharSequenceUtil.compare("abc", "abc", *)   = 0
 CharSequenceUtil.compare("a", "b", *)       < 0
 CharSequenceUtil.compare("b", "a", *)       > 0
 CharSequenceUtil.compare("a", "B", *)       > 0
 CharSequenceUtil.compare("ab", "abc", *)    < 0
 
```
    Parameters:
    
    str1 - 字符串1
    
    str2 - 字符串2
    
    nullIsLess - null 值是否排在前（null是否小于非空值）
    
    Returns:
    
    排序值。负数：str1 < str2，正数：str1 > str2, 0：str1 == str2
  - compareIgnoreCase
```
public static int compareIgnoreCase(CharSequence str1,
                                    CharSequence str2,
                                    boolean nullIsLess)
```
    比较两个字符串，用于排序，大小写不敏感
```
 CharSequenceUtil.compareIgnoreCase(null, null, *)     = 0
 CharSequenceUtil.compareIgnoreCase(null , "a", true)  < 0
 CharSequenceUtil.compareIgnoreCase(null , "a", false) > 0
 CharSequenceUtil.compareIgnoreCase("a", null, true)   > 0
 CharSequenceUtil.compareIgnoreCase("a", null, false)  < 0
 CharSequenceUtil.compareIgnoreCase("abc", "abc", *)   = 0
 CharSequenceUtil.compareIgnoreCase("abc", "ABC", *)   = 0
 CharSequenceUtil.compareIgnoreCase("a", "b", *)       < 0
 CharSequenceUtil.compareIgnoreCase("b", "a", *)       > 0
 CharSequenceUtil.compareIgnoreCase("a", "B", *)       < 0
 CharSequenceUtil.compareIgnoreCase("A", "b", *)       < 0
 CharSequenceUtil.compareIgnoreCase("ab", "abc", *)    < 0
 
```
    Parameters:
    
    str1 - 字符串1
    
    str2 - 字符串2
    
    nullIsLess - null 值是否排在前（null是否小于非空值）
    
    Returns:
    
    排序值。负数：str1 < str2，正数：str1 > str2, 0：str1 == str2
  - compareVersion
```
public static int compareVersion(CharSequence version1,
                                 CharSequence version2)
```
    比较两个版本
    null版本排在最小：即：
```
 CharSequenceUtil.compareVersion(null, "v1") < 0
 CharSequenceUtil.compareVersion("v1", "v1")  = 0
 CharSequenceUtil.compareVersion(null, null)   = 0
 CharSequenceUtil.compareVersion("v1", null) > 0
 CharSequenceUtil.compareVersion("1.0.0", "1.0.2") < 0
 CharSequenceUtil.compareVersion("1.0.2", "1.0.2a") < 0
 CharSequenceUtil.compareVersion("1.13.0", "1.12.1c") > 0
 CharSequenceUtil.compareVersion("V0.0.20170102", "V0.0.20170101") > 0
 
```
    Parameters:
    
    version1 - 版本1
    
    version2 - 版本2
    
    Returns:
    
    排序值。负数：version1 < version2，正数：version1 > version2, 0：version1 == version2
    
    Since:
    
    4.0.2
  - appendIfMissing
```
public static String appendIfMissing(CharSequence str,
                                     CharSequence suffix,
                                     CharSequence... suffixes)
```
    如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串
    不忽略大小写
    
    Parameters:
    
    str - 被检查的字符串
    
    suffix - 需要添加到结尾的字符串
    
    suffixes - 需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加
    
    Returns:
    
    如果已经结尾，返回原字符串，否则返回添加结尾的字符串
    
    Since:
    
    3.0.7
  - appendIfMissingIgnoreCase
```
public static String appendIfMissingIgnoreCase(CharSequence str,
                                               CharSequence suffix,
                                               CharSequence... suffixes)
```
    如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串
    忽略大小写
    
    Parameters:
    
    str - 被检查的字符串
    
    suffix - 需要添加到结尾的字符串
    
    suffixes - 需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加
    
    Returns:
    
    如果已经结尾，返回原字符串，否则返回添加结尾的字符串
    
    Since:
    
    3.0.7
  - appendIfMissing
```
public static String appendIfMissing(CharSequence str,
                                     CharSequence suffix,
                                     boolean ignoreCase,
                                     CharSequence... testSuffixes)
```
    如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串
    
    Parameters:
    
    str - 被检查的字符串
    
    suffix - 需要添加到结尾的字符串，不参与检查匹配
    
    ignoreCase - 检查结尾时是否忽略大小写
    
    testSuffixes - 需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加
    
    Returns:
    
    如果已经结尾，返回原字符串，否则返回添加结尾的字符串
    
    Since:
    
    3.0.7
  - prependIfMissing
```
public static String prependIfMissing(CharSequence str,
                                      CharSequence prefix,
                                      CharSequence... prefixes)
```
    如果给定字符串不是以给定的一个或多个字符串为开头，则在首部添加起始字符串
    不忽略大小写
    
    Parameters:
    
    str - 被检查的字符串
    
    prefix - 需要添加到首部的字符串
    
    prefixes - 需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加
    
    Returns:
    
    如果已经结尾，返回原字符串，否则返回添加结尾的字符串
    
    Since:
    
    3.0.7
  - prependIfMissingIgnoreCase
```
public static String prependIfMissingIgnoreCase(CharSequence str,
                                                CharSequence prefix,
                                                CharSequence... prefixes)
```
    如果给定字符串不是以给定的一个或多个字符串为开头，则在首部添加起始字符串
    忽略大小写
    
    Parameters:
    
    str - 被检查的字符串
    
    prefix - 需要添加到首部的字符串
    
    prefixes - 需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加
    
    Returns:
    
    如果已经结尾，返回原字符串，否则返回添加结尾的字符串
    
    Since:
    
    3.0.7
  - prependIfMissing
```
public static String prependIfMissing(CharSequence str,
                                      CharSequence prefix,
                                      boolean ignoreCase,
                                      CharSequence... prefixes)
```
    如果给定字符串不是以给定的一个或多个字符串为开头，则在首部添加起始字符串
    
    Parameters:
    
    str - 被检查的字符串
    
    prefix - 需要添加到首部的字符串
    
    ignoreCase - 检查结尾时是否忽略大小写
    
    prefixes - 需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加
    
    Returns:
    
    如果已经结尾，返回原字符串，否则返回添加结尾的字符串
    
    Since:
    
    3.0.7
  - 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
```
@Deprecated
public static String replace(CharSequence str,
                                          int startInclude,
                                          int endExclude,
                                          char replacedChar)
```
    Deprecated. 歧义，请使用replaceByCodePoint(CharSequence, int, int, char)
    
    替换指定字符串的指定区间内字符为固定字符
    此方法使用CharSequence.codePoints()完成拆分替换
    
    Parameters:
    
    str - 字符串
    
    startInclude - 开始位置（包含）
    
    endExclude - 结束位置（不包含）
    
    replacedChar - 被替换的字符
    
    Returns:
    
    替换后的字符串
    
    Since:
    
    3.2.1
  - replaceByCodePoint
```
public static String replaceByCodePoint(CharSequence str,
                                        int startInclude,
                                        int endExclude,
                                        char replacedChar)
```
    替换指定字符串的指定区间内字符为固定字符
    此方法使用CharSequence.codePoints()完成拆分替换
    
    Parameters:
    
    str - 字符串
    
    startInclude - 开始位置（包含）
    
    endExclude - 结束位置（不包含）
    
    replacedChar - 被替换的字符
    
    Returns:
    
    替换后的字符串
    
    Since:
    
    5.8.27
  - replace
```
@Deprecated
public static String replace(CharSequence str,
                                          int startInclude,
                                          int endExclude,
                                          CharSequence replacedStr)
```
    Deprecated. 歧义，请使用replaceByCodePoint(CharSequence, int, int, CharSequence)
    
    替换指定字符串的指定区间内字符为指定字符串，字符串只重复一次
    此方法使用CharSequence.codePoints()完成拆分替换
    
    Parameters:
    
    str - 字符串
    
    startInclude - 开始位置（包含）
    
    endExclude - 结束位置（不包含）
    
    replacedStr - 被替换的字符串
    
    Returns:
    
    替换后的字符串
    
    Since:
    
    3.2.1
  - replaceByCodePoint
```
public static String replaceByCodePoint(CharSequence str,
                                        int startInclude,
                                        int endExclude,
                                        CharSequence replacedStr)
```
    替换指定字符串的指定区间内字符为指定字符串，字符串只重复一次
    此方法使用CharSequence.codePoints()完成拆分替换
    
    Parameters:
    
    str - 字符串
    
    startInclude - 开始位置（包含）
    
    endExclude - 结束位置（不包含）
    
    replacedStr - 被替换的字符串
    
    Returns:
    
    替换后的字符串
    
    Since:
    
    5.8.27
  - replace
```
public static String replace(CharSequence str,
                             Pattern pattern,
                             Func1<Matcher,String> replaceFun)
```
    替换所有正则匹配的文本，并使用自定义函数决定如何替换
    replaceFun可以通过Matcher提取出匹配到的内容的不同部分，然后经过重新处理、组装变成新的内容放回原位。
```
     replace(this.content, "(\\d+)", parameters -> "-" + parameters.group(1) + "-")
     // 结果为："ZZZaaabbbccc中文-1234-"
 
```
    Parameters:
    
    str - 要替换的字符串
    
    pattern - 用于匹配的正则式
    
    replaceFun - 决定如何替换的函数
    
    Returns:
    
    替换后的字符串
    
    Since:
    
    4.2.2
    
    See Also:
    
    ReUtil.replaceAll(CharSequence, java.util.regex.Pattern, Func1)
  - replace
```
public static String replace(CharSequence str,
                             String regex,
                             Func1<Matcher,String> replaceFun)
```
    替换所有正则匹配的文本，并使用自定义函数决定如何替换
    
    Parameters:
    
    str - 要替换的字符串
    
    regex - 用于匹配的正则式
    
    replaceFun - 决定如何替换的函数
    
    Returns:
    
    替换后的字符串
    
    Since:
    
    4.2.2
    
    See Also:
    
    ReUtil.replaceAll(CharSequence, String, Func1)
  - replaceLast
```
public static String replaceLast(CharSequence str,
                                 CharSequence searchStr,
                                 CharSequence replacedStr)
```
    替换字符串中最后一个指定字符串
    
    Parameters:
    
    str - 字符串
    
    searchStr - 被查找的字符串
    
    replacedStr - 被替换的字符串
    
    Returns:
    
    替换后的字符串
  - replaceLast
```
public static String replaceLast(CharSequence str,
                                 CharSequence searchStr,
                                 CharSequence replacedStr,
                                 boolean ignoreCase)
```
    替换字符串中最后一个指定字符串
    
    Parameters:
    
    str - 字符串
    
    searchStr - 被查找的字符串
    
    replacedStr - 被替换的字符串
    
    ignoreCase - 是否忽略大小写
    
    Returns:
    
    替换后的字符串
  - replaceFirst
```
public static String replaceFirst(CharSequence str,
                                  CharSequence searchStr,
                                  CharSequence replacedStr)
```
    替换字符串中第一个指定字符串
    
    Parameters:
    
    str - 字符串
    
    searchStr - 被查找的字符串
    
    replacedStr - 被替换的字符串
    
    Returns:
    
    替换后的字符串
  - replaceFirst
```
public static String replaceFirst(CharSequence str,
                                  CharSequence searchStr,
                                  CharSequence replacedStr,
                                  boolean ignoreCase)
```
    替换字符串中第一个指定字符串
    
    Parameters:
    
    str - 字符串
    
    searchStr - 被查找的字符串
    
    replacedStr - 被替换的字符串
    
    ignoreCase - 是否忽略大小写
    
    Returns:
    
    替换后的字符串
  - hide
```
public static String hide(CharSequence str,
                          int startInclude,
                          int endExclude)
```
    替换指定字符串的指定区间内字符为"*" 俗称：脱敏功能，后面其他功能，可以见：DesensitizedUtil(脱敏工具类)
```
 CharSequenceUtil.hide(null,*,*)=null
 CharSequenceUtil.hide("",0,*)=""
 CharSequenceUtil.hide("jackduan@163.com",-1,4)   ****duan@163.com
 CharSequenceUtil.hide("jackduan@163.com",2,3)    ja*kduan@163.com
 CharSequenceUtil.hide("jackduan@163.com",3,2)    jackduan@163.com
 CharSequenceUtil.hide("jackduan@163.com",16,16)  jackduan@163.com
 CharSequenceUtil.hide("jackduan@163.com",16,17)  jackduan@163.com
 
```
    Parameters:
    
    str - 字符串
    
    startInclude - 开始位置（包含）
    
    endExclude - 结束位置（不包含）
    
    Returns:
    
    替换后的字符串
    
    Since:
    
    4.1.14
  - desensitized
```
public static String desensitized(CharSequence str,
                                  DesensitizedUtil.DesensitizedType desensitizedType)
```
    脱敏，使用默认的脱敏策略
```
 CharSequenceUtil.desensitized("100", DesensitizedUtil.DesensitizedType.USER_ID)) =  "0"
 CharSequenceUtil.desensitized("段正淳", DesensitizedUtil.DesensitizedType.CHINESE_NAME)) = "段**"
 CharSequenceUtil.desensitized("51343620000320711X", DesensitizedUtil.DesensitizedType.ID_CARD)) = "5***************1X"
 CharSequenceUtil.desensitized("09157518479", DesensitizedUtil.DesensitizedType.FIXED_PHONE)) = "0915*****79"
 CharSequenceUtil.desensitized("18049531999", DesensitizedUtil.DesensitizedType.MOBILE_PHONE)) = "180****1999"
 CharSequenceUtil.desensitized("北京市海淀区马连洼街道289号", DesensitizedUtil.DesensitizedType.ADDRESS)) = "北京市海淀区马********"
 CharSequenceUtil.desensitized("duandazhi-jack@gmail.com.cn", DesensitizedUtil.DesensitizedType.EMAIL)) = "d*************@gmail.com.cn"
 CharSequenceUtil.desensitized("1234567890", DesensitizedUtil.DesensitizedType.PASSWORD)) = "**********"
 CharSequenceUtil.desensitized("苏D40000", DesensitizedUtil.DesensitizedType.CAR_LICENSE)) = "苏D4***0"
 CharSequenceUtil.desensitized("11011111222233333256", DesensitizedType.BANK_CARD)) = "1101 **** **** **** 3256"
 
```
    Parameters:
    
    str - 字符串
    
    desensitizedType - 脱敏类型;可以脱敏：用户id、中文名、身份证号、座机号、手机号、地址、电子邮件、密码
    
    Returns:
    
    脱敏之后的字符串
    
    Since:
    
    5.6.2
    
    See Also:
    
    如果需要自定义，脱敏规则，请使用该工具类；
  - 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
  - length
```
public static int length(CharSequence cs)
```
    获取字符串的长度，如果为null返回0
    
    Parameters:
    
    cs - a 字符串
    
    Returns:
    
    字符串的长度，如果为null返回0
    
    Since:
    
    4.3.2
  - byteLength
```
public static int byteLength(CharSequence cs,
                             Charset charset)
```
    给定字符串转为bytes后的byte数（byte长度）
    
    Parameters:
    
    cs - 字符串
    
    charset - 编码
    
    Returns:
    
    byte长度
    
    Since:
    
    4.5.2
  - totalLength
```
public static int totalLength(CharSequence... strs)
```
    给定字符串数组的总长度
    null字符长度定义为0
    
    Parameters:
    
    strs - 字符串数组
    
    Returns:
    
    总长度
    
    Since:
    
    4.0.1
  - maxLength
```
public static String maxLength(CharSequence string,
                               int length)
```
    限制字符串长度，如果超过指定长度，截取指定长度并在末尾加"..."
    
    Parameters:
    
    string - 字符串
    
    length - 最大长度
    
    Returns:
    
    切割后的剩余的前半部分字符串+"..."
    
    Since:
    
    4.0.10
  - firstNonNull
```
public static <T extends CharSequence> T firstNonNull(T... strs)
```
    返回第一个非null 元素
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    strs - 多个元素
    
    Returns:
    
    第一个非空元素，如果给定的数组为空或者都为空，返回null
    
    Since:
    
    5.4.1
  - firstNonEmpty
```
public static <T extends CharSequence> T firstNonEmpty(T... strs)
```
    返回第一个非empty 元素
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    strs - 多个元素
    
    Returns:
    
    第一个非空元素，如果给定的数组为空或者都为空，返回null
    
    Since:
    
    5.4.1
    
    See Also:
    
    isNotEmpty(CharSequence)
  - firstNonBlank
```
public static <T extends CharSequence> T firstNonBlank(T... strs)
```
    返回第一个非blank 元素
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    strs - 多个元素
    
    Returns:
    
    第一个非空元素，如果给定的数组为空或者都为空，返回null
    
    Since:
    
    5.4.1
    
    See Also:
    
    isNotBlank(CharSequence)
  - 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:
    
    字符串
  - filter
```
public static String filter(CharSequence str,
                            Filter<Character> filter)
```
    过滤字符串
    
    Parameters:
    
    str - 字符串
    
    filter - 过滤器，Filter.accept(Object)返回为true的保留字符
    
    Returns:
    
    过滤后的字符串
    
    Since:
    
    5.4.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
  - swapCase
```
public static String swapCase(String str)
```
    切换给定字符串中的大小写。大写转小写，小写转大写。
```
 CharSequenceUtil.swapCase(null)                 = null
 CharSequenceUtil.swapCase("")                   = ""
 CharSequenceUtil.swapCase("The dog has a BONE") = "tHE DOG HAS A bone"
 
```
    Parameters:
    
    str - 字符串
    
    Returns:
    
    交换后的字符串
    
    Since:
    
    4.3.2
  - toUnderlineCase
```
public static String toUnderlineCase(CharSequence str)
```
    将驼峰式命名的字符串转换为下划线方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。
    例如：
```
 HelloWorld=》hello_world
 Hello_World=》hello_world
 HelloWorld_test=》hello_world_test
 
```
    Parameters:
    
    str - 转换前的驼峰式命名的字符串，也可以为下划线形式
    
    Returns:
    
    转换后下划线方式命名的字符串
    
    See Also:
    
    NamingCase.toUnderlineCase(CharSequence)
  - toSymbolCase
```
public static String toSymbolCase(CharSequence str,
                                  char symbol)
```
    将驼峰式命名的字符串转换为使用符号连接方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。
    
    Parameters:
    
    str - 转换前的驼峰式命名的字符串，也可以为符号连接形式
    
    symbol - 连接符
    
    Returns:
    
    转换后符号连接方式命名的字符串
    
    Since:
    
    4.0.10
    
    See Also:
    
    NamingCase.toSymbolCase(CharSequence, char)
  - toCamelCase
```
public static String toCamelCase(CharSequence name)
```
    将下划线方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。
    例如：hello_world=》helloWorld
    
    Parameters:
    
    name - 转换前的下划线大写方式命名的字符串
    
    Returns:
    
    转换后的驼峰式命名的字符串
    
    See Also:
    
    NamingCase.toCamelCase(CharSequence)
  - toCamelCase
```
public static String toCamelCase(CharSequence name,
                                 char symbol)
```
    将连接符方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。
    例如：hello_world=》helloWorld; hello-world=》helloWorld
    
    Parameters:
    
    name - 转换前的下划线大写方式命名的字符串
    
    symbol - 连接符
    
    Returns:
    
    转换后的驼峰式命名的字符串
    
    See Also:
    
    NamingCase.toCamelCase(CharSequence, char)
  - 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:
    
    是否包围，空串不包围
  - builder
```
public static StringBuilder builder(CharSequence... strs)
```
    创建StringBuilder对象
    
    Parameters:
    
    strs - 初始字符串列表
    
    Returns:
    
    StringBuilder对象
  - strBuilder
```
public static StrBuilder strBuilder(CharSequence... strs)
```
    创建StrBuilder对象
    
    Parameters:
    
    strs - 初始字符串列表
    
    Returns:
    
    StrBuilder对象
  - getGeneralField
```
public static String getGeneralField(CharSequence getOrSetMethodName)
```
    获得set或get或is方法对应的标准属性名
    例如：setName 返回 name
```
 getName =》name
 setName =》name
 isName  =》name
 
```
    Parameters:
    
    getOrSetMethodName - Get或Set方法名
    
    Returns:
    
    如果是set或get方法名，返回field，否则null
  - genSetter
```
public static String genSetter(CharSequence fieldName)
```
    生成set方法名
    例如：name 返回 setName
    
    Parameters:
    
    fieldName - 属性名
    
    Returns:
    
    setXxx
  - genGetter
```
public static String genGetter(CharSequence fieldName)
```
    生成get方法名
    
    Parameters:
    
    fieldName - 属性名
    
    Returns:
    
    getXxx
  - concat
```
public static String concat(boolean isNullToEmpty,
                            CharSequence... strs)
```
    连接多个字符串为一个
    
    Parameters:
    
    isNullToEmpty - 是否null转为""
    
    strs - 字符串数组
    
    Returns:
    
    连接后的字符串
    
    Since:
    
    4.1.0
  - brief
```
public static String brief(CharSequence str,
                           int maxLength)
```
    将给定字符串，变成 "xxx...xxx" 形式的字符串
    - abcdefgh 9 -》 abcdefgh
    - abcdefgh 8 -》 abcdefgh
    - abcdefgh 7 -》 ab...gh
    - abcdefgh 6 -》 ab...h
    - abcdefgh 5 -》 a...h
    - abcdefgh 4 -》 a..h
    - abcdefgh 3 -》 a.h
    - abcdefgh 2 -》 a.
    - abcdefgh 1 -》 a
    - abcdefgh 0 -》 abcdefgh
    - abcdefgh -1 -》 abcdefgh
    Parameters:
    
    str - 字符串
    
    maxLength - 结果的最大长度
    
    Returns:
    
    截取后的字符串
  - join
```
public static String join(CharSequence conjunction,
                          Object... objs)
```
    以 conjunction 为分隔符将多个对象转换为字符串
    
    Parameters:
    
    conjunction - 分隔符 StrPool.COMMA
    
    objs - 数组
    
    Returns:
    
    连接后的字符串
    
    See Also:
    
    ArrayUtil.join(Object, CharSequence)
  - join
```
public static <T> String join(CharSequence conjunction,
                              Iterable<T> iterable)
```
    以 conjunction 为分隔符将多个对象转换为字符串
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    conjunction - 分隔符 StrPool.COMMA
    
    iterable - 集合
    
    Returns:
    
    连接后的字符串
    
    Since:
    
    5.6.6
    
    See Also:
    
    CollUtil.join(Iterable, CharSequence)
  - isAllCharMatch
```
public static boolean isAllCharMatch(CharSequence value,
                                     Matcher<Character> matcher)
```
    字符串的每一个字符是否都与定义的匹配器匹配
    
    Parameters:
    
    value - 字符串
    
    matcher - 匹配器
    
    Returns:
    
    是否全部匹配
    
    Since:
    
    3.2.3
  - isNumeric
```
public static boolean isNumeric(CharSequence str)
```
    检查字符串是否都为数字组成
    
    Parameters:
    
    str - 字符串
    
    Returns:
    
    是否都为数字组成
    
    Since:
    
    5.7.3
  - move
```
public static String move(CharSequence str,
                          int startInclude,
                          int endExclude,
                          int moveLength)
```
    循环位移指定位置的字符串为指定距离
    当moveLength大于0向右位移，小于0向左位移，0不位移
    当moveLength大于字符串长度时采取循环位移策略，即位移到头后从头（尾）位移，例如长度为10，位移13则表示位移3
    
    Parameters:
    
    str - 字符串
    
    startInclude - 起始位置（包括）
    
    endExclude - 结束位置（不包括）
    
    moveLength - 移动距离，负数表示左移，正数为右移
    
    Returns:
    
    位移后的字符串
    
    Since:
    
    4.0.7
  - isCharEquals
```
public static boolean isCharEquals(CharSequence str)
```
    检查给定字符串的所有字符是否都一样
    
    Parameters:
    
    str - 字符出啊
    
    Returns:
    
    给定字符串的所有字符是否都一样
    
    Since:
    
    5.7.3
  - normalize
```
public static String normalize(CharSequence str)
```
    对字符串归一化处理，如 "Á" 可以使用 "u00C1"或 "u0041u0301"表示，实际测试中两个字符串并不equals
    因此使用此方法归一为一种表示形式，默认按照W3C通常建议的，在NFC中交换文本。
    
    Parameters:
    
    str - 归一化的字符串
    
    Returns:
    
    归一化后的字符串
    
    Since:
    
    5.7.16
    
    See Also:
    
    Normalizer.normalize(CharSequence, Normalizer.Form)
  - fixLength
```
public static String fixLength(CharSequence str,
                               char fixedChar,
                               int length)
```
    在给定字符串末尾填充指定字符，以达到给定长度
    如果字符串本身的长度大于等于length，返回原字符串
    
    Parameters:
    
    str - 字符串
    
    fixedChar - 补充的字符
    
    length - 补充到的长度
    
    Returns:
    
    补充后的字符串
    
    Since:
    
    5.8.0
  - hasLetter
```
public static boolean hasLetter(CharSequence str)
```
    指定字符串数组中，是否包含空字符串。
    
    如果传入参数对象不是为空,则返回false。如果字符串包含字母,不区分大小写,则返回true
    
    Parameters:
    
    str - 对象
    
    Returns:
    
    如果为字符串, 是否有字母
  - commonPrefix
```
public static CharSequence commonPrefix(CharSequence str1,
                                        CharSequence str2)
```
    字符串1和字符串2的公共前缀
    
    Parameters:
    
    str1 - 字符串1
    
    str2 - 字符串2
    
    Returns:
    
    字符串1和字符串2的公共前缀
  - commonSuffix
```
public static CharSequence commonSuffix(CharSequence str1,
                                        CharSequence str2)
```
    字符串1和字符串2的公共后缀
    
    Parameters:
    
    str1 - 字符串1
    
    str2 - 字符串2
    
    Returns:
    
    字符串1和字符串2的公共后缀

Class CharSequenceUtil

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

INDEX_NOT_FOUND

NULL

EMPTY

SPACE

Constructor Detail

CharSequenceUtil

Method Detail

isBlank

isNotBlank

hasBlank

isAllBlank

isEmpty

isNotEmpty

emptyIfNull

nullToEmpty

nullToDefault

emptyToDefault

blankToDefault

emptyToNull

hasEmpty

isAllEmpty

isAllNotEmpty

isAllNotBlank

isNullOrUndefined

isEmptyOrUndefined

isBlankOrUndefined

trim

trimToEmpty

trimToNull

trimStart

trimEnd

trim

trim

startWith

startWith

startWith

startWith

startWithIgnoreEquals

startWithIgnoreCase

startWithAny

startWithAnyIgnoreCase

endWith

endWith

endWith

endWith

endWithIgnoreCase

endWithAny

endWithAnyIgnoreCase

contains

contains

containsAny

containsAny

containsOnly

containsAll

containsBlank

getContainsStr

containsIgnoreCase

containsAnyIgnoreCase

getContainsStrIgnoreCase

indexOf

indexOf

indexOf

indexOfIgnoreCase

indexOfIgnoreCase

indexOf

lastIndexOfIgnoreCase

lastIndexOfIgnoreCase

lastIndexOf

ordinalIndexOf

removeAll

removeAny

removeAll

removeAllLineBreaks

removePreAndLowerFirst