java.lang.Object

org.miaixz.bus.core.text.CharsValidator

org.miaixz.bus.core.text.CharsBacker

Direct Known Subclasses:: StringKit

public class CharsBacker extends CharsValidator

CharSequence 相关类封装，包括但不限于：

字符串补充前缀或后缀：addXXX
字符串补充长度：padXXX
字符串包含关系：containsXXX
字符串默认值：defaultIfXXX
字符串查找：indexOf
字符串判断以什么结尾：endWith
字符串判断以什么开始：startWith
字符串匹配：equals
字符串格式化：format
字符串去除：removeXXX
字符串重复：repeat
获取子串：sub
去除两边的指定字符串（只去除一次）：strip
去除两边的指定所有字符：trim
去除两边的指定所有字符包装和去除包装：wrap

需要注意的是，strip、trim、wrap（unWrap）的策略不同：

strip：强调去除两边或某一边的指定字符串，这个字符串不会重复去除，如果一边不存在，另一边不影响去除
trim：强调去除两边指定字符，如果这个字符有多个，全部去除，例如去除两边所有的空白符。
unWrap：强调去包装，要求包装的前后字符都要存在，只有一个则不做处理，如去掉双引号包装。

Since:: Java 17+
Author:: Kimi Liu

Constructor Summary

Constructors

Constructor

Description

CharsBacker()
Method Summary

Modifier and Type

Method

Description

static String

addPrefixIfNot(CharSequence text, CharSequence prefix)

如果给定字符串不是以prefix开头的，在开头补充 prefix

static String

addSuffixIfNot(CharSequence text, CharSequence suffix)

如果给定字符串不是以suffix结尾的，在尾部补充 suffix

static String

appendIfMissing(CharSequence text, CharSequence suffix, boolean ignoreCase, CharSequence... testSuffixes)

如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串

static String

appendIfMissing(CharSequence text, CharSequence suffix, CharSequence... suffixes)

如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串不忽略大小写

static String

appendIfMissingIgnoreCase(CharSequence text, CharSequence suffix, CharSequence... suffixes)

如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串忽略大小写

static String

brief(CharSequence text, 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

static StringBuilder

builder(CharSequence text)

创建StringBuilder对象如果对象本身为StringBuilder，直接返回，否则新建

static StringBuilder

builder(CharSequence... args)

创建StringBuilder对象

static int

byteLength(CharSequence cs, Charset charset)

给定字符串转为bytes后的byte数（byte长度）

static String

center(CharSequence text, int size)

居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串

static String

center(CharSequence text, int size, char padChar)

居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串

static String

center(CharSequence text, int size, CharSequence padStr)

居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串

static String

cleanBlank(CharSequence text)

清理空白字符

static int

codeLength(CharSequence cs)

获取字符串的Unicode字符长度，如果为null返回0 Unicode字符长度指实际Unicode字符个数，如emoji算一个字符

static CharSequence

commonPrefix(CharSequence text1, CharSequence text2)

获取两个字符串的公共前缀

static CharSequence

commonSuffix(CharSequence text1, CharSequence text2)

获取两个字符串的公共后缀

static int

compare(CharSequence text1, CharSequence text2, boolean nullIsLess)

比较两个字符串，用于排序

static int

compareIgnoreCase(CharSequence text1, CharSequence text2, boolean nullIsLess)

比较两个字符串，用于排序，大小写不敏感

static int

compareVersion(CharSequence version1, CharSequence version2)

比较两个版本 null版本排在最小：即：

static String

concat(boolean isNullToEmpty, CharSequence... args)

连接多个字符串为一个

static boolean

contains(CharSequence text, char args)

指定字符是否在字符串中出现过

static boolean

contains(CharSequence text, CharSequence args)

指定字符串是否在字符串中出现过

static boolean

containsAll(CharSequence text, CharSequence... args)

检查指定字符串中是否含给定的所有字符串

static boolean

containsAny(CharSequence text, char... args)

查找指定字符串是否包含指定字符列表中的任意一个字符

static boolean

containsAny(CharSequence text, CharSequence... args)

查找指定字符串是否包含指定字符串列表中的任意一个字符串

static boolean

containsAnyIgnoreCase(CharSequence text, CharSequence... args)

查找指定字符串是否包含指定字符串列表中的任意一个字符串忽略大小写

static boolean

containsBlank(CharSequence text)

给定字符串是否包含空白符（空白符包括空格、制表符、全角空格和不间断空格）如果给定字符串为null或者""，则返回false

static boolean

containsIgnoreCase(CharSequence text, CharSequence args)

是否包含特定字符，忽略大小写，如果给定两个参数都为null，返回true

static boolean

containsOnly(CharSequence text, char... args)

检查指定字符串中是否只包含给定的字符这里的containsOnly并不是必须全部给定的args都需要有，而是一个子集。

static int

count(CharSequence content, char charForSearch)

统计指定内容中包含指定字符的数量

static int

count(CharSequence content, CharSequence strForSearch)

统计指定内容中包含指定字符串的数量参数为 null 或者 "" 返回 0.

static String[]

cut(CharSequence text, int partLength)

将字符串切分为N等份

static <T extends CharSequence, V> V

defaultIfBlank(T text, Function<T,V> handler, Supplier<? extends V> defaultSupplier)

如果被检查对象为 null 或 "" 或空白字符串时，返回默认值（由 defaultValueSupplier 提供）；否则直接返回

static <T extends CharSequence> T

defaultIfBlank(T text, T defaultValue)

如果给定对象为null或者""或者空白符返回默认值

static <T extends CharSequence, V> V

defaultIfEmpty(T text, Function<T,V> handler, Supplier<? extends V> defaultSupplier)

如果给定对象为null或者""返回defaultHandler处理的结果, 否则返回自定义handler处理后的返回值

static <T extends CharSequence> T

defaultIfEmpty(T text, Supplier<? extends T> defaultSupplier)

如果给定对象为null或者""返回原值, 否则返回自定义handler处理后的返回值

static <T extends CharSequence> T

defaultIfEmpty(T text, T defaultValue)

如果给定对象为null或者 "" 返回默认值

static <T extends CharSequence, R> R

defaultIfNull(T source, Function<? super T,? extends R> handler, Supplier<? extends R> defaultSupplier)

如果给定字符串不为null 返回自定义handler处理后的结果，否则返回 Supplier.get() 提供的默认值

static <T extends CharSequence> T

defaultIfNull(T source, Supplier<? extends T> defaultSupplier)

如果给定字符串不为null 返回原值, 否则返回 Supplier.get() 提供的默认值

static <T extends CharSequence> T

defaultIfNull(T text, T defaultValue)

如果给定字符串为null返回默认值

static CharSequence

emptyIfNull(CharSequence text)

当给定字符串为空字符串时，转换为"" 此方法与toStringOrEmpty(Object)不同的是，如果提供的CharSequence非String，则保持原状

static boolean

endWith(CharSequence text, char c)

字符串是否以给定字符结尾

static boolean

endWith(CharSequence text, CharSequence suffix)

是否以指定字符串结尾

static boolean

endWith(CharSequence text, CharSequence suffix, boolean ignoreCase)

是否以指定字符串结尾如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false

static boolean

endWith(CharSequence text, CharSequence suffix, boolean ignoreCase, boolean ignoreEquals)

是否以指定字符串结尾如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false

static boolean

endWithAny(CharSequence text, CharSequence... suffixes)

给定字符串是否以任何一个字符串结尾给定字符串和数组为空都返回false

static boolean

endWithAnyIgnoreCase(CharSequence text, CharSequence... suffixes)

给定字符串是否以任何一个字符串结尾（忽略大小写）给定字符串和数组为空都返回false

static boolean

endWithIgnoreCase(CharSequence text, CharSequence suffix)

是否以指定字符串结尾，忽略大小写

static boolean

equals(CharSequence text1, CharSequence text2)

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

static boolean

equals(CharSequence text1, CharSequence text2, boolean ignoreCase)

比较两个字符串是否相等，规则如下 str1和str2都为null 忽略大小写使用String.equalsIgnoreCase(String)判断相等不忽略大小写使用String.contentEquals(CharSequence)判断相等

static boolean

equalsAny(CharSequence text, boolean ignoreCase, CharSequence... args)

给定字符串是否与提供的中任一字符串相同，相同则返回true，没有相同的返回false 如果参与比对的字符串列表为空，返回false

static boolean

equalsAny(CharSequence text1, CharSequence... strs)

给定字符串是否与提供的中任一字符串相同，相同则返回true，没有相同的返回false 如果参与比对的字符串列表为空，返回false

static boolean

equalsAnyIgnoreCase(CharSequence text1, CharSequence... strs)

给定字符串是否与提供的中任意一个字符串相同（忽略大小写），相同则返回true，没有相同的返回false 如果参与比对的字符串列表为空，返回false

static boolean

equalsCharAt(CharSequence text, int position, char c)

字符串指定位置的字符是否与给定字符相同如果字符串为null，返回false 如果给定的位置大于字符串长度，返回false 如果给定的位置小于0，返回false

static boolean

equalsIgnoreCase(CharSequence text1, CharSequence text2)

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

static String

filter(CharSequence text, Predicate<Character> predicate)

过滤字符串

static <T extends CharSequence> T

firstNonBlank(T... args)

返回第一个非blank 元素

static <T extends CharSequence> T

firstNonEmpty(T... args)

返回第一个非empty 元素

static <T extends CharSequence> T

firstNonNull(T... args)

返回第一个非null 元素

static String

fixLength(CharSequence text, char fixedChar, int length)

在给定字符串末尾填充指定字符，以达到给定长度如果字符串本身的长度大于等于length，返回原字符串

static void

forEach(CharSequence str, boolean isCodePoint, IntConsumer consumer)

遍历字符串的每个字符，并处理

static void

forEach(CharSequence str, Consumer<Character> consumer)

遍历字符串的每个字符，并处理

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

getContainsStrIgnoreCase(CharSequence text, CharSequence... args)

查找指定字符串是否包含指定字符串列表中的任意一个字符串，如果包含返回找到的第一个字符串忽略大小写

static String

getContainsString(CharSequence text, CharSequence... args)

查找指定字符串是否包含指定字符串列表中的任意一个字符串，如果包含返回找到的第一个字符串

static String

getGeneralField(CharSequence getOrSetMethodName)

获得set或get或is方法对应的标准属性名例如：setName 返回 name

static String

hide(CharSequence text, int startInclude, int endExclude)

替换指定字符串的指定区间内字符为"*"

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 text, char args)

指定范围内查找指定字符

static int

indexOf(CharSequence text, char args, int start)

指定范围内查找指定字符

static int

indexOf(CharSequence text, char args, int start, int end)

指定范围内查找指定字符

static int

indexOf(CharSequence text, CharSequence args, int from, boolean ignoreCase)

指定范围内查找字符串

static int

indexOf(CharSequence text, Predicate<Character> matcher, int start, int end)

指定范围内查找指定字符

static int

indexOfIgnoreCase(CharSequence text, CharSequence args)

指定范围内查找字符串，忽略大小写

static int

indexOfIgnoreCase(CharSequence text, CharSequence args, int fromIndex)

指定范围内查找字符串

static boolean

isCharEquals(CharSequence text)

检查给定字符串的所有字符是否都一样

static boolean

isLowerCase(CharSequence text)

给定字符串中的字母是否全部为小写，判断依据如下：

static boolean

isNumeric(CharSequence text)

检查字符串是否都为数字组成

static boolean

isSubEquals(CharSequence text1, int offset1, CharSequence text2, boolean ignoreCase)

截取第一个字串的部分字符，与第二个字符串比较（长度一致），判断截取的子串是否相同任意一个字符串为null返回false

static boolean

isSubEquals(CharSequence text1, int offset1, CharSequence text2, int offset2, int length, boolean ignoreCase)

截取两个字符串的不同部分（长度一致），判断截取的子串是否相同任意一个字符串为null返回false

static boolean

isUpperCase(CharSequence text)

给定字符串中的字母是否全部为大写，判断依据如下：

static boolean

isWrap(CharSequence text, char wrapper)

指定字符串是否被同一字符包装（前后都有这些字符串）

static boolean

isWrap(CharSequence text, char prefixChar, char suffixChar)

指定字符串是否被包装

static boolean

isWrap(CharSequence text, CharSequence prefix, CharSequence suffix)

指定字符串是否被包装

static boolean

isWrap(CharSequence text, String wrapper)

指定字符串是否被同一字符包装（前后都有这些字符串）

static <T> String

join(CharSequence conjunction, Iterable<T> iterable)

以 conjunction 为分隔符将多个对象转换为字符串

static String

join(CharSequence conjunction, Object... objs)

以 conjunction 为分隔符将多个对象转换为字符串

static int

lastIndexOf(CharSequence text, CharSequence args, int from, boolean ignoreCase)

指定范围内查找字符串 fromIndex 为搜索起始位置，从后往前计数

static int

lastIndexOfIgnoreCase(CharSequence text, CharSequence args)

指定范围内查找字符串，忽略大小写

static int

lastIndexOfIgnoreCase(CharSequence text, CharSequence args, int fromIndex)

指定范围内查找字符串，忽略大小写 fromIndex 为搜索起始位置，从后往前计数

static String

left(String text, int len)

获取字符串中最左边的len字符

static int

length(CharSequence cs)

获取字符串的长度，如果为null返回0

static String

limitByteLength(CharSequence text, Charset charset, int maxBytesLength, int factor, boolean appendDots)

截断字符串，使用其按照指定编码为字节后不超过maxBytes长度此方法用于截取总bytes数不超过指定长度，如果字符出没有超出原样输出，如果超出了，则截取掉超出部分，并可选添加...，但是添加“...”后总长度也不超过限制长度。

static String

limitByteLengthUtf8(CharSequence text, int maxBytesLength, boolean appendDots)

截断字符串，使用UTF8编码为字节后不超过maxBytes长度

static String

limitLength(CharSequence text, int length)

限制字符串长度，如果超过指定长度，截取指定长度并在末尾加"..."

static String

lowerAt(CharSequence text, int index)

小写对应下标字母例如: text = NAME,index = 1, return NaME

static String

lowerFirst(CharSequence text)

小写首字母例如：text = Name, return name

static String

mid(String text, int pos, int len)

从字符串中间获取len字符.

static String

move(CharSequence text, int startInclude, int endExclude, int moveLength)

循环位移指定位置的字符串为指定距离当moveLength大于0向右位移，小于0向左位移，0不位移当moveLength大于字符串长度时采取循环位移策略，即位移到头后从头（尾）位移，例如长度为10，位移13则表示位移3

static String

normalize(CharSequence text)

对字符串归一化处理，如 "Á" 可以使用 "u00C1"或 "u0041u0301"表示，实际测试中两个字符串并不equals 因此使用此方法归一为一种表示形式，默认按照W3C通常建议的，在NFC中交换文本。

static <T extends CharSequence> T

nullIfEmpty(T text)

当给定字符串为空字符串时，转换为null

static int

ordinalIndexOf(CharSequence text, CharSequence args, int ordinal)

返回字符串 args 在字符串 text1 中第 ordinal 次出现的位置。

static String

padAfter(CharSequence text, int length, char padChar)

补充字符串以满足最小长度，如果提供的字符串大于指定长度，截断之

static String

padAfter(CharSequence text, int length, CharSequence padStr)

补充字符串以满足最小长度

static String

padPre(CharSequence text, int length, char padChar)

补充字符串以满足最小长度，如果提供的字符串大于指定长度，截断之同：leftPad (org.apache.commons.lang3.leftPad)

static String

padPre(CharSequence text, int length, CharSequence padStr)

补充字符串以满足指定长度，如果提供的字符串大于指定长度，截断之同：leftPad (org.apache.commons.lang3.leftPad)

static String

prependIfMissing(CharSequence text, CharSequence prefix, boolean ignoreCase, CharSequence... prefixes)

如果给定字符串不是以给定的一个或多个字符串为开头，则在首部添加起始字符串

static String

prependIfMissing(CharSequence text, CharSequence prefix, CharSequence... prefixes)

如果给定字符串不是以给定的一个或多个字符串为开头，则在前面添加起始字符串不忽略大小写

static String

prependIfMissingIgnoreCase(CharSequence text, CharSequence prefix, CharSequence... prefixes)

如果给定字符串不是以给定的一个或多个字符串为开头，则在首部添加起始字符串忽略大小写

static String

removeAll(CharSequence text, char... chars)

去除字符串中指定的多个字符，如有多个则全部去除

static String

removeAll(CharSequence text, CharSequence args)

移除字符串中所有给定字符串例：removeAll("aa-bb-cc-dd", "-") = aabbccdd

static String

removeAll(CharSequence text, CharSequence... args)

移除字符串中所有给定字符串，当某个字符串出现多次，则全部移除例：removeAny("aa-bb-cc-dd", "a", "b") = --cc-dd

static String

removeAllLineBreaks(CharSequence text)

去除所有换行符，包括：

static String

removeAllSuffix(CharSequence text, CharSequence suffix)

去掉指定所有后缀，如：

static String

removePreAndLowerFirst(CharSequence text, int preLength)

去掉首部指定长度的字符串并将剩余字符串首字母小写例如：text1=setName, preLength=3 = return name

static String

removePreAndLowerFirst(CharSequence text, CharSequence prefix)

去掉首部指定长度的字符串并将剩余字符串首字母小写例如：text1=setName, prefix=set = return name

static String

removePrefix(CharSequence text, CharSequence prefix)

去掉指定前缀

static String

removePrefix(CharSequence text, CharSequence prefix, boolean ignoreCase)

去掉指定前缀

static String

removePrefixIgnoreCase(CharSequence text, CharSequence prefix)

忽略大小写去掉指定前缀

static String

removeSufAndLowerFirst(CharSequence text, CharSequence suffix)

去掉指定后缀，并小写首字母

static String

removeSuffix(CharSequence text, CharSequence suffix)

去掉指定后缀

static String

removeSuffixIgnoreCase(CharSequence text, CharSequence suffix)

忽略大小写去掉指定后缀

static String

repeat(char c, int count)

重复某个字符

static String

repeat(CharSequence text, int count)

重复某个字符串

static String

repeatAndJoin(CharSequence text, int count, CharSequence delimiter)

重复某个字符串并通过分界符连接

static String

repeatByLength(CharSequence text, int padLen)

重复某个字符串到指定长度如果指定长度非指定字符串的整数倍，截断到固定长度如果指定长度小于字符串本身的长度，截断之

static String

replace(CharSequence text, int fromIndex, CharSequence searchStr, CharSequence replacement, boolean ignoreCase)

替换字符串中的指定字符串如果指定字符串出现多次，则全部替换

static String

replace(CharSequence text, CharSequence searchStr, CharSequence replacement)

替换字符串中的指定字符串

static String

replace(CharSequence text, CharSequence searchStr, CharSequence replacement, boolean ignoreCase)

替换字符串中的指定字符串

static String

replace(CharSequence text, String regex, FunctionX<Matcher,String> replaceFun)

替换所有正则匹配的文本，并使用自定义函数决定如何替换

static String

replace(CharSequence text, Pattern pattern, FunctionX<Matcher,String> replaceFun)

替换所有正则匹配的文本，并使用自定义函数决定如何替换 replaceFun可以提取出匹配到的内容的不同部分，然后经过重新处理、组装变成新的内容放回原位。

static String

replaceAt(CharSequence text, int index, UnaryOperator<Character> operator)

按照给定逻辑替换指定位置的字符，如字符大小写转换等

static String

replaceByCodePoint(CharSequence text, int beginInclude, int endExclude, char replacedChar)

替换指定字符串的指定区间内字符为固定字符，替换后字符串长度不变如替换的区间长度为10，则替换后的字符重复10次此方法使用String.codePoints()完成拆分替换

static String

replaceByCodePoint(CharSequence text, int beginInclude, int endExclude, CharSequence replacedStr)

替换指定字符串的指定区间内字符为指定字符串，字符串只重复一次此方法使用String.codePoints()完成拆分替换

static String

replaceChars(CharSequence text, char[] chars, CharSequence replacedStr)

替换字符字符数组中所有的字符为replacedStr

static String

replaceChars(CharSequence text, String chars, CharSequence replacedStr)

替换字符字符数组中所有的字符为replacedStr 提供的chars为所有需要被替换的字符，例如："\r\n"，则"\r"和"\n"都会被替换，哪怕他们单独存在

static String

replaceFirst(CharSequence text, CharSequence searchStr, CharSequence replacedStr, boolean ignoreCase)

替换字符串中第一个指定字符串

static String

replaceIgnoreCase(CharSequence text, CharSequence searchStr, CharSequence replacement)

替换字符串中的指定字符串，忽略大小写

static String

replaceLast(CharSequence text, CharSequence searchStr, CharSequence replacedStr, boolean ignoreCase)

替换字符串中最后一个指定字符串

static String

right(String text, int len)

获取字符串中最右边的len字符

static List<String>

split(CharSequence text, CharSequence separator)

切分字符串，如果分隔符不存在则返回原字符串此方法不会去除切分字符串后每个元素两边的空格，不忽略空串

static List<String>

split(CharSequence text, CharSequence separator, boolean isTrim, boolean ignoreEmpty)

切分字符串，不忽略大小写

static List<String>

split(CharSequence text, CharSequence separator, int limit, boolean isTrim, boolean ignoreEmpty)

切分字符串，不忽略大小写

static List<String>

split(CharSequence text, CharSequence separator, int limit, boolean isTrim, boolean ignoreEmpty, boolean ignoreCase)

切分字符串如果提供的字符串为null，则返回一个空的ArrayList 如果提供的字符串为""，则当ignoreEmpty时返回空的ArrayList，否则返回只有一个""元素的ArrayList

static <R> List<R>

split(CharSequence text, CharSequence separator, int limit, boolean ignoreEmpty, boolean ignoreCase, Function<String,R> mapping)

切分字符串如果提供的字符串为null，则返回一个空的ArrayList 如果提供的字符串为""，则当ignoreEmpty时返回空的ArrayList，否则返回只有一个""元素的ArrayList

static String

split(String text)

切分字符串

static String

split(String text, String separator, String reserve)

切分字符串

static List<String>

splitByBlank(CharSequence text)

使用空白符切分字符串切分后的字符串两边不包含空白符，空串或空白符串并不做为元素之一如果为空字符串或者null 则返回空集合

static List<String>

splitByBlank(CharSequence text, int limit)

使用空白符切分字符串切分后的字符串两边不包含空白符，空串或空白符串并不做为元素之一如果为空字符串或者null 则返回空集合

static String[]

splitByBlankToArray(CharSequence text, int limit)

切分字符串为字符串数组

static String[]

splitByLength(CharSequence text, int len)

根据给定长度，将给定字符串截取为多个部分

static List<String>

splitByRegex(CharSequence text, String separatorRegex, int limit, boolean isTrim, boolean ignoreEmpty)

通过正则切分字符串，规则如下：当提供的str为null时，返回new ArrayList(0) 当提供的str为""时，返回[""] 当提供的separatorRegex为empty(null or "")时，返回[text]，即只有原串一个元素的数组

static List<String>

splitByRegex(CharSequence text, Pattern separatorPattern, int limit, boolean isTrim, boolean ignoreEmpty)

通过正则切分字符串，规则如下：当提供的str为null时，返回new ArrayList(0) 当提供的str为""时，返回[""] 当提供的separatorRegex为empty(null or "")时，返回[text]，即只有原串一个元素的数组

static String[]

splitByRegexToArray(CharSequence text, Pattern separatorPattern, int limit, boolean isTrim, boolean ignoreEmpty)

通过正则切分字符串为字符串数组

static List<String>

splitPath(CharSequence text)

切分路径字符串如果为空字符串或者null 则返回空集合空路径会被忽略

static List<String>

splitPath(CharSequence text, int limit)

切分路径字符串如果为空字符串或者null 则返回空集合空路径会被忽略

static <T> T

splitTo(CharSequence text, CharSequence separator, Class<T> resultType)

切分字符串，去除切分后每个元素两边的空白符，去除空白项，并转为结果类型

static String[]

splitToArray(CharSequence text, CharSequence separator)

切分字符串，如果分隔符不存在则返回原字符串此方法不会去除切分字符串后每个元素两边的空格，不忽略空串

static List<String>

splitTrim(CharSequence text, CharSequence separator)

切分字符串，去除切分后每个元素两边的空白符，去除空白项

static boolean

startWith(CharSequence text, char c)

字符串是否以给定字符开始

static boolean

startWith(CharSequence text, CharSequence prefix)

是否以指定字符串开头

static boolean

startWith(CharSequence text, CharSequence prefix, boolean ignoreCase)

是否以指定字符串开头如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false

static boolean

startWith(CharSequence text, CharSequence prefix, boolean ignoreCase, boolean ignoreEquals)

是否以指定字符串开头如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false

static boolean

startWithAny(CharSequence text, CharSequence... prefixes)

给定字符串是否以任何一个字符串开始给定字符串和数组为空都返回false

static boolean

startWithAnyIgnoreCase(CharSequence text, CharSequence... prefixes)

给定字符串是否以任何一个字符串开始（忽略大小写）给定字符串和数组为空都返回false

static boolean

startWithIgnoreCase(CharSequence text, CharSequence prefix)

是否以指定字符串开头，忽略大小写

static boolean

startWithIgnoreEquals(CharSequence text, CharSequence prefix)

是否以指定字符串开头，忽略相等字符串的情况

static String

strip(CharSequence text, CharSequence prefixOrSuffix)

去除两边的指定字符串

static String

strip(CharSequence text, CharSequence prefix, CharSequence suffix)

去除两边的指定字符串两边字符如果存在，则去除，不存在不做处理

static String

strip(CharSequence text, CharSequence prefix, CharSequence suffix, boolean ignoreCase)

去除两边的指定字符串两边字符如果存在，则去除，不存在不做处理

static String

stripIgnoreCase(CharSequence text, CharSequence prefixOrSuffix)

去除两边的指定字符串，忽略大小写

static String

stripIgnoreCase(CharSequence text, CharSequence prefix, CharSequence suffix)

去除两边的指定字符串，忽略大小写

static String

sub(CharSequence text, int fromIndexInclude, int toIndexExclude)

改进JDK subString index从0开始计算，最后一个字符为-1，即sub("miaixz", 0, -1)得到"miaixz" 如果from和to位置一样，返回 "" 如果from或to为负数，则按照length从后向前数位置，如果绝对值大于字符串长度，则from归到0，to归到length 如果经过修正的index中from大于to，则互换from和to，如abcdefgh 2 3 =》 c，abcdefgh 2 -3 =》 cde

static String

subAfter(CharSequence text, char separator, boolean isLastSeparator)

截取分隔字符串之后的字符串，不包括分隔字符串如果给定的字符串为空串（null或""），返回原字符串如果分隔字符串为空串（null或""），则返回空串，如果分隔字符串未找到，返回空串，举例如下：

static String

subAfter(CharSequence text, CharSequence separator, boolean isLastSeparator)

截取分隔字符串之后的字符串，不包括分隔字符串如果给定的字符串为空串（null或""），返回原字符串如果分隔字符串为空串（null或""），则返回空串，如果分隔字符串未找到，返回空串，举例如下：

static String

subBefore(CharSequence text, char separator, boolean isLastSeparator)

截取分隔字符串之前的字符串，不包括分隔字符串如果给定的字符串为空串（null或""）或者分隔字符串为null，返回原字符串如果分隔字符串未找到，返回原字符串，举例如下：

static String

subBefore(CharSequence text, CharSequence separator, boolean isLastSeparator)

截取分隔字符串之前的字符串，不包括分隔字符串如果给定的字符串为空串（null或""）或者分隔字符串为null，返回原字符串如果分隔字符串为空串""，则返回空串，如果分隔字符串未找到，返回原字符串，举例如下：

static String

subBetween(CharSequence text, CharSequence beforeAndAfter)

截取指定字符串中间部分，不包括标识字符串

static String

subBetween(CharSequence text, CharSequence before, CharSequence after)

截取指定字符串中间部分，不包括标识字符串

static String[]

subBetweenAll(CharSequence text, CharSequence prefixAndSuffix)

截取指定字符串多段中间部分，不包括标识字符串

static String[]

subBetweenAll(CharSequence text, CharSequence prefix, CharSequence suffix)

截取指定字符串多段中间部分，不包括标识字符串

static String

subByCodePoint(CharSequence text, int fromIndex, int toIndex)

通过CodePoint截取字符串，可以截断Emoji

static String

subByLength(String input, int fromIndex, int length)

截取字符串,从指定位置开始,截取指定长度的字符串当fromIndex为正数时，这个index指的是插空位置，如下：

static String

subPre(CharSequence text, int toIndexExclude)

切割指定位置之前部分的字符串安全的subString,允许：string为null，允许string长度小于toIndexExclude长度

static String

subPreGbk(CharSequence text, int len, boolean halfUp)

截取部分字符串，这里一个汉字的长度认为是2 可以自定义halfUp，如len为10，如果截取后最后一个字符是半个字符，true表示保留，则长度是11，否则长度9

static String

subPreGbk(CharSequence text, int len, CharSequence suffix)

截取部分字符串，这里一个汉字的长度认为是2

static String

subSuf(CharSequence text, int fromIndex)

切割指定位置之后部分的字符串 fromIndex为0或字符串为空，返回原字符串 fromIndex大于字符串本身的长度，返回"" fromIndex支持负数，-1表示length-1

static String

subSufByLength(CharSequence text, int length)

切割指定长度的后部分的字符串

static String

swapCase(String text)

切换给定字符串中的大小写。

static String

toCamelCase(CharSequence name)

将下划线方式命名的字符串转换为驼峰式。

static String

toCamelCase(CharSequence name, char symbol)

将连接符方式命名的字符串转换为驼峰式。

static int[]

toChars(CharSequence text, boolean isCodePoint)

将字符串转换为字符数组

static String

toString(Object obj)

调用对象的toString方法，null会返回“null”

static String

toStringOrEmpty(Object obj)

调用对象的toString方法，null会返回空字符串 "" 如果仅仅是对CharSequence处理，请使用emptyIfNull(CharSequence)

static String

toStringOrNull(Object obj)

调用对象的toString方法，null会返回null

static String

toSymbolCase(CharSequence text, char symbol)

将驼峰式命名的字符串转换为使用符号连接方式。

static int

totalLength(CharSequence... args)

给定字符串数组的总长度 null字符长度定义为0

static String

toUnderlineCase(CharSequence text)

将驼峰式命名的字符串转换为下划线方式。

static String

trim(CharSequence text)

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

static String

trim(CharSequence text, StringTrimer.TrimMode mode)

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

static String

trim(CharSequence text, StringTrimer.TrimMode mode, Predicate<Character> predicate)

按照断言，除去字符串头尾部的断言为真的字符，如果字符串是null，依然返回null。

static Function<String,String>

trimFunc(boolean isTrim)

Trim函数

static String

trimPrefix(CharSequence text)

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

static String

trimSuffix(CharSequence text)

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

static String

trimToEmpty(CharSequence text)

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

static String

trimToNull(CharSequence text)

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

static String

unWrap(CharSequence text, char prefixAndSuffix)

去掉字符包装，如果未被包装则返回原字符串

static String

unWrap(CharSequence text, char prefix, char suffix)

去掉字符包装，如果未被包装则返回原字符串

static String

unWrap(CharSequence text, String prefix, String suffix)

去掉字符包装，如果未被包装则返回原字符串此方法要求prefix和suffix都存在，如果只有一个，不做去除。

static String

upperAt(CharSequence text, int index)

大写对应下标字母

static String

upperFirst(CharSequence text)

大写首字母例如：text = name, return Name

static String

upperFirstAndAddPre(CharSequence text, String preString)

原字符串首字母大写并在其首部添加指定字符串例如：text=name, preString=get = return getName

static String

wrap(CharSequence text, char prefix, char suffix)

包装指定字符串

static String

wrap(CharSequence text, CharSequence prefixAndSuffix)

包装指定字符串当前缀和后缀一致时使用此方法

static String

wrap(CharSequence text, 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 text, CharSequence prefix, CharSequence suffix)

包装指定字符串，如果前缀或后缀已经包含对应的字符串，则不再包装

Methods inherited from class org.miaixz.bus.core.text.CharsValidator
hasBlank, hasEmpty, hasEmpty, isAllBlank, isAllCharMatch, isAllEmpty, isAllEmpty, isAllNotBlank, isAllNotEmpty, isBlank, isBlankOrUndefined, isEmpty, isEmptyOrUndefined, isNotBlank, isNotEmpty, isNullOrUndefined

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

Constructor Details
- CharsBacker
  
  public CharsBacker()
Method Details
- toString
  public static String toString(Object obj)
  
  调用对象的toString方法，null会返回“null”
  
  Parameters:
  
  obj - 对象
  
  Returns:
  
  字符串
  
  See Also:
  
  String.valueOf(Object)
- toStringOrNull
  
  public static String toStringOrNull(Object obj)
  
  调用对象的toString方法，null会返回null
  
  Parameters:
  
  obj - 对象
  
  Returns:
  
  字符串 or null
- toStringOrEmpty
  public static String toStringOrEmpty(Object obj)
  
  调用对象的toString方法，null会返回空字符串 "" 如果仅仅是对CharSequence处理，请使用emptyIfNull(CharSequence)
  
  Parameters:
  
  obj - 对象
  
  Returns:
  
  String
  
  See Also:
  
  emptyIfNull(CharSequence)
- emptyIfNull
  public static CharSequence emptyIfNull(CharSequence text)
  
  当给定字符串为空字符串时，转换为"" 此方法与toStringOrEmpty(Object)不同的是，如果提供的CharSequence非String，则保持原状
  
  Parameters:
  
  text - 被转换的字符串
  
  Returns:
  
  转换后的字符串
  
  See Also:
  
  toStringOrEmpty(Object)
- nullIfEmpty
  
  public static <T extends CharSequence> T nullIfEmpty(T text)
  
  当给定字符串为空字符串时，转换为null
  
  Type Parameters:
  
  T - 字符串类型
  
  Parameters:
  
  text - 被转换的字符串
  
  Returns:
  
  转换后的字符串
- defaultIfNull
  public static <T extends CharSequence> T defaultIfNull(T text, T defaultValue)
  
  如果给定字符串为null返回默认值
  defaultIfNull(null, null); = null defaultIfNull(null, ""); = "" defaultIfNull(null, "zz"); = "zz" defaultIfNull("abc", *); = "abc"
  
  Type Parameters:
  
  T - 字符串类型
  
  Parameters:
  
  text - 被检查字符串，可能为null
  
  defaultValue - 被检查字符串为null返回的默认值，可以为null
  
  Returns:
  
  被检查字符串不为 null 返回原值，否则返回默认值
  
  See Also:
  
  ObjectValidator.defaultIfNull(Object, Object)
- defaultIfNull
  public static <T extends CharSequence> T defaultIfNull(T source, Supplier<? extends T> defaultSupplier)
  
  如果给定字符串不为null 返回原值, 否则返回 Supplier.get() 提供的默认值
  
  Type Parameters:
  
  T - 被检查字符串类型
  
  Parameters:
  
  source - 被检查字符串，可能为null
  
  defaultSupplier - 为空时的默认值提供者
  
  Returns:
  
  被检查字符串不为 null 返回原值，否则返回 Supplier.get() 提供的默认值
  
  See Also:
  
  ObjectValidator.defaultIfNull(Object, Supplier)
- defaultIfNull
  public static <T extends CharSequence, R> R defaultIfNull(T source, Function<? super T,? extends R> handler, Supplier<? extends R> defaultSupplier)
  
  如果给定字符串不为null 返回自定义handler处理后的结果，否则返回 Supplier.get() 提供的默认值
  
  Type Parameters:
  
  T - 被检查对象类型
  
  R - 返回值类型
  
  Parameters:
  
  source - 被检查对象，可能为null
  
  handler - 非空时自定义的处理方法
  
  defaultSupplier - 为空时的默认值提供者
  
  Returns:
  
  被检查对象不为 null 返回处理后的结果，否则返回 Supplier.get() 提供的默认值
  
  See Also:
  
  ObjectValidator.defaultIfNull(Object, Function, Supplier)
- defaultIfEmpty
  public static <T extends CharSequence> T defaultIfEmpty(T text, T defaultValue)
  
  如果给定对象为null或者 "" 返回默认值
  defaultIfEmpty(null, null) = null defaultIfEmpty(null, "") = "" defaultIfEmpty("", "zz") = "zz" defaultIfEmpty(" ", "zz") = " " defaultIfEmpty("abc", *) = "abc"
  
  Type Parameters:
  
  T - 对象类型（必须实现CharSequence接口）
  
  Parameters:
  
  text - 被检查对象，可能为null
  
  defaultValue - 被检查对象为null或者 ""返回的默认值，可以为null或者 ""
  
  Returns:
  
  被检查对象为null或者 ""返回默认值，否则返回原值
- defaultIfEmpty
  
  public static <T extends CharSequence> T defaultIfEmpty(T text, Supplier<? extends T> defaultSupplier)
  
  如果给定对象为null或者""返回原值, 否则返回自定义handler处理后的返回值
  
  Type Parameters:
  
  T - 被检查对象类型
  
  Parameters:
  
  text - String 类型
  
  defaultSupplier - empty时的处理方法
  
  Returns:
  
  处理后的返回值
- defaultIfEmpty
  
  public static <T extends CharSequence, V> V defaultIfEmpty(T text, Function<T,V> handler, Supplier<? extends V> defaultSupplier)
  
  如果给定对象为null或者""返回defaultHandler处理的结果, 否则返回自定义handler处理后的返回值
  
  Type Parameters:
  
  T - 被检查对象类型
  
  V - 结果类型
  
  Parameters:
  
  text - String 类型
  
  handler - 非empty的处理方法
  
  defaultSupplier - empty时的处理方法
  
  Returns:
  
  处理后的返回值
- defaultIfBlank
  public static <T extends CharSequence> T defaultIfBlank(T text, T defaultValue)
  
  如果给定对象为null或者""或者空白符返回默认值
  defaultIfBlank(null, null) = null defaultIfBlank(null, "") = "" defaultIfBlank("", "zz") = "zz" defaultIfBlank(" ", "zz") = "zz" defaultIfBlank("abc", *) = "abc"
  
  Type Parameters:
  
  T - 对象类型（必须实现CharSequence接口）
  
  Parameters:
  
  text - 被检查对象，可能为null
  
  defaultValue - 被检查对象为null或者 ""或者空白符返回的默认值，可以为null或者 ""或者空白符
  
  Returns:
  
  被检查对象为null或者 ""或者空白符返回默认值，否则返回原值
- defaultIfBlank
  
  public static <T extends CharSequence, V> V defaultIfBlank(T text, Function<T,V> handler, Supplier<? extends V> defaultSupplier)
  
  如果被检查对象为 null 或 "" 或空白字符串时，返回默认值（由 defaultValueSupplier 提供）；否则直接返回
  
  Type Parameters:
  
  T - 对象类型（必须实现CharSequence接口）
  
  V - 结果类型
  
  Parameters:
  
  text - 被检查对象
  
  handler - 非blank的处理方法
  
  defaultSupplier - 默认值提供者
  
  Returns:
  
  被检查对象为null返回默认值，否则返回自定义handle处理后的返回值
  
  Throws:
  
  NullPointerException - defaultValueSupplier == null 时，抛出
- trim
  public static String trim(CharSequence text)
  
  除去字符串头尾部的空白，如果字符串是null，依然返回null。
  注意，和String.trim()不同，此方法使用CharKit.isBlankChar(char) 来判定空白，因而可以除去英文字符集之外的其它空白，如中文空格。
  
  去除字符串空格罗列相关如下：
  
  trimPrefix(CharSequence)去除头部空格
  
  trimSuffix(CharSequence)去除尾部空格
  
  cleanBlank(CharSequence)去除头部、尾部、中间空格
  
  trim(null) = null trim("") = "" trim(" ") = "" trim("abc") = "abc" trim(" abc ") = "abc"
  
  Parameters:
  
  text - 要处理的字符串
  
  Returns:
  
  除去头尾空白的字符串，如果原字串为null，则返回null
- trimToEmpty
  public static String trimToEmpty(CharSequence text)
  
  除去字符串头尾部的空白，如果字符串是null，返回""。
  trimToEmpty(null) = "" trimToEmpty("") = "" trimToEmpty(" ") = "" trimToEmpty("abc") = "abc" trimToEmpty(" abc ") = "abc"
  
  Parameters:
  
  text - 字符串
  
  Returns:
  
  去除两边空白符后的字符串, 如果为null返回""
- trimToNull
  public static String trimToNull(CharSequence text)
  
  除去字符串头尾部的空白，如果字符串是null或者""，返回null。
  trimToNull(null) = null trimToNull("") = null trimToNull(" ") = null trimToNull("abc") = "abc" trimToEmpty(" abc ") = "abc"
  
  Parameters:
  
  text - 字符串
  
  Returns:
  
  去除两边空白符后的字符串, 如果为空返回null
- trimPrefix
  public static String trimPrefix(CharSequence text)
  
  除去字符串头部的空白，如果字符串是null，则返回null。
  注意，和String.trim()不同，此方法使用CharKit.isBlankChar(char) 来判定空白，因而可以除去英文字符集之外的其它空白，如中文空格。
  trimPrefix(null) = null trimPrefix("") = "" trimPrefix("abc") = "abc" trimPrefix(" abc") = "abc" trimPrefix("abc ") = "abc " trimPrefix(" abc ") = "abc "
  
  Parameters:
  
  text - 要处理的字符串
  
  Returns:
  
  除去空白的字符串，如果原字串为null或结果字符串为""，则返回 null
- trimSuffix
  public static String trimSuffix(CharSequence text)
  
  除去字符串尾部的空白，如果字符串是null，则返回null。
  注意，和String.trim()不同，此方法使用CharKit.isBlankChar(char) 来判定空白，因而可以除去英文字符集之外的其它空白，如中文空格。
  trimSuffix(null) = null trimSuffix("") = "" trimSuffix("abc") = "abc" trimSuffix(" abc") = " abc" trimSuffix("abc ") = "abc" trimSuffix(" abc ") = " abc"
  
  Parameters:
  
  text - 要处理的字符串
  
  Returns:
  
  除去空白的字符串，如果原字串为null或结果字符串为""，则返回 null
- trim
  
  public static String trim(CharSequence text, StringTrimer.TrimMode mode)
  
  除去字符串头尾部的空白符，如果字符串是null，依然返回null。
  
  Parameters:
  
  text - 要处理的字符串
  
  mode - 去除模式，可选去除头部、尾部、两边
  
  Returns:
  
  除去指定字符后的的字符串，如果原字串为null，则返回null
- trim
  
  public static String trim(CharSequence text, StringTrimer.TrimMode mode, Predicate<Character> predicate)
  
  按照断言，除去字符串头尾部的断言为真的字符，如果字符串是null，依然返回null。
  
  Parameters:
  
  text - 要处理的字符串
  
  mode - 去除模式，可选去除头部、尾部、两边
  
  predicate - 断言是否过掉字符，返回true表述过滤掉，false表示不过滤
  
  Returns:
  
  除去指定字符后的的字符串，如果原字串为null，则返回null
- startWith
  
  public static boolean startWith(CharSequence text, char c)
  
  字符串是否以给定字符开始
  
  Parameters:
  
  text - 字符串
  
  c - 字符
  
  Returns:
  
  是否开始
- startWith
  
  public static boolean startWith(CharSequence text, CharSequence prefix)
  
  是否以指定字符串开头
  
  Parameters:
  
  text - 被监测字符串
  
  prefix - 开头字符串
  
  Returns:
  
  是否以指定字符串开头
- startWithIgnoreEquals
  
  public static boolean startWithIgnoreEquals(CharSequence text, CharSequence prefix)
  
  是否以指定字符串开头，忽略相等字符串的情况
  
  Parameters:
  
  text - 被监测字符串
  
  prefix - 开头字符串
  
  Returns:
  
  是否以指定字符串开头并且两个字符串不相等
- startWithIgnoreCase
  
  public static boolean startWithIgnoreCase(CharSequence text, CharSequence prefix)
  
  是否以指定字符串开头，忽略大小写
  
  Parameters:
  
  text - 被监测字符串
  
  prefix - 开头字符串
  
  Returns:
  
  是否以指定字符串开头
- startWithAny
  
  public static boolean startWithAny(CharSequence text, CharSequence... prefixes)
  
  给定字符串是否以任何一个字符串开始给定字符串和数组为空都返回false
  
  Parameters:
  
  text - 给定字符串
  
  prefixes - 需要检测的开始字符串
  
  Returns:
  
  给定字符串是否以任何一个字符串开始
- startWithAnyIgnoreCase
  
  public static boolean startWithAnyIgnoreCase(CharSequence text, CharSequence... prefixes)
  
  给定字符串是否以任何一个字符串开始（忽略大小写）给定字符串和数组为空都返回false
  
  Parameters:
  
  text - 给定字符串
  
  prefixes - 需要检测的开始字符串
  
  Returns:
  
  给定字符串是否以任何一个字符串开始
- startWith
  
  public static boolean startWith(CharSequence text, CharSequence prefix, boolean ignoreCase)
  
  是否以指定字符串开头如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
  
  Parameters:
  
  text - 被监测字符串
  
  prefix - 开头字符串
  
  ignoreCase - 是否忽略大小写
  
  Returns:
  
  是否以指定字符串开头
- startWith
  public static boolean startWith(CharSequence text, CharSequence prefix, boolean ignoreCase, boolean ignoreEquals)
  
  是否以指定字符串开头如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
  CharsBacker.startWith("123", "123", false, true); -- false CharsBacker.startWith("ABCDEF", "abc", true, true); -- true CharsBacker.startWith("abc", "abc", true, true); -- false
  
  Parameters:
  
  text - 被监测字符串
  
  prefix - 开头字符串
  
  ignoreCase - 是否忽略大小写
  
  ignoreEquals - 是否忽略字符串相等的情况
  
  Returns:
  
  是否以指定字符串开头
- endWith
  
  public static boolean endWith(CharSequence text, char c)
  
  字符串是否以给定字符结尾
  
  Parameters:
  
  text - 字符串
  
  c - 字符
  
  Returns:
  
  是否结尾
- endWith
  
  public static boolean endWith(CharSequence text, CharSequence suffix)
  
  是否以指定字符串结尾
  
  Parameters:
  
  text - 被监测字符串
  
  suffix - 结尾字符串
  
  Returns:
  
  是否以指定字符串结尾
- endWithIgnoreCase
  
  public static boolean endWithIgnoreCase(CharSequence text, CharSequence suffix)
  
  是否以指定字符串结尾，忽略大小写
  
  Parameters:
  
  text - 被监测字符串
  
  suffix - 结尾字符串
  
  Returns:
  
  是否以指定字符串结尾
- endWithAny
  
  public static boolean endWithAny(CharSequence text, CharSequence... suffixes)
  
  给定字符串是否以任何一个字符串结尾给定字符串和数组为空都返回false
  
  Parameters:
  
  text - 给定字符串
  
  suffixes - 需要检测的结尾字符串
  
  Returns:
  
  给定字符串是否以任何一个字符串结尾
- endWithAnyIgnoreCase
  
  public static boolean endWithAnyIgnoreCase(CharSequence text, CharSequence... suffixes)
  
  给定字符串是否以任何一个字符串结尾（忽略大小写）给定字符串和数组为空都返回false
  
  Parameters:
  
  text - 给定字符串
  
  suffixes - 需要检测的结尾字符串
  
  Returns:
  
  给定字符串是否以任何一个字符串结尾
- endWith
  
  public static boolean endWith(CharSequence text, CharSequence suffix, boolean ignoreCase)
  
  是否以指定字符串结尾如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
  
  Parameters:
  
  text - 被监测字符串
  
  suffix - 结尾字符串
  
  ignoreCase - 是否忽略大小写
  
  Returns:
  
  是否以指定字符串结尾
- endWith
  
  public static boolean endWith(CharSequence text, CharSequence suffix, boolean ignoreCase, boolean ignoreEquals)
  
  是否以指定字符串结尾如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
  
  Parameters:
  
  text - 被监测字符串
  
  suffix - 结尾字符串
  
  ignoreCase - 是否忽略大小写
  
  ignoreEquals - 是否忽略字符串相等的情况
  
  Returns:
  
  是否以指定字符串结尾
- contains
  
  public static boolean contains(CharSequence text, char args)
  
  指定字符是否在字符串中出现过
  
  Parameters:
  
  text - 字符串
  
  args - 被查找的字符
  
  Returns:
  
  是否包含
- contains
  
  public static boolean contains(CharSequence text, CharSequence args)
  
  指定字符串是否在字符串中出现过
  
  Parameters:
  
  text - 字符串
  
  args - 被查找的字符串
  
  Returns:
  
  是否包含
- containsAny
  
  public static boolean containsAny(CharSequence text, CharSequence... args)
  
  查找指定字符串是否包含指定字符串列表中的任意一个字符串
  
  Parameters:
  
  text - 指定字符串
  
  args - 需要检查的字符串数组
  
  Returns:
  
  是否包含任意一个字符串
- containsAny
  
  public static boolean containsAny(CharSequence text, char... args)
  
  查找指定字符串是否包含指定字符列表中的任意一个字符
  
  Parameters:
  
  text - 指定字符串
  
  args - 需要检查的字符数组
  
  Returns:
  
  是否包含任意一个字符
- containsOnly
  public static boolean containsOnly(CharSequence text, char... args)
  
  检查指定字符串中是否只包含给定的字符这里的containsOnly并不是必须全部给定的args都需要有，而是一个子集。 args是个限定集合，检查字符串中的字符是否在这个限定集合中。
  
  text 是 null，args 也是 null，直接返回 true
  
  text 是 null，args 不是 null，直接返回 true
  
  text 不是 null，args 是 null，直接返回 false
  
  Parameters:
  
  text - 字符串
  
  args - 检查的字符
  
  Returns:
  
  字符串含有非检查的字符，返回false
- containsBlank
  
  public static boolean containsBlank(CharSequence text)
  
  给定字符串是否包含空白符（空白符包括空格、制表符、全角空格和不间断空格）如果给定字符串为null或者""，则返回false
  
  Parameters:
  
  text - 字符串
  
  Returns:
  
  是否包含空白符
- getContainsString
  
  public static String getContainsString(CharSequence text, CharSequence... args)
  
  查找指定字符串是否包含指定字符串列表中的任意一个字符串，如果包含返回找到的第一个字符串
  
  Parameters:
  
  text - 指定字符串
  
  args - 需要检查的字符串数组
  
  Returns:
  
  被包含的第一个字符串
- containsIgnoreCase
  
  public static boolean containsIgnoreCase(CharSequence text, CharSequence args)
  
  是否包含特定字符，忽略大小写，如果给定两个参数都为null，返回true
  
  Parameters:
  
  text - 被检测字符串
  
  args - 被测试是否包含的字符串
  
  Returns:
  
  是否包含
- containsAnyIgnoreCase
  
  public static boolean containsAnyIgnoreCase(CharSequence text, CharSequence... args)
  
  查找指定字符串是否包含指定字符串列表中的任意一个字符串忽略大小写
  
  Parameters:
  
  text - 指定字符串
  
  args - 需要检查的字符串数组
  
  Returns:
  
  是否包含任意一个字符串
- getContainsStrIgnoreCase
  
  public static String getContainsStrIgnoreCase(CharSequence text, CharSequence... args)
  
  查找指定字符串是否包含指定字符串列表中的任意一个字符串，如果包含返回找到的第一个字符串忽略大小写
  
  Parameters:
  
  text - 指定字符串
  
  args - 需要检查的字符串数组
  
  Returns:
  
  被包含的第一个字符串
- containsAll
  
  public static boolean containsAll(CharSequence text, CharSequence... args)
  
  检查指定字符串中是否含给定的所有字符串
  
  Parameters:
  
  text - 字符串
  
  args - 检查的字符
  
  Returns:
  
  字符串含有非检查的字符，返回false
- indexOf
  
  public static int indexOf(CharSequence text, char args)
  
  指定范围内查找指定字符
  
  Parameters:
  
  text - 字符串
  
  args - 被查找的字符
  
  Returns:
  
  位置
- indexOf
  
  public static int indexOf(CharSequence text, char args, int start)
  
  指定范围内查找指定字符
  
  Parameters:
  
  text - 字符串
  
  args - 被查找的字符
  
  start - 起始位置，如果小于0，从0开始查找
  
  Returns:
  
  位置
- indexOf
  
  public static int indexOf(CharSequence text, char args, int start, int end)
  
  指定范围内查找指定字符
  
  Parameters:
  
  text - 字符串
  
  args - 被查找的字符
  
  start - 起始位置，如果小于0，从0开始查找
  
  end - 终止位置，如果超过str.length()则默认查找到字符串末尾
  
  Returns:
  
  位置
- indexOf
  
  public static int indexOf(CharSequence text, Predicate<Character> matcher, int start, int end)
  
  指定范围内查找指定字符
  
  Parameters:
  
  text - 字符串
  
  matcher - 被查找的字符匹配器
  
  start - 起始位置，如果小于0，从0开始查找
  
  end - 终止位置，如果超过str.length()则默认查找到字符串末尾
  
  Returns:
  
  位置
- indexOfIgnoreCase
  public static int indexOfIgnoreCase(CharSequence text, CharSequence args)
  
  指定范围内查找字符串，忽略大小写
  indexOfIgnoreCase(null, *, *) = -1 indexOfIgnoreCase(*, null, *) = -1 indexOfIgnoreCase("", "", 0) = 0 indexOfIgnoreCase("aabaabaa", "A", 0) = 0 indexOfIgnoreCase("aabaabaa", "B", 0) = 2 indexOfIgnoreCase("aabaabaa", "AB", 0) = 1 indexOfIgnoreCase("aabaabaa", "B", 3) = 5 indexOfIgnoreCase("aabaabaa", "B", 9) = -1 indexOfIgnoreCase("aabaabaa", "B", -1) = 2 indexOfIgnoreCase("aabaabaa", "", 2) = 2 indexOfIgnoreCase("abc", "", 9) = -1
  
  Parameters:
  
  text - 字符串
  
  args - 需要查找位置的字符串
  
  Returns:
  
  位置
- indexOfIgnoreCase
  public static int indexOfIgnoreCase(CharSequence text, CharSequence args, int fromIndex)
  
  指定范围内查找字符串
  indexOfIgnoreCase(null, *, *) = -1 indexOfIgnoreCase(*, null, *) = -1 indexOfIgnoreCase("", "", 0) = 0 indexOfIgnoreCase("aabaabaa", "A", 0) = 0 indexOfIgnoreCase("aabaabaa", "B", 0) = 2 indexOfIgnoreCase("aabaabaa", "AB", 0) = 1 indexOfIgnoreCase("aabaabaa", "B", 3) = 5 indexOfIgnoreCase("aabaabaa", "B", 9) = -1 indexOfIgnoreCase("aabaabaa", "B", -1) = 2 indexOfIgnoreCase("aabaabaa", "", 2) = 2 indexOfIgnoreCase("abc", "", 9) = -1
  
  Parameters:
  
  text - 字符串
  
  args - 需要查找位置的字符串
  
  fromIndex - 起始位置
  
  Returns:
  
  位置
- indexOf
  
  public static int indexOf(CharSequence text, CharSequence args, int from, boolean ignoreCase)
  
  指定范围内查找字符串
  
  Parameters:
  
  text - 字符串，空则返回-1
  
  args - 需要查找位置的字符串，空则返回-1
  
  from - 起始位置（包含）
  
  ignoreCase - 是否忽略大小写
  
  Returns:
  
  位置
- lastIndexOfIgnoreCase
  
  public static int lastIndexOfIgnoreCase(CharSequence text, CharSequence args)
  
  指定范围内查找字符串，忽略大小写
  
  Parameters:
  
  text - 字符串
  
  args - 需要查找位置的字符串
  
  Returns:
  
  位置
- lastIndexOfIgnoreCase
  
  public static int lastIndexOfIgnoreCase(CharSequence text, CharSequence args, int fromIndex)
  
  指定范围内查找字符串，忽略大小写 fromIndex 为搜索起始位置，从后往前计数
  
  Parameters:
  
  text - 字符串
  
  args - 需要查找位置的字符串
  
  fromIndex - 起始位置，从后往前计数
  
  Returns:
  
  位置
- lastIndexOf
  
  public static int lastIndexOf(CharSequence text, CharSequence args, int from, boolean ignoreCase)
  
  指定范围内查找字符串 fromIndex 为搜索起始位置，从后往前计数
  
  Parameters:
  
  text - 字符串
  
  args - 需要查找位置的字符串
  
  from - 起始位置，从后往前计数
  
  ignoreCase - 是否忽略大小写
  
  Returns:
  
  位置
- ordinalIndexOf
  public static int ordinalIndexOf(CharSequence text, CharSequence args, int ordinal)
  
  返回字符串 args 在字符串 text1 中第 ordinal 次出现的位置。
  如果 text1=null 或 args=null 或 ordinal≤0 则返回-1 此方法来自：Apache-Commons-Lang
  示例（*代表任意字符）：
  ordinalIndexOf(null, *, *) = -1 ordinalIndexOf(*, null, *) = -1 ordinalIndexOf("", "", *) = 0 ordinalIndexOf("aabaabaa", "a", 1) = 0 ordinalIndexOf("aabaabaa", "a", 2) = 1 ordinalIndexOf("aabaabaa", "b", 1) = 2 ordinalIndexOf("aabaabaa", "b", 2) = 5 ordinalIndexOf("aabaabaa", "ab", 1) = 1 ordinalIndexOf("aabaabaa", "ab", 2) = 4 ordinalIndexOf("aabaabaa", "", 1) = 0 ordinalIndexOf("aabaabaa", "", 2) = 0
  
  Parameters:
  
  text - 被检查的字符串，可以为null
  
  args - 被查找的字符串，可以为null
  
  ordinal - 第几次出现的位置
  
  Returns:
  
  查找到的位置
- removeAll
  
  public static String removeAll(CharSequence text, CharSequence args)
  
  移除字符串中所有给定字符串例：removeAll("aa-bb-cc-dd", "-") = aabbccdd
  
  Parameters:
  
  text - 字符串
  
  args - 被移除的字符串
  
  Returns:
  
  移除后的字符串
- removeAll
  
  public static String removeAll(CharSequence text, CharSequence... args)
  
  移除字符串中所有给定字符串，当某个字符串出现多次，则全部移除例：removeAny("aa-bb-cc-dd", "a", "b") = --cc-dd
  
  Parameters:
  
  text - 字符串
  
  args - 被移除的字符串
  
  Returns:
  
  移除后的字符串
- removeAll
  
  public static String removeAll(CharSequence text, char... chars)
  
  去除字符串中指定的多个字符，如有多个则全部去除
  
  Parameters:
  
  text - 字符串
  
  chars - 字符列表
  
  Returns:
  
  去除后的字符
- removeAllLineBreaks
  public static String removeAllLineBreaks(CharSequence text)
  
  去除所有换行符，包括：
  1. \r 1. \n
  
  Parameters:
  
  text - 字符串
  
  Returns:
  
  处理后的字符串
- removePreAndLowerFirst
  
  public static String removePreAndLowerFirst(CharSequence text, int preLength)
  
  去掉首部指定长度的字符串并将剩余字符串首字母小写例如：text1=setName, preLength=3 = return name
  
  Parameters:
  
  text - 被处理的字符串
  
  preLength - 去掉的长度
  
  Returns:
  
  处理后的字符串，不符合规范返回null
- removePreAndLowerFirst
  
  public static String removePreAndLowerFirst(CharSequence text, CharSequence prefix)
  
  去掉首部指定长度的字符串并将剩余字符串首字母小写例如：text1=setName, prefix=set = return name
  
  Parameters:
  
  text - 被处理的字符串
  
  prefix - 前缀
  
  Returns:
  
  处理后的字符串，不符合规范返回null
- removePrefix
  
  public static String removePrefix(CharSequence text, CharSequence prefix)
  
  去掉指定前缀
  
  Parameters:
  
  text - 字符串
  
  prefix - 前缀
  
  Returns:
  
  切掉后的字符串，若前缀不是 prefix，返回原字符串
- removePrefixIgnoreCase
  
  public static String removePrefixIgnoreCase(CharSequence text, CharSequence prefix)
  
  忽略大小写去掉指定前缀
  
  Parameters:
  
  text - 字符串
  
  prefix - 前缀
  
  Returns:
  
  切掉后的字符串，若前缀不是 prefix，返回原字符串
- removePrefix
  
  public static String removePrefix(CharSequence text, CharSequence prefix, boolean ignoreCase)
  
  去掉指定前缀
  
  Parameters:
  
  text - 字符串
  
  prefix - 前缀
  
  ignoreCase - 是否忽略大小写
  
  Returns:
  
  切掉后的字符串，若前缀不是 prefix，返回原字符串
- removeAllSuffix
  public static String removeAllSuffix(CharSequence text, 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:
  
  text - 字符串，空返回原字符串
  
  suffix - 后缀字符串，空返回原字符串
  
  Returns:
  
  去掉所有后缀的字符串，若后缀不是 suffix，返回原字符串
- removeSuffix
  
  public static String removeSuffix(CharSequence text, CharSequence suffix)
  
  去掉指定后缀
  
  Parameters:
  
  text - 字符串
  
  suffix - 后缀
  
  Returns:
  
  切掉后的字符串，若后缀不是 suffix，返回原字符串
- removeSufAndLowerFirst
  
  public static String removeSufAndLowerFirst(CharSequence text, CharSequence suffix)
  
  去掉指定后缀，并小写首字母
  
  Parameters:
  
  text - 字符串
  
  suffix - 后缀
  
  Returns:
  
  切掉后的字符串，若后缀不是 suffix，返回原字符串
- removeSuffixIgnoreCase
  
  public static String removeSuffixIgnoreCase(CharSequence text, CharSequence suffix)
  
  忽略大小写去掉指定后缀
  
  Parameters:
  
  text - 字符串
  
  suffix - 后缀
  
  Returns:
  
  切掉后的字符串，若后缀不是 suffix，返回原字符串
- cleanBlank
  
  public static String cleanBlank(CharSequence text)
  
  清理空白字符
  
  Parameters:
  
  text - 被清理的字符串
  
  Returns:
  
  清理后的字符串
- strip
  
  public static String strip(CharSequence text, CharSequence prefixOrSuffix)
  
  去除两边的指定字符串
  
  Parameters:
  
  text - 被处理的字符串
  
  prefixOrSuffix - 前缀或后缀
  
  Returns:
  
  处理后的字符串
- strip
  
  public static String strip(CharSequence text, CharSequence prefix, CharSequence suffix)
  
  去除两边的指定字符串两边字符如果存在，则去除，不存在不做处理
  
  Parameters:
  
  text - 被处理的字符串
  
  prefix - 前缀
  
  suffix - 后缀
  
  Returns:
  
  处理后的字符串
- strip
  public static String strip(CharSequence text, 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:
  
  text - 被处理的字符串
  
  prefix - 前缀
  
  suffix - 后缀
  
  ignoreCase - 是否忽略大小写
  
  Returns:
  
  处理后的字符串
- stripIgnoreCase
  
  public static String stripIgnoreCase(CharSequence text, CharSequence prefixOrSuffix)
  
  去除两边的指定字符串，忽略大小写
  
  Parameters:
  
  text - 被处理的字符串
  
  prefixOrSuffix - 前缀或后缀
  
  Returns:
  
  处理后的字符串
- stripIgnoreCase
  
  public static String stripIgnoreCase(CharSequence text, CharSequence prefix, CharSequence suffix)
  
  去除两边的指定字符串，忽略大小写
  
  Parameters:
  
  text - 被处理的字符串
  
  prefix - 前缀
  
  suffix - 后缀
  
  Returns:
  
  处理后的字符串
- addPrefixIfNot
  public static String addPrefixIfNot(CharSequence text, CharSequence prefix)
  
  如果给定字符串不是以prefix开头的，在开头补充 prefix
  
  Parameters:
  
  text - 字符串
  
  prefix - 前缀
  
  Returns:
  
  补充后的字符串
  
  See Also:
  
  prependIfMissing(CharSequence, CharSequence, CharSequence...)
- addSuffixIfNot
  public static String addSuffixIfNot(CharSequence text, CharSequence suffix)
  
  如果给定字符串不是以suffix结尾的，在尾部补充 suffix
  
  Parameters:
  
  text - 字符串
  
  suffix - 后缀
  
  Returns:
  
  补充后的字符串
  
  See Also:
  
  appendIfMissing(CharSequence, CharSequence, CharSequence...)
- cut
  
  public static String[] cut(CharSequence text, int partLength)
  
  将字符串切分为N等份
  
  Parameters:
  
  text - 字符串
  
  partLength - 每等份的长度
  
  Returns:
  
  切分后的数组
- sub
  public static String sub(CharSequence text, int fromIndexInclude, int toIndexExclude)
  
  改进JDK subString
  
  index从0开始计算，最后一个字符为-1，即sub("miaixz", 0, -1)得到"miaixz"
  
  如果from和to位置一样，返回 ""
  
  如果from或to为负数，则按照length从后向前数位置，如果绝对值大于字符串长度，则from归到0，to归到length
  
  如果经过修正的index中from大于to，则互换from和to，如abcdefgh 2 3 =》 c，abcdefgh 2 -3 =》 cde
  
  Parameters:
  
  text - String
  
  fromIndexInclude - 开始的index（包括）
  
  toIndexExclude - 结束的index（不包括）
  
  Returns:
  
  字串
- subByCodePoint
  
  public static String subByCodePoint(CharSequence text, int fromIndex, int toIndex)
  
  通过CodePoint截取字符串，可以截断Emoji
  
  Parameters:
  
  text - String
  
  fromIndex - 开始的index（包括）
  
  toIndex - 结束的index（不包括）
  
  Returns:
  
  字串
- subPreGbk
  
  public static String subPreGbk(CharSequence text, int len, CharSequence suffix)
  
  截取部分字符串，这里一个汉字的长度认为是2
  
  Parameters:
  
  text - 字符串
  
  len - bytes切割到的位置（包含）
  
  suffix - 切割后加上后缀
  
  Returns:
  
  切割后的字符串
- subPreGbk
  
  public static String subPreGbk(CharSequence text, int len, boolean halfUp)
  
  截取部分字符串，这里一个汉字的长度认为是2 可以自定义halfUp，如len为10，如果截取后最后一个字符是半个字符，true表示保留，则长度是11，否则长度9
  
  Parameters:
  
  text - 字符串
  
  len - bytes切割到的位置（包含）
  
  halfUp - 遇到截取一半的GBK字符，是否保留。
  
  Returns:
  
  切割后的字符串
- subPre
  public static String subPre(CharSequence text, int toIndexExclude)
  
  切割指定位置之前部分的字符串安全的subString,允许：string为null，允许string长度小于toIndexExclude长度
  Assert.assertEquals(subPre(null, 3), null); Assert.assertEquals(subPre("ab", 3), "ab"); Assert.assertEquals(subPre("abc", 3), "abc"); Assert.assertEquals(subPre("abcd", 3), "abc"); Assert.assertEquals(subPre("abcd", -3), "a"); Assert.assertEquals(subPre("ab", 3), "ab");
  
  Parameters:
  
  text - 字符串
  
  toIndexExclude - 切割到的位置（不包括）
  
  Returns:
  
  切割后的剩余的前半部分字符串
- subSuf
  public static String subSuf(CharSequence text, int fromIndex)
  
  切割指定位置之后部分的字符串
  
  fromIndex为0或字符串为空，返回原字符串
  
  fromIndex大于字符串本身的长度，返回""
  
  fromIndex支持负数，-1表示length-1
  
  Parameters:
  
  text - 字符串
  
  fromIndex - 切割开始的位置（包括）
  
  Returns:
  
  切割后后剩余的后半部分字符串
- subSufByLength
  public static String subSufByLength(CharSequence text, int length)
  
  切割指定长度的后部分的字符串
  subSufByLength("abcde", 3) = "cde" subSufByLength("abcde", 0) = "" subSufByLength("abcde", -5) = "" subSufByLength("abcde", -1) = "" subSufByLength("abcde", 5) = "abcde" subSufByLength("abcde", 10) = "abcde" subSufByLength(null, 3) = null
  
  Parameters:
  
  text - 字符串
  
  length - 切割长度
  
  Returns:
  
  切割后后剩余的后半部分字符串
- subByLength
  public static String subByLength(String input, int fromIndex, int length)
  
  截取字符串,从指定位置开始,截取指定长度的字符串当fromIndex为正数时，这个index指的是插空位置，如下：
  0 1 2 3 4 A B C D
  当fromIndex为负数时，为反向插空位置，其中-1表示最后一个字符之前的位置：
  -3 -2 -1 length A B C D
  
  Parameters:
  
  input - 原始字符串
  
  fromIndex - 开始的index,包括，可以为负数
  
  length - 要截取的长度
  
  Returns:
  
  截取后的字符串
- subBefore
  public static String subBefore(CharSequence text, CharSequence separator, boolean isLastSeparator)
  
  截取分隔字符串之前的字符串，不包括分隔字符串如果给定的字符串为空串（null或""）或者分隔字符串为null，返回原字符串如果分隔字符串为空串""，则返回空串，如果分隔字符串未找到，返回原字符串，举例如下：
  subBefore(null, *, false) = null subBefore("", *, false) = "" subBefore("abc", "a", false) = "" subBefore("abcba", "b", false) = "a" subBefore("abc", "c", false) = "ab" subBefore("abc", "d", false) = "abc" subBefore("abc", "", false) = "" subBefore("abc", null, false) = "abc"
  
  Parameters:
  
  text - 被查找的字符串
  
  separator - 分隔字符串（不包括）
  
  isLastSeparator - 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
  
  Returns:
  
  切割后的字符串
- subBefore
  public static String subBefore(CharSequence text, char separator, boolean isLastSeparator)
  
  截取分隔字符串之前的字符串，不包括分隔字符串如果给定的字符串为空串（null或""）或者分隔字符串为null，返回原字符串如果分隔字符串未找到，返回原字符串，举例如下：
  subBefore(null, *, false) = null subBefore("", *, false) = "" subBefore("abc", 'a', false) = "" subBefore("abcba", 'b', false) = "a" subBefore("abc", 'c', false) = "ab" subBefore("abc", 'd', false) = "abc"
  
  Parameters:
  
  text - 被查找的字符串
  
  separator - 分隔字符串（不包括）
  
  isLastSeparator - 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
  
  Returns:
  
  切割后的字符串
- subAfter
  public static String subAfter(CharSequence text, CharSequence separator, boolean isLastSeparator)
  
  截取分隔字符串之后的字符串，不包括分隔字符串如果给定的字符串为空串（null或""），返回原字符串如果分隔字符串为空串（null或""），则返回空串，如果分隔字符串未找到，返回空串，举例如下：
  subAfter(null, *, false) = null subAfter("", *, false) = "" subAfter(*, null, false) = "" subAfter("abc", "a", false) = "ciphers" subAfter("abcba", "b", false) = "cba" subAfter("abc", "c", false) = "" subAfter("abc", "d", false) = "" subAfter("abc", "", false) = "abc"
  
  Parameters:
  
  text - 被查找的字符串
  
  separator - 分隔字符串（不包括）
  
  isLastSeparator - 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
  
  Returns:
  
  切割后的字符串
- subAfter
  public static String subAfter(CharSequence text, char separator, boolean isLastSeparator)
  
  截取分隔字符串之后的字符串，不包括分隔字符串如果给定的字符串为空串（null或""），返回原字符串如果分隔字符串为空串（null或""），则返回空串，如果分隔字符串未找到，返回空串，举例如下：
  subAfter(null, *, false) = null subAfter("", *, false) = "" subAfter("abc", 'a', false) = "ciphers" subAfter("abcba", 'b', false) = "cba" subAfter("abc", 'c', false) = "" subAfter("abc", 'd', false) = ""
  
  Parameters:
  
  text - 被查找的字符串
  
  separator - 分隔字符串（不包括）
  
  isLastSeparator - 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
  
  Returns:
  
  切割后的字符串
- subBetween
  public static String subBetween(CharSequence text, CharSequence before, CharSequence after)
  
  截取指定字符串中间部分，不包括标识字符串
  subBetween("wx[b]yz", "[", "]") = "b" subBetween(null, *, *) = null subBetween(*, null, *) = null subBetween(*, *, null) = null subBetween("", "", "") = "" subBetween("", "", "]") = null subBetween("", "[", "]") = null subBetween("yabcz", "", "") = "" subBetween("yabcz", "y", "z") = "abc" subBetween("yabczyabcz", "y", "z") = "abc"
  
  Parameters:
  
  text - 被切割的字符串
  
  before - 截取开始的字符串标识
  
  after - 截取到的字符串标识
  
  Returns:
  
  截取后的字符串
- subBetween
  public static String subBetween(CharSequence text, CharSequence beforeAndAfter)
  
  截取指定字符串中间部分，不包括标识字符串
  subBetween(null, *) = null subBetween("", "") = "" subBetween("", "tag") = null subBetween("tagabctag", null) = null subBetween("tagabctag", "") = "" subBetween("tagabctag", "tag") = "abc"
  
  Parameters:
  
  text - 被切割的字符串
  
  beforeAndAfter - 截取开始和结束的字符串标识
  
  Returns:
  
  截取后的字符串
- subBetweenAll
  public static String[] subBetweenAll(CharSequence text, CharSequence prefix, CharSequence suffix)
  
  截取指定字符串多段中间部分，不包括标识字符串
  subBetweenAll("wx[b]y[z]", "[", "]") = ["b","z"] subBetweenAll(null, *, *) = [] subBetweenAll(*, null, *) = [] subBetweenAll(*, *, null) = [] subBetweenAll("", "", "") = [] subBetweenAll("", "", "]") = [] subBetweenAll("", "[", "]") = [] subBetweenAll("yabcz", "", "") = [] subBetweenAll("yabcz", "y", "z") = ["abc"] subBetweenAll("yabczyabcz", "y", "z") = ["abc","abc"] subBetweenAll("[yabc[zy]abcz]", "[", "]"); = ["zy"] 重叠时只截取内部，
  
  Parameters:
  
  text - 被切割的字符串
  
  prefix - 截取开始的字符串标识
  
  suffix - 截取到的字符串标识
  
  Returns:
  
  截取后的字符串
- subBetweenAll
  public static String[] subBetweenAll(CharSequence text, CharSequence prefixAndSuffix)
  
  截取指定字符串多段中间部分，不包括标识字符串
  subBetweenAll(null, *) = [] subBetweenAll(*, null) = [] subBetweenAll(*, *) = [] subBetweenAll("", "") = [] subBetweenAll("", "#") = [] subBetweenAll("gotanks", "") = [] subBetweenAll("#gotanks#", "#") = ["gotanks"] subBetweenAll("#hello# #world#!", "#") = ["hello", "world"] subBetweenAll("#hello# world#!", "#"); = ["hello"]
  
  Parameters:
  
  text - 被切割的字符串
  
  prefixAndSuffix - 截取开始和结束的字符串标识
  
  Returns:
  
  截取后的字符串
- repeat
  public static String repeat(char c, int count)
  
  重复某个字符
  repeat('e', 0) = "" repeat('e', 3) = "eee" repeat('e', -2) = ""
  
  Parameters:
  
  c - 被重复的字符
  
  count - 重复的数目，如果小于等于0则返回""
  
  Returns:
  
  重复字符字符串
- repeat
  
  public static String repeat(CharSequence text, int count)
  
  重复某个字符串
  
  Parameters:
  
  text - 被重复的字符
  
  count - 重复的数目
  
  Returns:
  
  重复字符字符串
- repeatByLength
  public static String repeatByLength(CharSequence text, int padLen)
  
  重复某个字符串到指定长度
  
  如果指定长度非指定字符串的整数倍，截断到固定长度
  
  如果指定长度小于字符串本身的长度，截断之
  
  Parameters:
  
  text - 被重复的字符
  
  padLen - 指定长度
  
  Returns:
  
  重复字符字符串
- repeatAndJoin
  public static String repeatAndJoin(CharSequence text, int count, CharSequence delimiter)
  
  重复某个字符串并通过分界符连接
  repeatAndJoin("?", 5, ",") = "?,?,?,?,?" repeatAndJoin("?", 0, ",") = "" repeatAndJoin("?", 5, null) = "?????"
  
  Parameters:
  
  text - 被重复的字符串
  
  count - 数量
  
  delimiter - 分界符
  
  Returns:
  
  连接后的字符串
- equals
  public static boolean equals(CharSequence text1, CharSequence text2)
  
  比较两个字符串（大小写敏感）。
  equals(null, null) = true equals(null, "abc") = false equals("abc", null) = false equals("abc", "abc") = true equals("abc", "ABC") = false
  
  Parameters:
  
  text1 - 要比较的字符串1
  
  text2 - 要比较的字符串2
  
  Returns:
  
  如果两个字符串相同，或者都是null，则返回true
- equalsIgnoreCase
  public static boolean equalsIgnoreCase(CharSequence text1, CharSequence text2)
  
  比较两个字符串（大小写不敏感）。
  equalsIgnoreCase(null, null) = true equalsIgnoreCase(null, "abc") = false equalsIgnoreCase("abc", null) = false equalsIgnoreCase("abc", "abc") = true equalsIgnoreCase("abc", "ABC") = true
  
  Parameters:
  
  text1 - 要比较的字符串1
  
  text2 - 要比较的字符串2
  
  Returns:
  
  如果两个字符串相同，或者都是null，则返回true
- equals
  public static boolean equals(CharSequence text1, CharSequence text2, boolean ignoreCase)
  
  比较两个字符串是否相等，规则如下
  
  str1和str2都为null
  
  忽略大小写使用String.equalsIgnoreCase(String)判断相等
  
  不忽略大小写使用String.contentEquals(CharSequence)判断相等
  
  Parameters:
  
  text1 - 要比较的字符串1
  
  text2 - 要比较的字符串2
  
  ignoreCase - 是否忽略大小写
  
  Returns:
  
  如果两个字符串相同，或者都是null，则返回true
- equalsAnyIgnoreCase
  
  public static boolean equalsAnyIgnoreCase(CharSequence text1, CharSequence... strs)
  
  给定字符串是否与提供的中任意一个字符串相同（忽略大小写），相同则返回true，没有相同的返回false 如果参与比对的字符串列表为空，返回false
  
  Parameters:
  
  text1 - 给定需要检查的字符串
  
  strs - 需要参与比对的字符串列表
  
  Returns:
  
  是否相同
- equalsAny
  
  public static boolean equalsAny(CharSequence text1, CharSequence... strs)
  
  给定字符串是否与提供的中任一字符串相同，相同则返回true，没有相同的返回false 如果参与比对的字符串列表为空，返回false
  
  Parameters:
  
  text1 - 给定需要检查的字符串
  
  strs - 需要参与比对的字符串列表
  
  Returns:
  
  是否相同
- equalsAny
  
  public static boolean equalsAny(CharSequence text, boolean ignoreCase, CharSequence... args)
  
  给定字符串是否与提供的中任一字符串相同，相同则返回true，没有相同的返回false 如果参与比对的字符串列表为空，返回false
  
  Parameters:
  
  text - 给定需要检查的字符串
  
  ignoreCase - 是否忽略大小写
  
  args - 需要参与比对的字符串列表
  
  Returns:
  
  是否相同
- equalsCharAt
  
  public static boolean equalsCharAt(CharSequence text, int position, char c)
  
  字符串指定位置的字符是否与给定字符相同如果字符串为null，返回false 如果给定的位置大于字符串长度，返回false 如果给定的位置小于0，返回false
  
  Parameters:
  
  text - 字符串
  
  position - 位置
  
  c - 需要对比的字符
  
  Returns:
  
  字符串指定位置的字符是否与给定字符相同
- isSubEquals
  public static boolean isSubEquals(CharSequence text1, int offset1, CharSequence text2, boolean ignoreCase)
  
  截取第一个字串的部分字符，与第二个字符串比较（长度一致），判断截取的子串是否相同任意一个字符串为null返回false
  
  Parameters:
  
  text1 - 第一个字符串
  
  offset1 - 第一个字符串开始的位置
  
  text2 - 第二个字符串
  
  ignoreCase - 是否忽略大小写
  
  Returns:
  
  子串是否相同
  
  See Also:
  
  String.regionMatches(boolean, int, String, int, int)
- isSubEquals
  public static boolean isSubEquals(CharSequence text1, int offset1, CharSequence text2, int offset2, int length, boolean ignoreCase)
  
  截取两个字符串的不同部分（长度一致），判断截取的子串是否相同任意一个字符串为null返回false
  
  Parameters:
  
  text1 - 第一个字符串
  
  offset1 - 第一个字符串开始的位置
  
  text2 - 第二个字符串
  
  offset2 - 第二个字符串开始的位置
  
  length - 截取长度
  
  ignoreCase - 是否忽略大小写
  
  Returns:
  
  子串是否相同
  
  See Also:
  
  String.regionMatches(boolean, int, String, int, int)
- 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:
  
  格式化后的文本
- wrap
  
  public static String wrap(CharSequence text, CharSequence prefixAndSuffix)
  
  包装指定字符串当前缀和后缀一致时使用此方法
  
  Parameters:
  
  text - 被包装的字符串
  
  prefixAndSuffix - 前缀和后缀
  
  Returns:
  
  包装后的字符串
- wrap
  
  public static String wrap(CharSequence text, CharSequence prefix, CharSequence suffix)
  
  包装指定字符串
  
  Parameters:
  
  text - 被包装的字符串
  
  prefix - 前缀
  
  suffix - 后缀
  
  Returns:
  
  包装后的字符串
- wrap
  
  public static String wrap(CharSequence text, char prefix, char suffix)
  
  包装指定字符串
  
  Parameters:
  
  text - 被包装的字符串
  
  prefix - 前缀
  
  suffix - 后缀
  
  Returns:
  
  包装后的字符串
- wrapAllWithPair
  
  public static String[] wrapAllWithPair(CharSequence prefixAndSuffix, CharSequence... strs)
  
  使用单个字符包装多个字符串
  
  Parameters:
  
  prefixAndSuffix - 前缀和后缀
  
  strs - 多个字符串
  
  Returns:
  
  包装的字符串数组
- wrapAll
  
  public static String[] wrapAll(CharSequence prefix, CharSequence suffix, CharSequence... strs)
  
  包装多个字符串
  
  Parameters:
  
  prefix - 前缀
  
  suffix - 后缀
  
  strs - 多个字符串
  
  Returns:
  
  包装的字符串数组
- wrapIfMissing
  
  public static String wrapIfMissing(CharSequence text, CharSequence prefix, CharSequence suffix)
  
  包装指定字符串，如果前缀或后缀已经包含对应的字符串，则不再包装
  
  Parameters:
  
  text - 被包装的字符串
  
  prefix - 前缀
  
  suffix - 后缀
  
  Returns:
  
  包装后的字符串
- wrapAllWithPairIfMissing
  
  public static String[] wrapAllWithPairIfMissing(CharSequence prefixAndSuffix, CharSequence... strs)
  
  使用成对的字符包装多个字符串，如果已经包装，则不再包装
  
  Parameters:
  
  prefixAndSuffix - 前缀和后缀
  
  strs - 多个字符串
  
  Returns:
  
  包装的字符串数组
- wrapAllIfMissing
  
  public static String[] wrapAllIfMissing(CharSequence prefix, CharSequence suffix, CharSequence... strs)
  
  包装多个字符串，如果已经包装，则不再包装
  
  Parameters:
  
  prefix - 前缀
  
  suffix - 后缀
  
  strs - 多个字符串
  
  Returns:
  
  包装的字符串数组
- unWrap
  
  public static String unWrap(CharSequence text, String prefix, String suffix)
  
  去掉字符包装，如果未被包装则返回原字符串此方法要求prefix和suffix都存在，如果只有一个，不做去除。
  
  Parameters:
  
  text - 字符串
  
  prefix - 前置字符串
  
  suffix - 后置字符串
  
  Returns:
  
  去掉包装字符的字符串
- unWrap
  
  public static String unWrap(CharSequence text, char prefix, char suffix)
  
  去掉字符包装，如果未被包装则返回原字符串
  
  Parameters:
  
  text - 字符串
  
  prefix - 前置字符
  
  suffix - 后置字符
  
  Returns:
  
  去掉包装字符的字符串
- unWrap
  
  public static String unWrap(CharSequence text, char prefixAndSuffix)
  
  去掉字符包装，如果未被包装则返回原字符串
  
  Parameters:
  
  text - 字符串
  
  prefixAndSuffix - 前置和后置字符
  
  Returns:
  
  去掉包装字符的字符串
- isWrap
  
  public static boolean isWrap(CharSequence text, CharSequence prefix, CharSequence suffix)
  
  指定字符串是否被包装
  
  Parameters:
  
  text - 字符串
  
  prefix - 前缀
  
  suffix - 后缀
  
  Returns:
  
  是否被包装
- isWrap
  
  public static boolean isWrap(CharSequence text, String wrapper)
  
  指定字符串是否被同一字符包装（前后都有这些字符串）
  
  Parameters:
  
  text - 字符串
  
  wrapper - 包装字符串
  
  Returns:
  
  是否被包装
- isWrap
  
  public static boolean isWrap(CharSequence text, char wrapper)
  
  指定字符串是否被同一字符包装（前后都有这些字符串）
  
  Parameters:
  
  text - 字符串
  
  wrapper - 包装字符
  
  Returns:
  
  是否被包装
- isWrap
  
  public static boolean isWrap(CharSequence text, char prefixChar, char suffixChar)
  
  指定字符串是否被包装
  
  Parameters:
  
  text - 字符串
  
  prefixChar - 前缀
  
  suffixChar - 后缀
  
  Returns:
  
  是否被包装
- left
  public static String left(String text, int len)
  
  获取字符串中最左边的len字符
  left(null, *) = null left(*, -ve) = "" left("", *) = "" left("abc", 0) = "" left("abc", 2) = "ab" left("abc", 4) = "abc"
  
  Parameters:
  
  text - 要从中获取字符的字符串可能为空
  
  len - 所需字符串的长度
  
  Returns:
  
  最左边的字符，null如果输入为空字符串
- right
  public static String right(String text, int len)
  
  获取字符串中最右边的len字符
  right(null, *) = null right(*, -ve) = "" right("", *) = "" right("abc", 0) = "" right("abc", 2) = "bc" right("abc", 4) = "abc"
  
  Parameters:
  
  text - 要从中获取字符的字符串可能为空
  
  len - 所需字符串的长度
  
  Returns:
  
  最右边的字符，null如果输入为空字符串
- mid
  public static String mid(String text, int pos, int len)
  
  从字符串中间获取len字符.
  mid(null, *, *) = null mid(*, *, -ve) = "" mid("", 0, *) = "" mid("abc", 0, 2) = "ab" mid("abc", 0, 4) = "abc" mid("abc", 2, 4) = "c" mid("abc", 4, 2) = "" mid("abc", -2, 2) = "ab"
  
  Parameters:
  
  text - 要从中获取字符的字符串可能为空
  
  pos - 开始时的位置，负为零
  
  len - 所需字符串的长度
  
  Returns:
  
  中间的字符，null如果输入为空字符串
- padPre
  public static String padPre(CharSequence text, int length, CharSequence padStr)
  
  补充字符串以满足指定长度，如果提供的字符串大于指定长度，截断之同：leftPad (org.apache.commons.lang3.leftPad)
  padPre(null, *, *);//null padPre("1", 3, "ABC");//"AB1" padPre("123", 2, "ABC");//"12" padPre("1039", -1, "0");//"103"
  
  Parameters:
  
  text - 字符串
  
  length - 长度
  
  padStr - 补充的字符
  
  Returns:
  
  补充后的字符串
- padPre
  public static String padPre(CharSequence text, int length, char padChar)
  
  补充字符串以满足最小长度，如果提供的字符串大于指定长度，截断之同：leftPad (org.apache.commons.lang3.leftPad)
  padPre(null, *, *);//null padPre("1", 3, '0');//"001" padPre("123", 2, '0');//"12"
  
  Parameters:
  
  text - 字符串
  
  length - 长度
  
  padChar - 补充的字符
  
  Returns:
  
  补充后的字符串
- padAfter
  public static String padAfter(CharSequence text, int length, char padChar)
  
  补充字符串以满足最小长度，如果提供的字符串大于指定长度，截断之
  padAfter(null, *, *);//null padAfter("1", 3, '0');//"100" padAfter("123", 2, '0');//"23" padAfter("123", -1, '0')//"" 空串
  
  Parameters:
  
  text - 字符串，如果为null，直接返回null
  
  length - 长度
  
  padChar - 补充的字符
  
  Returns:
  
  补充后的字符串
- padAfter
  public static String padAfter(CharSequence text, int length, CharSequence padStr)
  
  补充字符串以满足最小长度
  padAfter(null, *, *);//null padAfter("1", 3, "ABC");//"1AB" padAfter("123", 2, "ABC");//"23"
  
  Parameters:
  
  text - 字符串，如果为null，直接返回null
  
  length - 长度
  
  padStr - 补充的字符
  
  Returns:
  
  补充后的字符串
- center
  public static String center(CharSequence text, int size)
  
  居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串
  center(null, *) = null center("", 4) = " " center("ab", -1) = "ab" center("ab", 4) = " ab " center("abcd", 2) = "abcd" center("a", 4) = " a "
  
  Parameters:
  
  text - 字符串
  
  size - 指定长度
  
  Returns:
  
  补充后的字符串
- center
  public static String center(CharSequence text, int size, char padChar)
  
  居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串
  center(null, *, *) = null center("", 4, ' ') = " " center("ab", -1, ' ') = "ab" center("ab", 4, ' ') = " ab " center("abcd", 2, ' ') = "abcd" center("a", 4, ' ') = " a " center("a", 4, 'y') = "yayy" center("abc", 7, ' ') = " abc "
  
  Parameters:
  
  text - 字符串
  
  size - 指定长度
  
  padChar - 两边补充的字符
  
  Returns:
  
  补充后的字符串
- center
  public static String center(CharSequence text, int size, CharSequence padStr)
  
  居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串
  center(null, *, *) = null center("", 4, " ") = " " center("ab", -1, " ") = "ab" center("ab", 4, " ") = " ab " center("abcd", 2, " ") = "abcd" center("a", 4, " ") = " a " center("a", 4, "yz") = "yayz" center("abc", 7, null) = " abc " center("abc", 7, "") = " abc "
  
  Parameters:
  
  text - 字符串
  
  size - 指定长度
  
  padStr - 两边补充的字符串
  
  Returns:
  
  补充后的字符串
- count
  public static int count(CharSequence content, CharSequence strForSearch)
  
  统计指定内容中包含指定字符串的数量参数为 null 或者 "" 返回 0.
  count(null, *) = 0 count("", *) = 0 count("abba", null) = 0 count("abba", "") = 0 count("abba", "a") = 2 count("abba", "ab") = 1 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 text1, CharSequence text2, boolean nullIsLess)
  
  比较两个字符串，用于排序
  compare(null, null, *) = 0 compare(null , "a", true) < 0 compare(null , "a", false) > 0 compare("a", null, true) > 0 compare("a", null, false) < 0 compare("abc", "abc", *) = 0 compare("a", "b", *) < 0 compare("b", "a", *) > 0 compare("a", "B", *) > 0 compare("ab", "abc", *) < 0
  
  Parameters:
  
  text1 - 字符串1
  
  text2 - 字符串2
  
  nullIsLess - null 值是否排在前（null是否小于非空值）
  
  Returns:
  
  排序值。负数：text1 < text2，正数：text1 > text2, 0：text1 == text2
- compareIgnoreCase
  public static int compareIgnoreCase(CharSequence text1, CharSequence text2, boolean nullIsLess)
  
  比较两个字符串，用于排序，大小写不敏感
  compareIgnoreCase(null, null, *) = 0 compareIgnoreCase(null , "a", true) < 0 compareIgnoreCase(null , "a", false) > 0 compareIgnoreCase("a", null, true) > 0 compareIgnoreCase("a", null, false) < 0 compareIgnoreCase("abc", "abc", *) = 0 compareIgnoreCase("abc", "ABC", *) = 0 compareIgnoreCase("a", "b", *) < 0 compareIgnoreCase("b", "a", *) > 0 compareIgnoreCase("a", "B", *) < 0 compareIgnoreCase("A", "b", *) < 0 compareIgnoreCase("ab", "abc", *) < 0
  
  Parameters:
  
  text1 - 字符串1
  
  text2 - 字符串2
  
  nullIsLess - null 值是否排在前（null是否小于非空值）
  
  Returns:
  
  排序值。负数：text1 < text2，正数：text1 > text2, 0：text1 == text2
- compareVersion
  public static int compareVersion(CharSequence version1, CharSequence version2)
  
  比较两个版本 null版本排在最小：即：
  compareVersion(null, "v1") < 0 compareVersion("v1", "v1") = 0 compareVersion(null, null) = 0 compareVersion("v1", null) > 0 compareVersion("1.0.0", "1.0.2") < 0 compareVersion("1.0.2", "1.0.2a") < 0 compareVersion("1.13.0", "1.12.1c") > 0 compareVersion("V0.0.20170102", "V0.0.20170101") > 0
  
  Parameters:
  
  version1 - 版本1
  
  version2 - 版本2
  
  Returns:
  
  排序值。负数：version1 < version2，正数：version1 > version2, 0：version1 == version2
- appendIfMissing
  
  public static String appendIfMissing(CharSequence text, CharSequence suffix, CharSequence... suffixes)
  
  如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串不忽略大小写
  
  Parameters:
  
  text - 被检查的字符串
  
  suffix - 需要添加到结尾的字符串
  
  suffixes - 需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加
  
  Returns:
  
  如果已经结尾，返回原字符串，否则返回添加结尾的字符串
- appendIfMissingIgnoreCase
  
  public static String appendIfMissingIgnoreCase(CharSequence text, CharSequence suffix, CharSequence... suffixes)
  
  如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串忽略大小写
  
  Parameters:
  
  text - 被检查的字符串
  
  suffix - 需要添加到结尾的字符串
  
  suffixes - 需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加
  
  Returns:
  
  如果已经结尾，返回原字符串，否则返回添加结尾的字符串
- appendIfMissing
  
  public static String appendIfMissing(CharSequence text, CharSequence suffix, boolean ignoreCase, CharSequence... testSuffixes)
  
  如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串
  
  Parameters:
  
  text - 被检查的字符串
  
  suffix - 需要添加到结尾的字符串，不参与检查匹配
  
  ignoreCase - 检查结尾时是否忽略大小写
  
  testSuffixes - 需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加
  
  Returns:
  
  如果已经结尾，返回原字符串，否则返回添加结尾的字符串
- prependIfMissing
  
  public static String prependIfMissing(CharSequence text, CharSequence prefix, CharSequence... prefixes)
  
  如果给定字符串不是以给定的一个或多个字符串为开头，则在前面添加起始字符串不忽略大小写
  
  Parameters:
  
  text - 被检查的字符串
  
  prefix - 需要添加到首部的字符串
  
  prefixes - 需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加
  
  Returns:
  
  如果已经结尾，返回原字符串，否则返回添加结尾的字符串
- prependIfMissingIgnoreCase
  
  public static String prependIfMissingIgnoreCase(CharSequence text, CharSequence prefix, CharSequence... prefixes)
  
  如果给定字符串不是以给定的一个或多个字符串为开头，则在首部添加起始字符串忽略大小写
  
  Parameters:
  
  text - 被检查的字符串
  
  prefix - 需要添加到首部的字符串
  
  prefixes - 需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加
  
  Returns:
  
  如果已经结尾，返回原字符串，否则返回添加结尾的字符串
- prependIfMissing
  
  public static String prependIfMissing(CharSequence text, CharSequence prefix, boolean ignoreCase, CharSequence... prefixes)
  
  如果给定字符串不是以给定的一个或多个字符串为开头，则在首部添加起始字符串
  
  Parameters:
  
  text - 被检查的字符串
  
  prefix - 需要添加到首部的字符串
  
  ignoreCase - 检查结尾时是否忽略大小写
  
  prefixes - 需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加
  
  Returns:
  
  如果已经结尾，返回原字符串，否则返回添加结尾的字符串
- replaceFirst
  
  public static String replaceFirst(CharSequence text, CharSequence searchStr, CharSequence replacedStr, boolean ignoreCase)
  
  替换字符串中第一个指定字符串
  
  Parameters:
  
  text - 字符串
  
  searchStr - 被查找的字符串
  
  replacedStr - 被替换的字符串
  
  ignoreCase - 是否忽略大小写
  
  Returns:
  
  替换后的字符串
- replaceLast
  
  public static String replaceLast(CharSequence text, CharSequence searchStr, CharSequence replacedStr, boolean ignoreCase)
  
  替换字符串中最后一个指定字符串
  
  Parameters:
  
  text - 字符串
  
  searchStr - 被查找的字符串
  
  replacedStr - 被替换的字符串
  
  ignoreCase - 是否忽略大小写
  
  Returns:
  
  替换后的字符串
- replaceIgnoreCase
  
  public static String replaceIgnoreCase(CharSequence text, CharSequence searchStr, CharSequence replacement)
  
  替换字符串中的指定字符串，忽略大小写
  
  Parameters:
  
  text - 字符串
  
  searchStr - 被查找的字符串
  
  replacement - 被替换的字符串
  
  Returns:
  
  替换后的字符串
- replace
  
  public static String replace(CharSequence text, CharSequence searchStr, CharSequence replacement)
  
  替换字符串中的指定字符串
  
  Parameters:
  
  text - 字符串
  
  searchStr - 被查找的字符串
  
  replacement - 被替换的字符串
  
  Returns:
  
  替换后的字符串
- replace
  
  public static String replace(CharSequence text, CharSequence searchStr, CharSequence replacement, boolean ignoreCase)
  
  替换字符串中的指定字符串
  
  Parameters:
  
  text - 字符串
  
  searchStr - 被查找的字符串
  
  replacement - 被替换的字符串
  
  ignoreCase - 是否忽略大小写
  
  Returns:
  
  替换后的字符串
- replace
  
  public static String replace(CharSequence text, int fromIndex, CharSequence searchStr, CharSequence replacement, boolean ignoreCase)
  
  替换字符串中的指定字符串如果指定字符串出现多次，则全部替换
  
  Parameters:
  
  text - 字符串
  
  fromIndex - 开始位置（包括）
  
  searchStr - 被查找的字符串
  
  replacement - 被替换的字符串
  
  ignoreCase - 是否忽略大小写
  
  Returns:
  
  替换后的字符串
- replaceByCodePoint
  
  public static String replaceByCodePoint(CharSequence text, int beginInclude, int endExclude, char replacedChar)
  
  替换指定字符串的指定区间内字符为固定字符，替换后字符串长度不变如替换的区间长度为10，则替换后的字符重复10次此方法使用String.codePoints()完成拆分替换
  
  Parameters:
  
  text - 字符串
  
  beginInclude - 开始位置（包含）
  
  endExclude - 结束位置（不包含）
  
  replacedChar - 被替换的字符
  
  Returns:
  
  替换后的字符串
- replaceByCodePoint
  
  public static String replaceByCodePoint(CharSequence text, int beginInclude, int endExclude, CharSequence replacedStr)
  
  替换指定字符串的指定区间内字符为指定字符串，字符串只重复一次此方法使用String.codePoints()完成拆分替换
  
  Parameters:
  
  text - 字符串
  
  beginInclude - 开始位置（包含）
  
  endExclude - 结束位置（不包含）
  
  replacedStr - 被替换的字符串
  
  Returns:
  
  替换后的字符串
- replace
  public static String replace(CharSequence text, Pattern pattern, FunctionX<Matcher,String> replaceFun)
  
  替换所有正则匹配的文本，并使用自定义函数决定如何替换 replaceFun可以提取出匹配到的内容的不同部分，然后经过重新处理、组装变成新的内容放回原位。
  replace(this.content, "(\\d+)", parameters -> "-" + parameters.group(1) + "-") // 结果为："ZZZaaabbbccc中文-1234-"
  
  Parameters:
  
  text - 要替换的字符串
  
  pattern - 用于匹配的正则式
  
  replaceFun - 决定如何替换的函数
  
  Returns:
  
  替换后的字符串
  
  See Also:
  
  PatternKit.replaceAll(CharSequence, java.util.regex.Pattern, FunctionX)
- replace
  public static String replace(CharSequence text, String regex, FunctionX<Matcher,String> replaceFun)
  
  替换所有正则匹配的文本，并使用自定义函数决定如何替换
  
  Parameters:
  
  text - 要替换的字符串
  
  regex - 用于匹配的正则式
  
  replaceFun - 决定如何替换的函数
  
  Returns:
  
  替换后的字符串
  
  See Also:
  
  PatternKit.replaceAll(CharSequence, String, FunctionX)
- hide
  public static String hide(CharSequence text, int startInclude, int endExclude)
  
  替换指定字符串的指定区间内字符为"*"
  hide(null,*,*)=null hide("",0,*)="" hide("jackduan@163.com",-1,4) ****duan@163.com hide("jackduan@163.com",2,3) ja*kduan@163.com hide("jackduan@163.com",3,2) jackduan@163.com hide("jackduan@163.com",16,16) jackduan@163.com hide("jackduan@163.com",16,17) jackduan@163.com
  
  Parameters:
  
  text - 字符串
  
  startInclude - 开始位置（包含）
  
  endExclude - 结束位置（不包含）
  
  Returns:
  
  替换后的字符串
- replaceChars
  
  public static String replaceChars(CharSequence text, String chars, CharSequence replacedStr)
  
  替换字符字符数组中所有的字符为replacedStr 提供的chars为所有需要被替换的字符，例如："\r\n"，则"\r"和"\n"都会被替换，哪怕他们单独存在
  
  Parameters:
  
  text - 被检查的字符串
  
  chars - 需要替换的字符列表，用一个字符串表示这个字符列表
  
  replacedStr - 替换成的字符串
  
  Returns:
  
  新字符串
- replaceChars
  
  public static String replaceChars(CharSequence text, char[] chars, CharSequence replacedStr)
  
  替换字符字符数组中所有的字符为replacedStr
  
  Parameters:
  
  text - 被检查的字符串
  
  chars - 需要替换的字符列表
  
  replacedStr - 替换成的字符串
  
  Returns:
  
  新字符串
- replaceAt
  
  public static String replaceAt(CharSequence text, int index, UnaryOperator<Character> operator)
  
  按照给定逻辑替换指定位置的字符，如字符大小写转换等
  
  Parameters:
  
  text - 字符串
  
  index - 位置，-1表示最后一个字符
  
  operator - 替换逻辑，给定原字符，返回新字符
  
  Returns:
  
  替换后的字符串
- length
  
  public static int length(CharSequence cs)
  
  获取字符串的长度，如果为null返回0
  
  Parameters:
  
  cs - a 字符串
  
  Returns:
  
  字符串的长度，如果为null返回0
- codeLength
  
  public static int codeLength(CharSequence cs)
  
  获取字符串的Unicode字符长度，如果为null返回0 Unicode字符长度指实际Unicode字符个数，如emoji算一个字符
  
  Parameters:
  
  cs - a 字符串
  
  Returns:
  
  字符串的长度，如果为null返回0
- byteLength
  
  public static int byteLength(CharSequence cs, Charset charset)
  
  给定字符串转为bytes后的byte数（byte长度）
  
  Parameters:
  
  cs - 字符串
  
  charset - 编码
  
  Returns:
  
  byte长度
- totalLength
  
  public static int totalLength(CharSequence... args)
  
  给定字符串数组的总长度 null字符长度定义为0
  
  Parameters:
  
  args - 字符串数组
  
  Returns:
  
  总长度
- limitLength
  
  public static String limitLength(CharSequence text, int length)
  
  限制字符串长度，如果超过指定长度，截取指定长度并在末尾加"..."
  
  Parameters:
  
  text - 字符串
  
  length - 最大长度
  
  Returns:
  
  切割后的剩余的前半部分字符串+"..."
- limitByteLengthUtf8
  
  public static String limitByteLengthUtf8(CharSequence text, int maxBytesLength, boolean appendDots)
  
  截断字符串，使用UTF8编码为字节后不超过maxBytes长度
  
  Parameters:
  
  text - 原始字符串
  
  maxBytesLength - 最大字节数
  
  appendDots - 截断后是否追加省略号(...)
  
  Returns:
  
  限制后的长度
- limitByteLength
  
  public static String limitByteLength(CharSequence text, Charset charset, int maxBytesLength, int factor, boolean appendDots)
  
  截断字符串，使用其按照指定编码为字节后不超过maxBytes长度此方法用于截取总bytes数不超过指定长度，如果字符出没有超出原样输出，如果超出了，则截取掉超出部分，并可选添加...，但是添加“...”后总长度也不超过限制长度。
  
  Parameters:
  
  text - 原始字符串
  
  charset - 指定编码
  
  maxBytesLength - 最大字节数
  
  factor - 速算因子，取该编码下单个字符的最大可能字节数
  
  appendDots - 截断后是否追加省略号(...)
  
  Returns:
  
  限制后的长度
- firstNonNull
  
  public static <T extends CharSequence> T firstNonNull(T... args)
  
  返回第一个非null 元素
  
  Type Parameters:
  
  T - 元素类型
  
  Parameters:
  
  args - 多个元素
  
  Returns:
  
  第一个非空元素，如果给定的数组为空或者都为空，返回null
- firstNonEmpty
  public static <T extends CharSequence> T firstNonEmpty(T... args)
  
  返回第一个非empty 元素
  
  Type Parameters:
  
  T - 元素类型
  
  Parameters:
  
  args - 多个元素
  
  Returns:
  
  第一个非空元素，如果给定的数组为空或者都为空，返回null
  
  See Also:
  
  CharsValidator.isNotEmpty(CharSequence)
- firstNonBlank
  public static <T extends CharSequence> T firstNonBlank(T... args)
  
  返回第一个非blank 元素
  
  Type Parameters:
  
  T - 元素类型
  
  Parameters:
  
  args - 多个元素
  
  Returns:
  
  第一个非空元素，如果给定的数组为空或者都为空，返回null
  
  See Also:
  
  CharsValidator.isNotBlank(CharSequence)
- upperFirstAndAddPre
  
  public static String upperFirstAndAddPre(CharSequence text, String preString)
  
  原字符串首字母大写并在其首部添加指定字符串例如：text=name, preString=get = return getName
  
  Parameters:
  
  text - 被处理的字符串
  
  preString - 添加的首部
  
  Returns:
  
  处理后的字符串
- upperFirst
  
  public static String upperFirst(CharSequence text)
  
  大写首字母例如：text = name, return Name
  
  Parameters:
  
  text - 字符串
  
  Returns:
  
  字符串
- upperAt
  public static String upperAt(CharSequence text, int index)
  
  大写对应下标字母
  例如: text = name,index = 1, return nAme
  
  Parameters:
  
  text - 字符串
  
  index - 下标，支持负数，-1表示最后一个字符
  
  Returns:
  
  字符串
- lowerFirst
  
  public static String lowerFirst(CharSequence text)
  
  小写首字母例如：text = Name, return name
  
  Parameters:
  
  text - 字符串
  
  Returns:
  
  字符串
- lowerAt
  
  public static String lowerAt(CharSequence text, int index)
  
  小写对应下标字母例如: text = NAME,index = 1, return NaME
  
  Parameters:
  
  text - 字符串
  
  index - 下标，支持负数，-1表示最后一个字符
  
  Returns:
  
  字符串
- filter
  
  public static String filter(CharSequence text, Predicate<Character> predicate)
  
  过滤字符串
  
  Parameters:
  
  text - 字符串
  
  predicate - 过滤器，Predicate.test(Object)为true保留字符
  
  Returns:
  
  过滤后的字符串
- isUpperCase
  public static boolean isUpperCase(CharSequence text)
  
  给定字符串中的字母是否全部为大写，判断依据如下：
  1. 大写字母包括A-Z 2. 其它非字母的Unicode符都算作大写
  
  Parameters:
  
  text - 被检查的字符串
  
  Returns:
  
  是否全部为大写
- isLowerCase
  public static boolean isLowerCase(CharSequence text)
  
  给定字符串中的字母是否全部为小写，判断依据如下：
  1. 小写字母包括a-z 2. 其它非字母的Unicode符都算作小写
  
  Parameters:
  
  text - 被检查的字符串
  
  Returns:
  
  是否全部为小写
- swapCase
  public static String swapCase(String text)
  
  切换给定字符串中的大小写。大写转小写，小写转大写。
  swapCase(null) = null swapCase("") = "" swapCase("The dog has a BONE") = "tHE DOG HAS A bone"
  
  Parameters:
  
  text - 字符串
  
  Returns:
  
  交换后的字符串
- toUnderlineCase
  public static String toUnderlineCase(CharSequence text)
  
  将驼峰式命名的字符串转换为下划线方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。例如：
  HelloWorld = hello_world Hello_World = hello_world HelloWorld_test = hello_world_test
  
  Parameters:
  
  text - 转换前的驼峰式命名的字符串，也可以为下划线形式
  
  Returns:
  
  转换后下划线方式命名的字符串
  
  See Also:
  
  NamingCase.toUnderlineCase(CharSequence)
- toSymbolCase
  public static String toSymbolCase(CharSequence text, char symbol)
  
  将驼峰式命名的字符串转换为使用符号连接方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。
  
  Parameters:
  
  text - 转换前的驼峰式命名的字符串，也可以为符号连接形式
  
  symbol - 连接符
  
  Returns:
  
  转换后符号连接方式命名的字符串
  
  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)
- builder
  
  public static StringBuilder builder(CharSequence text)
  
  创建StringBuilder对象如果对象本身为StringBuilder，直接返回，否则新建
  
  Parameters:
  
  text - CharSequence
  
  Returns:
  
  StringBuilder对象
- builder
  
  public static StringBuilder builder(CharSequence... args)
  
  创建StringBuilder对象
  
  Parameters:
  
  args - 初始字符串列表
  
  Returns:
  
  StringBuilder对象
- 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... args)
  
  连接多个字符串为一个
  
  Parameters:
  
  isNullToEmpty - 是否null转为""
  
  args - 字符串数组
  
  Returns:
  
  连接后的字符串
- brief
  public static String brief(CharSequence text, 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:
  
  text - 字符串
  
  maxLength - 结果的最大长度
  
  Returns:
  
  截取后的字符串
- join
  public static String join(CharSequence conjunction, Object... objs)
  
  以 conjunction 为分隔符将多个对象转换为字符串
  
  Parameters:
  
  conjunction - 分隔符 Symbol.COMMA
  
  objs - 数组
  
  Returns:
  
  连接后的字符串
  
  See Also:
  
  ArrayKit.join(Object, CharSequence)
- join
  public static <T> String join(CharSequence conjunction, Iterable<T> iterable)
  
  以 conjunction 为分隔符将多个对象转换为字符串
  
  Type Parameters:
  
  T - 元素类型
  
  Parameters:
  
  conjunction - 分隔符 Symbol.COMMA
  
  iterable - 集合
  
  Returns:
  
  连接后的字符串
  
  See Also:
  
  CollKit.join(Iterable, CharSequence)
- isNumeric
  
  public static boolean isNumeric(CharSequence text)
  
  检查字符串是否都为数字组成
  
  Parameters:
  
  text - 字符串
  
  Returns:
  
  是否都为数字组成
- move
  
  public static String move(CharSequence text, int startInclude, int endExclude, int moveLength)
  
  循环位移指定位置的字符串为指定距离当moveLength大于0向右位移，小于0向左位移，0不位移当moveLength大于字符串长度时采取循环位移策略，即位移到头后从头（尾）位移，例如长度为10，位移13则表示位移3
  
  Parameters:
  
  text - 字符串
  
  startInclude - 起始位置（包括）
  
  endExclude - 结束位置（不包括）
  
  moveLength - 移动距离，负数表示左移，正数为右移
  
  Returns:
  
  位移后的字符串
- isCharEquals
  
  public static boolean isCharEquals(CharSequence text)
  
  检查给定字符串的所有字符是否都一样
  
  Parameters:
  
  text - 字符出啊
  
  Returns:
  
  给定字符串的所有字符是否都一样
- normalize
  public static String normalize(CharSequence text)
  
  对字符串归一化处理，如 "Á" 可以使用 "u00C1"或 "u0041u0301"表示，实际测试中两个字符串并不equals 因此使用此方法归一为一种表示形式，默认按照W3C通常建议的，在NFC中交换文本。
  
  Parameters:
  
  text - 归一化的字符串
  
  Returns:
  
  归一化后的字符串
  
  See Also:
  
  Normalizer.normalize(CharSequence, Normalizer.Form)
- fixLength
  
  public static String fixLength(CharSequence text, char fixedChar, int length)
  
  在给定字符串末尾填充指定字符，以达到给定长度如果字符串本身的长度大于等于length，返回原字符串
  
  Parameters:
  
  text - 字符串
  
  fixedChar - 补充的字符
  
  length - 补充到的长度
  
  Returns:
  
  补充后的字符串
- commonPrefix
  public static CharSequence commonPrefix(CharSequence text1, CharSequence text2)
  
  获取两个字符串的公共前缀
  commonPrefix("abb", "acc") // "a"
  
  Parameters:
  
  text1 - 字符串1
  
  text2 - 字符串2
  
  Returns:
  
  字符串1和字符串2的公共前缀
- commonSuffix
  public static CharSequence commonSuffix(CharSequence text1, CharSequence text2)
  
  获取两个字符串的公共后缀
  commonSuffix("aba", "cba") // "ba"
  
  Parameters:
  
  text1 - 字符串1
  
  text2 - 字符串2
  
  Returns:
  
  字符串1和字符串2的公共后缀
- splitTo
  
  public static <T> T splitTo(CharSequence text, CharSequence separator, Class<T> resultType)
  
  切分字符串，去除切分后每个元素两边的空白符，去除空白项，并转为结果类型
  
  Type Parameters:
  
  T - 结果类型
  
  Parameters:
  
  text - 被切分的字符串
  
  separator - 分隔符字符
  
  resultType - 结果类型的类，可以是数组或集合
  
  Returns:
  
  long数组
- splitTrim
  
  public static List<String> splitTrim(CharSequence text, CharSequence separator)
  
  切分字符串，去除切分后每个元素两边的空白符，去除空白项
  
  Parameters:
  
  text - 被切分的字符串
  
  separator - 分隔符字符
  
  Returns:
  
  切分后的集合
- splitToArray
  
  public static String[] splitToArray(CharSequence text, CharSequence separator)
  
  切分字符串，如果分隔符不存在则返回原字符串此方法不会去除切分字符串后每个元素两边的空格，不忽略空串
  
  Parameters:
  
  text - 被切分的字符串
  
  separator - 分隔符
  
  Returns:
  
  字符串
- split
  
  public static String split(String text)
  
  切分字符串
  
  Parameters:
  
  text - 被切分的字符串
  
  Returns:
  
  字符串
- split
  
  public static String split(String text, String separator, String reserve)
  
  切分字符串
  
  Parameters:
  
  text - 被切分的字符串
  
  separator - 分隔符
  
  reserve - 替换后的分隔符
  
  Returns:
  
  字符串
- split
  
  public static List<String> split(CharSequence text, CharSequence separator)
  
  切分字符串，如果分隔符不存在则返回原字符串此方法不会去除切分字符串后每个元素两边的空格，不忽略空串
  
  Parameters:
  
  text - 被切分的字符串
  
  separator - 分隔符
  
  Returns:
  
  字符串
- split
  
  public static List<String> split(CharSequence text, CharSequence separator, boolean isTrim, boolean ignoreEmpty)
  
  切分字符串，不忽略大小写
  
  Parameters:
  
  text - 被切分的字符串
  
  separator - 分隔符字符串
  
  isTrim - 是否去除切分字符串后每个元素两边的空格
  
  ignoreEmpty - 是否忽略空串
  
  Returns:
  
  切分后的集合
- split
  
  public static List<String> split(CharSequence text, CharSequence separator, int limit, boolean isTrim, boolean ignoreEmpty)
  
  切分字符串，不忽略大小写
  
  Parameters:
  
  text - 被切分的字符串
  
  separator - 分隔符字符串
  
  limit - 限制分片数，小于等于0表示无限制
  
  isTrim - 是否去除切分字符串后每个元素两边的空格
  
  ignoreEmpty - 是否忽略空串
  
  Returns:
  
  切分后的集合
- split
  
  public static List<String> split(CharSequence text, CharSequence separator, int limit, boolean isTrim, boolean ignoreEmpty, boolean ignoreCase)
  
  切分字符串如果提供的字符串为null，则返回一个空的ArrayList 如果提供的字符串为""，则当ignoreEmpty时返回空的ArrayList，否则返回只有一个""元素的ArrayList
  
  Parameters:
  
  text - 被切分的字符串
  
  separator - 分隔符字符串
  
  limit - 限制分片数，小于等于0表示无限制
  
  isTrim - 是否去除切分字符串后每个元素两边的空格
  
  ignoreEmpty - 是否忽略空串
  
  ignoreCase - 是否忽略大小写
  
  Returns:
  
  切分后的集合
- split
  
  public static <R> List<R> split(CharSequence text, CharSequence separator, int limit, boolean ignoreEmpty, boolean ignoreCase, Function<String,R> mapping)
  
  切分字符串如果提供的字符串为null，则返回一个空的ArrayList 如果提供的字符串为""，则当ignoreEmpty时返回空的ArrayList，否则返回只有一个""元素的ArrayList
  
  Type Parameters:
  
  R - 元素类型
  
  Parameters:
  
  text - 被切分的字符串
  
  separator - 分隔符字符串
  
  limit - 限制分片数，小于等于0表示无限制
  
  ignoreEmpty - 是否忽略空串
  
  ignoreCase - 是否忽略大小写
  
  mapping - 切分后字段映射函数
  
  Returns:
  
  切分后的集合
- splitPath
  
  public static List<String> splitPath(CharSequence text)
  
  切分路径字符串如果为空字符串或者null 则返回空集合空路径会被忽略
  
  Parameters:
  
  text - 被切分的字符串
  
  Returns:
  
  切分后的集合
- splitPath
  
  public static List<String> splitPath(CharSequence text, int limit)
  
  切分路径字符串如果为空字符串或者null 则返回空集合空路径会被忽略
  
  Parameters:
  
  text - 被切分的字符串
  
  limit - 限制分片数，小于等于0表示无限制
  
  Returns:
  
  切分后的集合
- splitByBlank
  
  public static List<String> splitByBlank(CharSequence text)
  
  使用空白符切分字符串切分后的字符串两边不包含空白符，空串或空白符串并不做为元素之一如果为空字符串或者null 则返回空集合
  
  Parameters:
  
  text - 被切分的字符串
  
  Returns:
  
  切分后的集合
- splitByBlank
  
  public static List<String> splitByBlank(CharSequence text, int limit)
  
  使用空白符切分字符串切分后的字符串两边不包含空白符，空串或空白符串并不做为元素之一如果为空字符串或者null 则返回空集合
  
  Parameters:
  
  text - 被切分的字符串
  
  limit - 限制分片数，小于等于0表示无限制
  
  Returns:
  
  切分后的集合
- splitByBlankToArray
  
  public static String[] splitByBlankToArray(CharSequence text, int limit)
  
  切分字符串为字符串数组
  
  Parameters:
  
  text - 被切分的字符串
  
  limit - 限制分片数，小于等于0表示无限制
  
  Returns:
  
  切分后的集合
- splitByRegex
  public static List<String> splitByRegex(CharSequence text, String separatorRegex, int limit, boolean isTrim, boolean ignoreEmpty)
  
  通过正则切分字符串，规则如下：
  
  当提供的str为null时，返回new ArrayList(0)
  
  当提供的str为""时，返回[""]
  
  当提供的separatorRegex为empty(null or "")时，返回[text]，即只有原串一个元素的数组
  
  Parameters:
  
  text - 字符串
  
  separatorRegex - 分隔符正则
  
  limit - 限制分片数，小于等于0表示无限制
  
  isTrim - 是否去除切分字符串后每个元素两边的空格
  
  ignoreEmpty - 是否忽略空串
  
  Returns:
  
  切分后的集合
- splitByRegex
  public static List<String> splitByRegex(CharSequence text, Pattern separatorPattern, int limit, boolean isTrim, boolean ignoreEmpty)
  
  通过正则切分字符串，规则如下：
  
  当提供的str为null时，返回new ArrayList(0)
  
  当提供的str为""时，返回[""]
  
  当提供的separatorRegex为empty(null or "")时，返回[text]，即只有原串一个元素的数组
  
  Parameters:
  
  text - 字符串
  
  separatorPattern - 分隔符正则Pattern
  
  limit - 限制分片数，小于等于0表示无限制
  
  isTrim - 是否去除切分字符串后每个元素两边的空格
  
  ignoreEmpty - 是否忽略空串
  
  Returns:
  
  切分后的集合
- splitByRegexToArray
  
  public static String[] splitByRegexToArray(CharSequence text, Pattern separatorPattern, int limit, boolean isTrim, boolean ignoreEmpty)
  
  通过正则切分字符串为字符串数组
  
  Parameters:
  
  text - 被切分的字符串
  
  separatorPattern - 分隔符正则Pattern
  
  limit - 限制分片数，小于等于0表示无限制
  
  isTrim - 是否去除切分字符串后每个元素两边的空格
  
  ignoreEmpty - 是否忽略空串
  
  Returns:
  
  切分后的集合
- splitByLength
  
  public static String[] splitByLength(CharSequence text, int len)
  
  根据给定长度，将给定字符串截取为多个部分
  
  Parameters:
  
  text - 字符串
  
  len - 每一个小节的长度，必须大于0
  
  Returns:
  
  截取后的字符串数组
- trimFunc
  
  public static Function<String,String> trimFunc(boolean isTrim)
  
  Trim函数
  
  Parameters:
  
  isTrim - 是否trim
  
  Returns:
  
  Function
- toChars
  
  public static int[] toChars(CharSequence text, boolean isCodePoint)
  
  将字符串转换为字符数组
  
  Parameters:
  
  text - 字符串
  
  isCodePoint - 是否为Unicode码点（即支持emoji等多char字符）
  
  Returns:
  
  字符数组
- forEach
  
  public static void forEach(CharSequence str, Consumer<Character> consumer)
  
  遍历字符串的每个字符，并处理
  
  Parameters:
  
  str - 字符串
  
  consumer - 字符处理
- forEach
  
  public static void forEach(CharSequence str, boolean isCodePoint, IntConsumer consumer)
  
  遍历字符串的每个字符，并处理
  
  Parameters:
  
  str - 字符串
  
  isCodePoint - 是否为Unicode码点（即支持emoji等多char字符）
  
  consumer - 字符处理

Class CharsBacker

Constructor Summary

Method Summary

Methods inherited from class org.miaixz.bus.core.text.CharsValidator

Methods inherited from class java.lang.Object

Constructor Details

CharsBacker

Method Details

toString

toStringOrNull

toStringOrEmpty

emptyIfNull

nullIfEmpty

defaultIfNull

defaultIfNull

defaultIfNull

defaultIfEmpty

defaultIfEmpty

defaultIfEmpty

defaultIfBlank

defaultIfBlank

trim

trimToEmpty

trimToNull

trimPrefix

trimSuffix

trim

trim

startWith

startWith

startWithIgnoreEquals

startWithIgnoreCase

startWithAny

startWithAnyIgnoreCase

startWith

startWith

endWith

endWith

endWithIgnoreCase

endWithAny

endWithAnyIgnoreCase

endWith

endWith

contains

contains

containsAny

containsAny

containsOnly

containsBlank

getContainsString

containsIgnoreCase

containsAnyIgnoreCase

getContainsStrIgnoreCase

containsAll

indexOf

indexOf

indexOf

indexOf

indexOfIgnoreCase

indexOfIgnoreCase

indexOf

lastIndexOfIgnoreCase

lastIndexOfIgnoreCase

lastIndexOf

ordinalIndexOf

removeAll

removeAll

removeAll

removeAllLineBreaks

removePreAndLowerFirst

removePreAndLowerFirst

removePrefix

removePrefixIgnoreCase

removePrefix

removeAllSuffix

removeSuffix

removeSufAndLowerFirst

removeSuffixIgnoreCase

cleanBlank

strip