com.jchanghong.core.kotlin.StrHelper.kt Maven / Gradle / Ivy
The newest version!
package com.jchanghong.core.kotlin
import cn.hutool.core.util.StrUtil
import java.io.StringReader
import java.nio.ByteBuffer
import java.nio.charset.Charset
fun main() {
println("sa".toCamelCase())
}
//fun\s+(\w+)(\(str: CharSequence\?,*)([^{]+)
/**
* 字符串工具类
*
* @author xiaoleilu
*/
/**
* 字符串是否为空白 空白的定义如下：
* 1、为null
* 2、为不可见字符（如空格）
* 3、""
*
* @param str 被检测的字符串
* @return 是否为空
*/
fun CharSequence?.isBlank(): Boolean {
return StrUtil.isBlank(this)
}
/**
* 字符串是否为非空白，非空白的定义如下：
* 1、不为null
* 2、不为不可见字符（如空格）
* 3、不为""
*
* @param str 被检测的字符串
* @return 是否为非空
*/
fun CharSequence?.isNotBlank(): Boolean {
return StrUtil.isNotBlank(this)
}
/**
* 是否包含空字符串
*
* @param strs 字符串列表
* @return 是否包含空字符串
*/
fun Collection.hasBlank(): Boolean {
return StrUtil.hasBlank(*this.toTypedArray())
}
/**
* 给定所有字符串是否为空白
*
* @param strs 字符串
* @return 所有字符串是否为空白
*/
fun Collection.isAllBlank(): Boolean {
return StrUtil.isAllBlank(*this.toTypedArray())
}
/**
* 字符串是否为空，空的定义如下:
* 1、为null
* 2、为""
*
* @param str 被检测的字符串
* @return 是否为空
*/
fun CharSequence?.isEmpty(): Boolean {
return StrUtil.isEmpty(this)
}
/**
* 字符串是否为非空白，非空白的定义如下：
* 1、不为null
* 2、不为""
*
* @param str 被检测的字符串
* @return 是否为非空
*/
fun CharSequence?.isNotEmpty(): Boolean {
return StrUtil.isNotEmpty(this)
}
/**
* 当给定字符串为null时，转换为Empty
*
* @param str 被检查的字符串
* @return 原字符串或者空串
* @see .nullToEmpty
* @since 4.6.3
*/
fun CharSequence?.emptyIfNull(): String {
return StrUtil.emptyIfNull(this)
}
/**
* 当给定字符串为null时，转换为Empty
*
* @param str 被转换的字符串
* @return 转换后的字符串
*/
fun CharSequence?.nullToEmpty(): String {
return StrUtil.nullToEmpty(this)
}
/**
* 如果字符串是`null`，则返回指定默认字符串，否则返回字符串本身。
*
*
* nullToDefault(null, "default") = "default"
* nullToDefault("", "default") = ""
* nullToDefault(" ", "default") = " "
* nullToDefault("bat", "default") = "bat"
*
*
* @param str 要转换的字符串
* @param defaultStr 默认字符串
* @return 字符串本身或指定的默认字符串
*/
fun CharSequence?.nullToDefault(defaultStr: String): String {
return StrUtil.nullToDefault(this, defaultStr)
}
/**
* 如果字符串是`null`或者""，则返回指定默认字符串，否则返回字符串本身。
*
*
* emptyToDefault(null, "default") = "default"
* emptyToDefault("", "default") = "default"
* emptyToDefault(" ", "default") = " "
* emptyToDefault("bat", "default") = "bat"
*
*
* @param str 要转换的字符串
* @param defaultStr 默认字符串
* @return 字符串本身或指定的默认字符串
* @since 4.1.0
*/
fun CharSequence?.emptyToDefault(defaultStr: String): String {
return StrUtil.emptyToDefault(this, defaultStr)
}
/**
* 如果字符串是`null`或者""或者空白，则返回指定默认字符串，否则返回字符串本身。
*
*
* emptyToDefault(null, "default") = "default"
* emptyToDefault("", "default") = "default"
* emptyToDefault(" ", "default") = "default"
* emptyToDefault("bat", "default") = "bat"
*
*
* @param str 要转换的字符串
* @param defaultStr 默认字符串
* @return 字符串本身或指定的默认字符串
* @since 4.1.0
*/
fun CharSequence?.blankToDefault(defaultStr: String): String {
return StrUtil.blankToDefault(this, defaultStr)
}
/**
* 当给定字符串为空字符串时，转换为`null`
*
* @param str 被转换的字符串
* @return 转换后的字符串
*/
fun CharSequence?.emptyToNull(): String {
return StrUtil.emptyToNull(this)
}
/**
* 是否包含空字符串
*
* @param strs 字符串列表
* @return 是否包含空字符串
*/
fun Collection.hasEmpty(): Boolean {
return StrUtil.hasEmpty(*this.toTypedArray())
}
/**
* 是否全部为空字符串
*
* @param strs 字符串列表
* @return 是否全部为空字符串
*/
fun Collection.isAllEmpty(): Boolean {
return StrUtil.isAllEmpty(*this.toTypedArray())
}
/**
* 检查字符串是否为null、“null”、“undefined”
*
* @param str 被检查的字符串
* @return 是否为null、“null”、“undefined”
* @since 4.0.10
*/
fun CharSequence?.isNullOrUndefined(): Boolean {
return StrUtil.isNullOrUndefined(this)
}
/**
* 检查字符串是否为null、“”、“null”、“undefined”
*
* @param str 被检查的字符串
* @return 是否为null、“”、“null”、“undefined”
* @since 4.0.10
*/
fun CharSequence?.isEmptyOrUndefined(): Boolean {
return StrUtil.isEmptyOrUndefined(this)
}
/**
* 检查字符串是否为null、空白串、“null”、“undefined”
*
* @param str 被检查的字符串
* @return 是否为null、空白串、“null”、“undefined”
* @since 4.0.10
*/
fun CharSequence?.isBlankOrUndefined(): Boolean {
return StrUtil.isBlankOrUndefined(this)
}
/**
* 除去字符串头尾部的空白，如果字符串是`null`，依然返回`null`。
*
*
*
* 注意，和`String.trim`不同，此方法使用`NumberUtil.isBlankChar` 来判定空白， 因而可以除去英文字符集之外的其它空白，如中文空格。
*
*
* trim(null) = null
* trim("") = ""
* trim(" ") = ""
* trim("abc") = "abc"
* trim(" abc ") = "abc"
*
*
* @param str 要处理的字符串
* @return 除去头尾空白的字符串，如果原字串为`null`，则返回`null`
*/
fun CharSequence?.trim(): String {
return StrUtil.trim(this.toString())
}
/**
* 给定字符串数组全部做去首尾空格
*
* @param strs 字符串数组
*/
fun Collection.trim(): List {
return this.map { it.trim() }
}
/**
* 除去字符串头部的空白，如果字符串是`null`，则返回`null`。
*
*
*
* 注意，和`String.trim`不同，此方法使用`CharUtil.isBlankChar` 来判定空白， 因而可以除去英文字符集之外的其它空白，如中文空格。
*
*
* trimStart(null) = null
* trimStart("") = ""
* trimStart("abc") = "abc"
* trimStart(" abc") = "abc"
* trimStart("abc ") = "abc "
* trimStart(" abc ") = "abc "
*
*
* @param str 要处理的字符串
* @return 除去空白的字符串，如果原字串为`null`或结果字符串为`""`，则返回 `null`
*/
fun CharSequence?.trimStart(): String {
return StrUtil.trimStart(this.toString())
}
/**
* 除去字符串尾部的空白，如果字符串是`null`，则返回`null`。
*
*
*
* 注意，和`String.trim`不同，此方法使用`CharUtil.isBlankChar` 来判定空白， 因而可以除去英文字符集之外的其它空白，如中文空格。
*
*
* trimEnd(null) = null
* trimEnd("") = ""
* trimEnd("abc") = "abc"
* trimEnd(" abc") = " abc"
* trimEnd("abc ") = "abc"
* trimEnd(" abc ") = " abc"
*
*
* @param str 要处理的字符串
* @return 除去空白的字符串，如果原字串为`null`或结果字符串为`""`，则返回 `null`
*/
fun CharSequence?.trimEnd(): String {
return StrUtil.trimEnd(this.toString())
}
/**
* 除去字符串头尾部的空白符，如果字符串是`null`，依然返回`null`。
*
* @param str 要处理的字符串
* @param mode `-1`表示trimStart，`0`表示trim全部， `1`表示trimEnd
* @return 除去指定字符后的的字符串，如果原字串为`null`，则返回`null`
*/
fun CharSequence?.trim(mode: Int): String {
return StrUtil.trim(this.toString(), mode)
}
/**
* 字符串是否以给定字符开始
*
* @param str 字符串
* @param c 字符
* @return 是否开始
*/
fun CharSequence?.startWith(c: Char): Boolean {
return StrUtil.startWith(this ?: "", c)
}
/**
* 是否以指定字符串开头
* 如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
*
* @param str 被监测字符串
* @param prefix 开头字符串
* @param isIgnoreCase 是否忽略大小写
* @return 是否以指定字符串开头
*/
fun CharSequence?.startWith(prefix: CharSequence?, isIgnoreCase: Boolean): Boolean {
return StrUtil.startWith(this ?: "", prefix ?: "", isIgnoreCase)
}
/**
* 是否以指定字符串开头
*
* @param str 被监测字符串
* @param prefix 开头字符串
* @return 是否以指定字符串开头
*/
fun CharSequence?.startWith(prefix: CharSequence?): Boolean {
return StrUtil.startWith(this ?: "", prefix ?: "")
}
/**
* 是否以指定字符串开头，忽略大小写
*
* @param str 被监测字符串
* @param prefix 开头字符串
* @return 是否以指定字符串开头
*/
fun CharSequence?.startWithIgnoreCase(prefix: CharSequence?): Boolean {
return StrUtil.startWithIgnoreCase(this ?: "", prefix ?: "")
}
/**
* 给定字符串是否以任何一个字符串开始
* 给定字符串和数组为空都返回false
*
* @param str 给定字符串
* @param prefixes 需要检测的开始字符串
* @return 给定字符串是否以任何一个字符串开始
* @since 3.0.6
*/
fun CharSequence?.startWithAny(vararg prefixes: CharSequence?): Boolean {
return StrUtil.startWithAny(this ?: "", *prefixes)
}
/**
* 字符串是否以给定字符结尾
*
* @param str 字符串
* @param c 字符
* @return 是否结尾
*/
fun CharSequence?.endWith(c: Char): Boolean {
return StrUtil.endWith(this ?: "", c)
}
/**
* 是否以指定字符串结尾
* 如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
*
* @param str 被监测字符串
* @param suffix 结尾字符串
* @param isIgnoreCase 是否忽略大小写
* @return 是否以指定字符串结尾
*/
fun CharSequence?.endWith(suffix: CharSequence?, isIgnoreCase: Boolean): Boolean {
return StrUtil.endWith(this ?: "", suffix ?: "", isIgnoreCase)
}
/**
* 是否以指定字符串结尾
*
* @param str 被监测字符串
* @param suffix 结尾字符串
* @return 是否以指定字符串结尾
*/
fun CharSequence?.endWith(suffix: CharSequence?): Boolean {
return StrUtil.endWith(this ?: "", suffix ?: "")
}
/**
* 是否以指定字符串结尾，忽略大小写
*
* @param str 被监测字符串
* @param suffix 结尾字符串
* @return 是否以指定字符串结尾
*/
fun CharSequence?.endWithIgnoreCase(suffix: CharSequence?): Boolean {
return StrUtil.endWithIgnoreCase(this ?: "", suffix ?: "")
}
/**
* 给定字符串是否以任何一个字符串结尾
* 给定字符串和数组为空都返回false
*
* @param str 给定字符串
* @param suffixes 需要检测的结尾字符串
* @return 给定字符串是否以任何一个字符串结尾
* @since 3.0.6
*/
fun CharSequence?.endWithAny(vararg suffixes: CharSequence?): Boolean {
return StrUtil.endWithAny(this ?: "", *suffixes)
}
/**
* 指定字符是否在字符串中出现过
*
* @param str 字符串
* @param searchChar 被查找的字符
* @return 是否包含
* @since 3.1.2
*/
fun CharSequence?.contains(searchChar: Char): Boolean {
return StrUtil.contains(this ?: "", searchChar)
}
/**
* 指定字符串是否在字符串中出现过
*
* @param str 字符串
* @param searchStr 被查找的字符串
* @return 是否包含
* @since 5.1.1
*/
fun CharSequence?.contains(searchStr: CharSequence?): Boolean {
return StrUtil.contains(this ?: "", searchStr ?: "")
}
/**
* 查找指定字符串是否包含指定字符串列表中的任意一个字符串
*
* @param str 指定字符串
* @param testStrs 需要检查的字符串数组
* @return 是否包含任意一个字符串
* @since 3.2.0
*/
fun CharSequence?.containsAny(vararg testStrs: CharSequence?): Boolean {
return StrUtil.containsAny(this ?: "", *testStrs)
}
/**
* 查找指定字符串是否包含指定字符列表中的任意一个字符
*
* @param str 指定字符串
* @param testChars 需要检查的字符数组
* @return 是否包含任意一个字符
* @since 4.1.11
*/
fun CharSequence?.containsAny(vararg testChars: Char): Boolean {
return StrUtil.containsAny(this ?: "", *testChars)
}
/**
* 检查指定字符串中是否只包含给定的字符
*
* @param str 字符串
* @param testChars 检查的字符
* @return 字符串含有非检查的字符，返回false
* @since 4.4.1
*/
fun CharSequence?.containsOnly(vararg testChars: Char): Boolean {
return StrUtil.containsOnly(this ?: "", *testChars)
}
/**
* 给定字符串是否包含空白符（空白符包括空格、制表符、全角空格和不间断空格）
* 如果给定字符串为null或者""，则返回false
*
* @param str 字符串
* @return 是否包含空白符
* @since 4.0.8
*/
fun CharSequence?.containsBlank(): Boolean {
return StrUtil.containsBlank(this.toString())
}
/**
* 查找指定字符串是否包含指定字符串列表中的任意一个字符串，如果包含返回找到的第一个字符串
*
* @param str 指定字符串
* @param testStrs 需要检查的字符串数组
* @return 被包含的第一个字符串
* @since 3.2.0
*/
fun CharSequence?.getContainsStr(vararg testStrs: CharSequence?): String {
return StrUtil.getContainsStr(this ?: "", *testStrs)
}
/**
* 是否包含特定字符，忽略大小写，如果给定两个参数都为`null`，返回true
*
* @param str 被检测字符串
* @param testStr 被测试是否包含的字符串
* @return 是否包含
*/
fun CharSequence?.containsIgnoreCase(testStr: CharSequence?): Boolean {
return StrUtil.containsIgnoreCase(this.toString(), testStr.toString())
}
/**
* 查找指定字符串是否包含指定字符串列表中的任意一个字符串
* 忽略大小写
*
* @param str 指定字符串
* @param testStrs 需要检查的字符串数组
* @return 是否包含任意一个字符串
* @since 3.2.0
*/
fun CharSequence?.containsAnyIgnoreCase(vararg testStrs: CharSequence?): Boolean {
return StrUtil.containsAnyIgnoreCase(this ?: "", *testStrs)
}
/**
* 查找指定字符串是否包含指定字符串列表中的任意一个字符串，如果包含返回找到的第一个字符串
* 忽略大小写
*
* @param str 指定字符串
* @param testStrs 需要检查的字符串数组
* @return 被包含的第一个字符串
* @since 3.2.0
*/
fun CharSequence?.getContainsStrIgnoreCase(vararg testStrs: CharSequence?): String {
return StrUtil.getContainsStrIgnoreCase(this ?: "", *testStrs)
}
/**
* 获得set或get或is方法对应的标准属性名
* 例如：setName 返回 name
*
*
* getName =》name
* setName =》name
* isName =》name
*
*
* @param getOrSetMethodName Get或Set方法名
* @return 如果是set或get方法名，返回field， 否则null
*/
fun CharSequence.getGeneralField(): String {
return StrUtil.getGeneralField(this) ?: ""
}
/**
* 生成set方法名
* 例如：name 返回 setName
*
* @param fieldName 属性名
* @return setXxx
*/
fun CharSequence.genSetter(): String {
return StrUtil.genSetter(this)
}
/**
* 生成get方法名
*
* @param fieldName 属性名
* @return getXxx
*/
fun CharSequence.genGetter(): String {
return StrUtil.genGetter(this)
}
/**
* 移除字符串中所有给定字符串
* 例：removeAll("aa-bb-cc-dd", "-") =》 aabbccdd
*
* @param str 字符串
* @param strToRemove 被移除的字符串
* @return 移除后的字符串
*/
fun CharSequence?.removeAll(strToRemove: CharSequence?): String {
return StrUtil.removeAll(this ?: "", strToRemove ?: "")
}
/**
* 去除字符串中指定的多个字符，如有多个则全部去除
*
* @param str 字符串
* @param chars 字符列表
* @return 去除后的字符
* @since 4.2.2
*/
fun CharSequence?.removeAll(vararg chars: Char): String {
return StrUtil.removeAll(this ?: "", *chars)
}
/**
* 去除所有换行符，包括：
*
*
* 1. \r
* 1. \n
*
*
* @param str 字符串
* @return 处理后的字符串
* @since 4.2.2
*/
fun CharSequence?.removeAllLineBreaks(): String {
return StrUtil.removeAllLineBreaks(this ?: "")
}
/**
* 去掉首部指定长度的字符串并将剩余字符串首字母小写
* 例如：str=setName, preLength=3 =》 return name
*
* @param str 被处理的字符串
* @param preLength 去掉的长度
* @return 处理后的字符串，不符合规范返回null
*/
fun CharSequence?.removePreAndLowerFirst(preLength: Int): String {
return StrUtil.removePreAndLowerFirst(this ?: "", preLength)
}
/**
* 去掉首部指定长度的字符串并将剩余字符串首字母小写
* 例如：str=setName, prefix=set =》 return name
*
* @param str 被处理的字符串
* @param prefix 前缀
* @return 处理后的字符串，不符合规范返回null
*/
fun CharSequence?.removePreAndLowerFirst(prefix: CharSequence?): String {
return StrUtil.removePreAndLowerFirst(this ?: "", prefix ?: "")
}
/**
* 原字符串首字母大写并在其首部添加指定字符串 例如：str=name, preString=get =》 return getName
*
* @param str 被处理的字符串
* @param preString 添加的首部
* @return 处理后的字符串
*/
fun CharSequence?.upperFirstAndAddPre(preString: String?): String {
return StrUtil.upperFirstAndAddPre(this ?: "", preString ?: "")
}
/**
* 大写首字母
* 例如：str = name, return Name
*
* @param str 字符串
* @return 字符串
*/
fun CharSequence?.upperFirst(): String {
return StrUtil.upperFirst(this ?: "")
}
/**
* 小写首字母
* 例如：str = Name, return name
*
* @param str 字符串
* @return 字符串
*/
fun CharSequence?.lowerFirst(): String {
return StrUtil.lowerFirst(this ?: "")
}
/**
* 去掉指定前缀
*
* @param str 字符串
* @param prefix 前缀
* @return 切掉后的字符串，若前缀不是 preffix， 返回原字符串
*/
fun CharSequence?.removePrefix(prefix: CharSequence?): String {
return StrUtil.removePrefix(this ?: "", prefix ?: "")
}
/**
* 忽略大小写去掉指定前缀
*
* @param str 字符串
* @param prefix 前缀
* @return 切掉后的字符串，若前缀不是 prefix， 返回原字符串
*/
fun CharSequence?.removePrefixIgnoreCase(prefix: CharSequence?): String {
return StrUtil.removePrefixIgnoreCase(this ?: "", prefix ?: "")
}
/**
* 去掉指定后缀
*
* @param str 字符串
* @param suffix 后缀
* @return 切掉后的字符串，若后缀不是 suffix， 返回原字符串
*/
fun CharSequence?.removeSuffix(suffix: CharSequence?): String {
return StrUtil.removeSuffix(this ?: "", suffix ?: "")
}
/**
* 去掉指定后缀，并小写首字母
*
* @param str 字符串
* @param suffix 后缀
* @return 切掉后的字符串，若后缀不是 suffix， 返回原字符串
*/
fun CharSequence?.removeSufAndLowerFirst(suffix: CharSequence?): String {
return StrUtil.removeSufAndLowerFirst(this ?: "", suffix ?: "")
}
/**
* 忽略大小写去掉指定后缀
*
* @param str 字符串
* @param suffix 后缀
* @return 切掉后的字符串，若后缀不是 suffix， 返回原字符串
*/
fun CharSequence?.removeSuffixIgnoreCase(suffix: CharSequence?): String {
return StrUtil.removeSuffixIgnoreCase(this ?: "", suffix ?: "")
}
/**
* 去除两边的指定字符串
*
* @param str 被处理的字符串
* @param prefixOrSuffix 前缀或后缀
* @return 处理后的字符串
* @since 3.1.2
*/
fun CharSequence?.strip(prefixOrSuffix: CharSequence?): String {
return StrUtil.strip(this ?: "", prefixOrSuffix ?: "")
}
/**
* 去除两边的指定字符串
*
* @param str 被处理的字符串
* @param prefix 前缀
* @param suffix 后缀
* @return 处理后的字符串
* @since 3.1.2
*/
fun CharSequence?.strip(prefix: CharSequence?, suffix: CharSequence?): String {
return StrUtil.strip(this ?: "", prefix ?: "", suffix ?: "")
}
/**
* 去除两边的指定字符串，忽略大小写
*
* @param str 被处理的字符串
* @param prefixOrSuffix 前缀或后缀
* @return 处理后的字符串
* @since 3.1.2
*/
fun CharSequence?.stripIgnoreCase(prefixOrSuffix: CharSequence?): String {
return StrUtil.stripIgnoreCase(this ?: "", prefixOrSuffix ?: "")
}
/**
* 去除两边的指定字符串，忽略大小写
*
* @param str 被处理的字符串
* @param prefix 前缀
* @param suffix 后缀
* @return 处理后的字符串
* @since 3.1.2
*/
fun CharSequence?.stripIgnoreCase(prefix: CharSequence?, suffix: CharSequence?): String {
return StrUtil.stripIgnoreCase(this ?: "", prefix ?: "", suffix ?: "")
}
/**
* 如果给定字符串不是以prefix开头的，在开头补充 prefix
*
* @param str 字符串
* @param prefix 前缀
* @return 补充后的字符串
*/
fun CharSequence?.addPrefixIfNot(prefix: CharSequence?): String {
return StrUtil.addPrefixIfNot(this ?: "", prefix ?: "")
}
/**
* 如果给定字符串不是以suffix结尾的，在尾部补充 suffix
*
* @param str 字符串
* @param suffix 后缀
* @return 补充后的字符串
*/
fun CharSequence?.addSuffixIfNot(suffix: CharSequence?): String {
return StrUtil.addSuffixIfNot(this ?: "", suffix ?: "")
}
/**
* 清理空白字符
*
* @param str 被清理的字符串
* @return 清理后的字符串
*/
fun CharSequence?.cleanBlank(): String {
return StrUtil.cleanBlank(this ?: "")
}
/**
* 改进JDK subString
* index从0开始计算，最后一个字符为-1
* 如果from和to位置一样，返回 ""
* 如果from或to为负数，则按照length从后向前数位置，如果绝对值大于字符串长度，则from归到0，to归到length
* 如果经过修正的index中from大于to，则互换from和to example:
* abcdefgh 2 3 =》 c
* abcdefgh 2 -3 =》 cde
*
* @param str String
* @param fromIndex 开始的index（包括）
* @param toIndex 结束的index（不包括）
* @return 字串
*/
fun CharSequence?.sub(fromIndex: Int, toIndex: Int): String {
return StrUtil.sub(this ?: "", fromIndex, toIndex)
}
/**
* 通过CodePoint截取字符串，可以截断Emoji
*
* @param str String
* @param fromIndex 开始的index（包括）
* @param toIndex 结束的index（不包括）
* @return 字串
*/
fun CharSequence?.subByCodePoint(fromIndex: Int, toIndex: Int): String {
return StrUtil.subByCodePoint(this ?: "", fromIndex, toIndex)
}
/**
* 截取部分字符串，这里一个汉字的长度认为是2
*
* @param str 字符串
* @param len 切割的位置
* @param suffix 切割后加上后缀
* @return 切割后的字符串
* @since 3.1.1
*/
fun CharSequence?.subPreGbk(len: Int, suffix: CharSequence?): String {
return StrUtil.subPreGbk(this ?: "", len, suffix ?: "")
}
/**
* 限制字符串长度，如果超过指定长度，截取指定长度并在末尾加"..."
*
* @param string 字符串
* @param length 最大长度
* @return 切割后的剩余的前半部分字符串+"..."
* @since 4.0.10
*/
fun CharSequence?.maxLength(length: Int): String {
return StrUtil.maxLength(this ?: "", length)
}
/**
* 切割指定位置之前部分的字符串
*
* @param string 字符串
* @param toIndex 切割到的位置（不包括）
* @return 切割后的剩余的前半部分字符串
*/
fun CharSequence?.subPre(toIndex: Int): String {
return StrUtil.subPre(this ?: "", toIndex)
}
/**
* 切割指定位置之后部分的字符串
*
* @param string 字符串
* @param fromIndex 切割开始的位置（包括）
* @return 切割后后剩余的后半部分字符串
*/
fun CharSequence?.subSuf(fromIndex: Int): String {
return StrUtil.subSuf(this ?: "", fromIndex)
}
/**
* 切割指定长度的后部分的字符串
*
*
* StrUtil.subSufByLength("abcde", 3) = "cde"
* StrUtil.subSufByLength("abcde", 0) = ""
* StrUtil.subSufByLength("abcde", -5) = ""
* StrUtil.subSufByLength("abcde", -1) = ""
* StrUtil.subSufByLength("abcde", 5) = "abcde"
* StrUtil.subSufByLength("abcde", 10) = "abcde"
* StrUtil.subSufByLength(null, 3) = null
*
*
* @param string 字符串
* @param length 切割长度
* @return 切割后后剩余的后半部分字符串
* @since 4.0.1
*/
fun CharSequence?.subSufByLength(length: Int): String {
return StrUtil.subSufByLength(this ?: "", length)
}
/**
* 截取字符串,从指定位置开始,截取指定长度的字符串
* author weibaohui
*
* @param input 原始字符串
* @param fromIndex 开始的index,包括
* @param length 要截取的长度
* @return 截取后的字符串
*/
fun String?.subWithLength(fromIndex: Int, length: Int): String {
return StrUtil.subWithLength(this ?: "", fromIndex, length)
}
/**
* 截取分隔字符串之前的字符串，不包括分隔字符串
* 如果给定的字符串为空串（null或""）或者分隔字符串为null，返回原字符串
* 如果分隔字符串为空串""，则返回空串，如果分隔字符串未找到，返回原字符串，举例如下：
*
*
* StrUtil.subBefore(null, *, false) = null
* StrUtil.subBefore("", *, false) = ""
* StrUtil.subBefore("abc", "a", false) = ""
* StrUtil.subBefore("abcba", "b", false) = "a"
* StrUtil.subBefore("abc", "c", false) = "ab"
* StrUtil.subBefore("abc", "d", false) = "abc"
* StrUtil.subBefore("abc", "", false) = ""
* StrUtil.subBefore("abc", null, false) = "abc"
*
*
* @param string 被查找的字符串
* @param separator 分隔字符串（不包括）
* @param isLastSeparator 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
* @return 切割后的字符串
* @since 3.1.1
*/
fun CharSequence?.subBefore(separator: CharSequence?, isLastSeparator: Boolean): String {
return StrUtil.subBefore(this ?: "", separator, isLastSeparator)
}
/**
* 截取分隔字符串之前的字符串，不包括分隔字符串
* 如果给定的字符串为空串（null或""）或者分隔字符串为null，返回原字符串
* 如果分隔字符串未找到，返回原字符串，举例如下：
*
*
* StrUtil.subBefore(null, *, false) = null
* StrUtil.subBefore("", *, false) = ""
* StrUtil.subBefore("abc", 'a', false) = ""
* StrUtil.subBefore("abcba", 'b', false) = "a"
* StrUtil.subBefore("abc", 'c', false) = "ab"
* StrUtil.subBefore("abc", 'd', false) = "abc"
*
*
* @param string 被查找的字符串
* @param separator 分隔字符串（不包括）
* @param isLastSeparator 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
* @return 切割后的字符串
* @since 4.1.15
*/
fun CharSequence?.subBefore(separator: Char, isLastSeparator: Boolean): String {
return StrUtil.subBefore(this ?: "", separator, isLastSeparator)
}
/**
* 截取分隔字符串之后的字符串，不包括分隔字符串
* 如果给定的字符串为空串（null或""），返回原字符串
* 如果分隔字符串为空串（null或""），则返回空串，如果分隔字符串未找到，返回空串，举例如下：
*
*
* StrUtil.subAfter(null, *, false) = null
* StrUtil.subAfter("", *, false) = ""
* StrUtil.subAfter(*, null, false) = ""
* StrUtil.subAfter("abc", "a", false) = "bc"
* StrUtil.subAfter("abcba", "b", false) = "cba"
* StrUtil.subAfter("abc", "c", false) = ""
* StrUtil.subAfter("abc", "d", false) = ""
* StrUtil.subAfter("abc", "", false) = "abc"
*
*
* @param string 被查找的字符串
* @param separator 分隔字符串（不包括）
* @param isLastSeparator 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
* @return 切割后的字符串
* @since 3.1.1
*/
fun CharSequence?.subAfter(separator: CharSequence, isLastSeparator: Boolean): String {
return StrUtil.subAfter(this ?: "", separator, isLastSeparator)
}
/**
* 截取分隔字符串之后的字符串，不包括分隔字符串
* 如果给定的字符串为空串（null或""），返回原字符串
* 如果分隔字符串为空串（null或""），则返回空串，如果分隔字符串未找到，返回空串，举例如下：
*
*
* StrUtil.subAfter(null, *, false) = null
* StrUtil.subAfter("", *, false) = ""
* StrUtil.subAfter("abc", 'a', false) = "bc"
* StrUtil.subAfter("abcba", 'b', false) = "cba"
* StrUtil.subAfter("abc", 'c', false) = ""
* StrUtil.subAfter("abc", 'd', false) = ""
*
*
* @param string 被查找的字符串
* @param separator 分隔字符串（不包括）
* @param isLastSeparator 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
* @return 切割后的字符串
* @since 4.1.15
*/
fun CharSequence?.subAfter(separator: Char, isLastSeparator: Boolean): String {
return StrUtil.subAfter(this ?: "", separator, isLastSeparator)
}
/**
* 截取指定字符串中间部分，不包括标识字符串
*
*
* 栗子：
*
*
* StrUtil.subBetween("wx[b]yz", "[", "]") = "b"
* StrUtil.subBetween(null, *, *) = null
* StrUtil.subBetween(*, null, *) = null
* StrUtil.subBetween(*, *, null) = null
* StrUtil.subBetween("", "", "") = ""
* StrUtil.subBetween("", "", "]") = null
* StrUtil.subBetween("", "[", "]") = null
* StrUtil.subBetween("yabcz", "", "") = ""
* StrUtil.subBetween("yabcz", "y", "z") = "abc"
* StrUtil.subBetween("yabczyabcz", "y", "z") = "abc"
*
*
* @param str 被切割的字符串
* @param before 截取开始的字符串标识
* @param after 截取到的字符串标识
* @return 截取后的字符串
* @since 3.1.1
*/
fun CharSequence?.subBetween(before: CharSequence?, after: CharSequence?): String {
return StrUtil.subBetween(this ?: "", before ?: "", after ?: "")
}
/**
* 截取指定字符串中间部分，不包括标识字符串
*
*
* 栗子：
*
*
* StrUtil.subBetween(null, *) = null
* StrUtil.subBetween("", "") = ""
* StrUtil.subBetween("", "tag") = null
* StrUtil.subBetween("tagabctag", null) = null
* StrUtil.subBetween("tagabctag", "") = ""
* StrUtil.subBetween("tagabctag", "tag") = "abc"
*
*
* @param str 被切割的字符串
* @param beforeAndAfter 截取开始和结束的字符串标识
* @return 截取后的字符串
* @since 3.1.1
*/
fun CharSequence?.subBetween(beforeAndAfter: CharSequence?): String {
return StrUtil.subBetween(this ?: "", beforeAndAfter ?: "")
}
/**
* 给定字符串是否被字符包围
*
* @param str 字符串
* @param prefix 前缀
* @param suffix 后缀
* @return 是否包围，空串不包围
*/
fun CharSequence?.isSurround(prefix: CharSequence?, suffix: CharSequence?): Boolean {
return StrUtil.isSurround(this ?: "", prefix ?: "", suffix ?: "")
}
/**
* 给定字符串是否被字符包围
*
* @param str 字符串
* @param prefix 前缀
* @param suffix 后缀
* @return 是否包围，空串不包围
*/
fun CharSequence?.isSurround(prefix: Char, suffix: Char): Boolean {
return StrUtil.isSurround(this ?: "", prefix, suffix)
}
/**
* 重复某个字符
*
* @param c 被重复的字符
* @param count 重复的数目，如果小于等于0则返回""
* @return 重复字符字符串
*/
fun repeat(c: Char, count: Int): String {
return StrUtil.repeat(c, count)
}
/**
* 重复某个字符串
*
* @param str 被重复的字符
* @param count 重复的数目
* @return 重复字符字符串
*/
fun CharSequence?.repeat(count: Int): String {
return StrUtil.repeat(this ?: "", count)
}
/**
* 重复某个字符串到指定长度
*
* @param str 被重复的字符
* @param padLen 指定长度
* @return 重复字符字符串
* @since 4.3.2
*/
fun CharSequence?.repeatByLength(padLen: Int): String {
return StrUtil.repeatByLength(this ?: "", padLen)
}
/**
* 重复某个字符串并通过分界符连接
*
*
* StrUtil.repeatAndJoin("?", 5, ",") = "?,?,?,?,?"
* StrUtil.repeatAndJoin("?", 0, ",") = ""
* StrUtil.repeatAndJoin("?", 5, null) = "?????"
*
*
* @param str 被重复的字符串
* @param count 数量
* @param conjunction 分界符
* @return 连接后的字符串
* @since 4.0.1
*/
fun CharSequence?.repeatAndJoin(count: Int, conjunction: CharSequence?): String {
return StrUtil.repeatAndJoin(this ?: "", count, conjunction ?: ",")
}
/**
* 比较两个字符串（大小写敏感）。
*
*
* equals(null, null) = true
* equals(null, "abc") = false
* equals("abc", null) = false
* equals("abc", "abc") = true
* equals("abc", "ABC") = false
*
*
* @param str1 要比较的字符串1
* @param str2 要比较的字符串2
* @return 如果两个字符串相同，或者都是`null`，则返回`true`
*/
fun CharSequence?.equals(str2: CharSequence?): Boolean {
return StrUtil.equals(this, str2)
}
/**
* 比较两个字符串（大小写不敏感）。
*
*
* equalsIgnoreCase(null, null) = true
* equalsIgnoreCase(null, "abc") = false
* equalsIgnoreCase("abc", null) = false
* equalsIgnoreCase("abc", "abc") = true
* equalsIgnoreCase("abc", "ABC") = true
*
*
* @param str1 要比较的字符串1
* @param str2 要比较的字符串2
* @return 如果两个字符串相同，或者都是`null`，则返回`true`
*/
fun CharSequence?.equalsIgnoreCase(str2: CharSequence?): Boolean {
return StrUtil.equalsIgnoreCase(this, str2)
}
/**
* 比较两个字符串是否相等。
*
* @param str1 要比较的字符串1
* @param str2 要比较的字符串2
* @param ignoreCase 是否忽略大小写
* @return 如果两个字符串相同，或者都是`null`，则返回`true`
* @since 3.2.0
*/
fun CharSequence?.equals(str2: CharSequence?, ignoreCase: Boolean): Boolean {
return StrUtil.equals(this, str2, ignoreCase)
}
/**
* 将对象转为字符串
* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
*
* @param obj 对象
* @return 字符串
*/
fun Any?.utf8Str(): String {
this ?: return ""
return StrUtil.utf8Str(this)
}
/**
* 将对象转为字符串
*
*
* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组
* 2、对象数组会调用Arrays.toString方法
*
*
* @param obj 对象
* @param charsetName 字符集
* @return 字符串
*/
fun Any?.str(charsetName: String): String {
return StrUtil.str(this ?: return "", charsetName)
}
/**
* 将对象转为字符串
*
* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组
* 2、对象数组会调用Arrays.toString方法
*
*
* @param obj 对象
* @param charset 字符集
* @return 字符串
*/
fun Any?.str(charset: Charset): String {
return StrUtil.str(this ?: return "", charset)
}
/**
* 将byte数组转为字符串
*
* @param bytes byte数组
* @param charset 字符集
* @return 字符串
*/
fun ByteArray?.str(charset: String): String {
return StrUtil.str(this ?: return "", charset)
}
/**
* 解码字节码
*
* @param data 字符串
* @param charset 字符集，如果此字段为空，则解码的结果取决于平台
* @return 解码后的字符串
*/
fun ByteArray?.str(charset: Charset?): String {
return StrUtil.str(this ?: return "", charset ?: Charsets.UTF_8)
}
/**
* 将Byte数组转为字符串
*
* @param bytes byte数组
* @param charset 字符集
* @return 字符串
*/
fun Array?.str(bytes: Array?, charset: String?): String {
this ?: return ""
return StrUtil.str(this, charset ?: Charsets.UTF_8.name())
}
/**
* 解码字节码
*
* @param data 字符串
* @param charset 字符集，如果此字段为空，则解码的结果取决于平台
* @return 解码后的字符串
*/
fun Array?.str(charset: Charset?): String {
return StrUtil.str(this ?: return "", charset ?: Charsets.UTF_8)
}
/**
* 将编码的byteBuffer数据转换为字符串
*
* @param data 数据
* @param charset 字符集，如果为空使用当前系统字符集
* @return 字符串
*/
fun ByteBuffer?.str(charset: String?): String {
return StrUtil.str(this ?: return "", charset ?: Charsets.UTF_8.name())
}
/**
* 将编码的byteBuffer数据转换为字符串
*
* @param data 数据
* @param charset 字符集，如果为空使用当前系统字符集
* @return 字符串
*/
fun ByteBuffer?.str(charset: Charset?): String {
return StrUtil.str(this ?: return "", charset ?: Charsets.UTF_8)
}
/**
* 字符串转换为byteBuffer
*
* @param str 字符串
* @param charset 编码
* @return byteBuffer
*/
fun CharSequence?.byteBuffer(charset: String?): ByteBuffer {
return StrUtil.byteBuffer(this ?: "", charset ?: Charsets.UTF_8.name())
}
/**
* 将驼峰式命名的字符串转换为下划线方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。
* 例如：
*
*
* HelloWorld=》hello_world
* Hello_World=》hello_world
* HelloWorld_test=》hello_world_test
*
*
* @param str 转换前的驼峰式命名的字符串，也可以为下划线形式
* @return 转换后下划线方式命名的字符串
*/
fun CharSequence?.toUnderlineCase(): String {
return StrUtil.toUnderlineCase(this ?: return "")
}
/**
* 将驼峰式命名的字符串转换为使用符号连接方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。
*
* @param str 转换前的驼峰式命名的字符串，也可以为符号连接形式
* @param symbol 连接符
* @return 转换后符号连接方式命名的字符串
* @since 4.0.10
*/
fun CharSequence?.toSymbolCase(symbol: Char): String {
return StrUtil.toSymbolCase(this ?: return "", symbol)
}
/**
* 将下划线方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。
* 例如：hello_world=》helloWorld
*
* @param name 转换前的下划线大写方式命名的字符串
* @return 转换后的驼峰式命名的字符串
*/
fun CharSequence?.toCamelCase(): String {
return StrUtil.toCamelCase(this ?: return "")
}
/**
* 包装指定字符串
* 当前缀和后缀一致时使用此方法
*
* @param str 被包装的字符串
* @param prefixAndSuffix 前缀和后缀
* @return 包装后的字符串
* @since 3.1.0
*/
fun CharSequence?.wrap(prefixAndSuffix: CharSequence?): String {
return StrUtil.wrap(this ?: "", prefixAndSuffix ?: "")
}
/**
* 包装指定字符串
*
* @param str 被包装的字符串
* @param prefix 前缀
* @param suffix 后缀
* @return 包装后的字符串
*/
fun CharSequence?.wrap(prefix: CharSequence?, suffix: CharSequence?): String {
return StrUtil.wrap(this ?: "", prefix ?: "", suffix ?: "")
}
/**
* 包装指定字符串，如果前缀或后缀已经包含对应的字符串，则不再包装
*
* @param str 被包装的字符串
* @param prefix 前缀
* @param suffix 后缀
* @return 包装后的字符串
*/
fun CharSequence?.wrapIfMissing(prefix: CharSequence?, suffix: CharSequence?): String {
return StrUtil.wrapIfMissing(this ?: "", prefix ?: "", suffix ?: "")
}
/**
* 去掉字符包装，如果未被包装则返回原字符串
*
* @param str 字符串
* @param prefix 前置字符串
* @param suffix 后置字符串
* @return 去掉包装字符的字符串
* @since 4.0.1
*/
fun CharSequence?.unWrap(prefix: String?, suffix: String?): String {
return StrUtil.unWrap(this ?: "", prefix ?: "", suffix ?: "")
}
/**
* 去掉字符包装，如果未被包装则返回原字符串
*
* @param str 字符串
* @param prefix 前置字符
* @param suffix 后置字符
* @return 去掉包装字符的字符串
* @since 4.0.1
*/
fun CharSequence?.unWrap(prefix: Char, suffix: Char): String {
return StrUtil.unWrap(this ?: "", prefix, suffix)
}
/**
* 去掉字符包装，如果未被包装则返回原字符串
*
* @param str 字符串
* @param prefixAndSuffix 前置和后置字符
* @return 去掉包装字符的字符串
* @since 4.0.1
*/
fun CharSequence?.unWrap(prefixAndSuffix: Char): String {
return StrUtil.unWrap(this ?: "", prefixAndSuffix)
}
/**
* 指定字符串是否被包装
*
* @param str 字符串
* @param prefix 前缀
* @param suffix 后缀
* @return 是否被包装
*/
fun CharSequence?.isWrap(prefix: String?, suffix: String?): Boolean {
return StrUtil.isWrap(this ?: "", prefix ?: "", suffix ?: "")
}
/**
* 指定字符串是否被同一字符包装（前后都有这些字符串）
*
* @param str 字符串
* @param wrapper 包装字符串
* @return 是否被包装
*/
fun CharSequence?.isWrap(wrapper: String?): Boolean {
return StrUtil.isWrap(this ?: "", wrapper ?: "")
}
/**
* 指定字符串是否被同一字符包装（前后都有这些字符串）
*
* @param str 字符串
* @param wrapper 包装字符
* @return 是否被包装
*/
fun CharSequence?.isWrap(wrapper: Char): Boolean {
return StrUtil.isWrap(this ?: "", wrapper)
}
/**
* 指定字符串是否被包装
*
* @param str 字符串
* @param prefixChar 前缀
* @param suffixChar 后缀
* @return 是否被包装
*/
fun CharSequence?.isWrap(prefixChar: Char, suffixChar: Char): Boolean {
return StrUtil.isWrap(this ?: "", prefixChar, suffixChar)
}
/**
* 补充字符串以满足最小长度
*
*
* StrUtil.padPre(null, *, *);//null
* StrUtil.padPre("1", 3, "ABC");//"AB1"
* StrUtil.padPre("123", 2, "ABC");//"12"
*
*
* @param str 字符串
* @param minLength 最小长度
* @param padStr 补充的字符
* @return 补充后的字符串
*/
fun CharSequence?.padPre(minLength: Int, padStr: CharSequence?): String {
return StrUtil.padPre(this ?: "", minLength, padStr ?: "")
}
/**
* 补充字符串以满足最小长度
*
*
* StrUtil.padPre(null, *, *);//null
* StrUtil.padPre("1", 3, '0');//"001"
* StrUtil.padPre("123", 2, '0');//"12"
*
*
* @param str 字符串
* @param minLength 最小长度
* @param padChar 补充的字符
* @return 补充后的字符串
*/
fun CharSequence?.padPre(minLength: Int, padChar: Char): String {
return StrUtil.padPre(this ?: "", minLength, padChar)
}
/**
* 补充字符串以满足最小长度
*
*
* StrUtil.padAfter(null, *, *);//null
* StrUtil.padAfter("1", 3, '0');//"100"
* StrUtil.padAfter("123", 2, '0');//"23"
*
*
* @param str 字符串，如果为`null`，直接返回null
* @param minLength 最小长度
* @param padChar 补充的字符
* @return 补充后的字符串
*/
fun CharSequence?.padAfter(minLength: Int, padChar: Char): String {
return StrUtil.padAfter(this ?: "", minLength, padChar)
}
/**
* 补充字符串以满足最小长度
*
*
* StrUtil.padAfter(null, *, *);//null
* StrUtil.padAfter("1", 3, "ABC");//"1AB"
* StrUtil.padAfter("123", 2, "ABC");//"23"
*
*
* @param str 字符串，如果为`null`，直接返回null
* @param minLength 最小长度
* @param padStr 补充的字符
* @return 补充后的字符串
* @since 4.3.2
*/
fun CharSequence?.padAfter(minLength: Int, padStr: CharSequence?): String {
return StrUtil.padAfter(this ?: "", minLength, padStr ?: "")
}
/**
* 居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串
*
*
* StrUtil.center(null, *) = null
* StrUtil.center("", 4) = " "
* StrUtil.center("ab", -1) = "ab"
* StrUtil.center("ab", 4) = " ab "
* StrUtil.center("abcd", 2) = "abcd"
* StrUtil.center("a", 4) = " a "
*
*
* @param str 字符串
* @param size 指定长度
* @return 补充后的字符串
* @since 4.3.2
*/
fun CharSequence?.center(size: Int): String {
return StrUtil.center(this ?: "", size)
}
/**
* 居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串
*
*
* StrUtil.center(null, *, *) = null
* StrUtil.center("", 4, ' ') = " "
* StrUtil.center("ab", -1, ' ') = "ab"
* StrUtil.center("ab", 4, ' ') = " ab "
* StrUtil.center("abcd", 2, ' ') = "abcd"
* StrUtil.center("a", 4, ' ') = " a "
* StrUtil.center("a", 4, 'y') = "yayy"
* StrUtil.center("abc", 7, ' ') = " abc "
*
*
* @param str 字符串
* @param size 指定长度
* @param padChar 两边补充的字符
* @return 补充后的字符串
* @since 4.3.2
*/
fun CharSequence?.center(size: Int, padChar: Char): String {
return StrUtil.center(this ?: "", size, padChar)
}
/**
* 居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串
*
*
* StrUtil.center(null, *, *) = null
* StrUtil.center("", 4, " ") = " "
* StrUtil.center("ab", -1, " ") = "ab"
* StrUtil.center("ab", 4, " ") = " ab "
* StrUtil.center("abcd", 2, " ") = "abcd"
* StrUtil.center("a", 4, " ") = " a "
* StrUtil.center("a", 4, "yz") = "yayz"
* StrUtil.center("abc", 7, null) = " abc "
* StrUtil.center("abc", 7, "") = " abc "
*
*
* @param str 字符串
* @param size 指定长度
* @param padStr 两边补充的字符串
* @return 补充后的字符串
*/
fun CharSequence?.center(size: Int, padStr: CharSequence?): String {
return StrUtil.center(this ?: "", size, padStr ?: "")
}
/**
* 创建StringBuilder对象
*
* @return StringBuilder对象
*/
fun String.builder(): StringBuilder {
return StrUtil.builder(this)
}
/**
* 获得StringReader
*
* @param str 字符串
* @return StringReader
*/
fun CharSequence?.getReader(): StringReader {
return StrUtil.getReader(this ?: "")
}
/**
* 统计指定内容中包含指定字符的数量
*
* @param content 内容
* @param charForSearch 被统计的字符
* @return 包含数量
*/
fun count(content: CharSequence?, charForSearch: Char): Int {
return StrUtil.count(content ?: "", charForSearch)
}
/**
* 将给定字符串，变成 "xxx...xxx" 形式的字符串
*
* @param str 字符串
* @param maxLength 最大长度
* @return 截取后的字符串
*/
fun CharSequence?.brief(maxLength: Int): String {
return StrUtil.brief(this ?: "", maxLength)
}
/**
* 比较两个版本
* null版本排在最小：即：
*
*
* StrUtil.compareVersion(null, "v1") < 0
* StrUtil.compareVersion("v1", "v1") = 0
* StrUtil.compareVersion(null, null) = 0
* StrUtil.compareVersion("v1", null) > 0
* StrUtil.compareVersion("1.0.0", "1.0.2") < 0
* StrUtil.compareVersion("1.0.2", "1.0.2a") < 0
* StrUtil.compareVersion("1.13.0", "1.12.1c") > 0
* StrUtil.compareVersion("V0.0.20170102", "V0.0.20170101") > 0
*
*
* @param version1 版本1
* @param version2 版本2
* @return 排序值。负数：version1 < version2，正数：version1 > version2, 0：version1 == version2
* @since 4.0.2
*/
fun CharSequence?.compareVersion(version2: CharSequence?): Int {
return StrUtil.compareVersion(this, version2)
}
/**
* 指定范围内查找指定字符
*
* @param str 字符串
* @param searchChar 被查找的字符
* @return 位置
*/
fun CharSequence?.indexOf(searchChar: Char): Int {
return StrUtil.indexOf(this ?: "", searchChar)
}
/**
* 指定范围内查找指定字符
*
* @param str 字符串
* @param searchChar 被查找的字符
* @param start 起始位置，如果小于0，从0开始查找
* @return 位置
*/
fun CharSequence?.indexOf(searchChar: Char, start: Int): Int {
return StrUtil.indexOf(this ?: "", searchChar, start)
}
/**
* 指定范围内查找指定字符
*
* @param str 字符串
* @param searchChar 被查找的字符
* @param start 起始位置，如果小于0，从0开始查找
* @param end 终止位置，如果超过str.length()则默认查找到字符串末尾
* @return 位置
*/
fun CharSequence?.indexOf(searchChar: Char, start: Int, end: Int): Int {
return StrUtil.indexOf(this ?: "", searchChar, start, end)
}
/**
* 指定范围内查找字符串，忽略大小写
*
*
* StrUtil.indexOfIgnoreCase(null, *, *) = -1
* StrUtil.indexOfIgnoreCase(*, null, *) = -1
* StrUtil.indexOfIgnoreCase("", "", 0) = 0
* StrUtil.indexOfIgnoreCase("aabaabaa", "A", 0) = 0
* StrUtil.indexOfIgnoreCase("aabaabaa", "B", 0) = 2
* StrUtil.indexOfIgnoreCase("aabaabaa", "AB", 0) = 1
* StrUtil.indexOfIgnoreCase("aabaabaa", "B", 3) = 5
* StrUtil.indexOfIgnoreCase("aabaabaa", "B", 9) = -1
* StrUtil.indexOfIgnoreCase("aabaabaa", "B", -1) = 2
* StrUtil.indexOfIgnoreCase("aabaabaa", "", 2) = 2
* StrUtil.indexOfIgnoreCase("abc", "", 9) = -1
*
*
* @param str 字符串
* @param searchStr 需要查找位置的字符串
* @return 位置
* @since 3.2.1
*/
fun CharSequence?.indexOfIgnoreCase(searchStr: CharSequence?): Int {
return StrUtil.indexOfIgnoreCase(this ?: "", searchStr ?: "")
}
/**
* 指定范围内查找字符串
*
*
* StrUtil.indexOfIgnoreCase(null, *, *) = -1
* StrUtil.indexOfIgnoreCase(*, null, *) = -1
* StrUtil.indexOfIgnoreCase("", "", 0) = 0
* StrUtil.indexOfIgnoreCase("aabaabaa", "A", 0) = 0
* StrUtil.indexOfIgnoreCase("aabaabaa", "B", 0) = 2
* StrUtil.indexOfIgnoreCase("aabaabaa", "AB", 0) = 1
* StrUtil.indexOfIgnoreCase("aabaabaa", "B", 3) = 5
* StrUtil.indexOfIgnoreCase("aabaabaa", "B", 9) = -1
* StrUtil.indexOfIgnoreCase("aabaabaa", "B", -1) = 2
* StrUtil.indexOfIgnoreCase("aabaabaa", "", 2) = 2
* StrUtil.indexOfIgnoreCase("abc", "", 9) = -1
*
*
* @param str 字符串
* @param searchStr 需要查找位置的字符串
* @param fromIndex 起始位置
* @return 位置
* @since 3.2.1
*/
fun CharSequence?.indexOfIgnoreCase(searchStr: CharSequence?, fromIndex: Int): Int {
return StrUtil.indexOfIgnoreCase(this ?: "", searchStr ?: "", fromIndex)
}
/**
* 指定范围内查找字符串
*
* @param str 字符串
* @param searchStr 需要查找位置的字符串
* @param fromIndex 起始位置
* @param ignoreCase 是否忽略大小写
* @return 位置
* @since 3.2.1
*/
fun CharSequence?.indexOf(searchStr: CharSequence?, fromIndex: Int, ignoreCase: Boolean): Int {
return StrUtil.indexOf(this ?: "", searchStr ?: "", fromIndex, ignoreCase)
}
/**
* 指定范围内查找字符串，忽略大小写
*
* @param str 字符串
* @param searchStr 需要查找位置的字符串
* @return 位置
* @since 3.2.1
*/
fun CharSequence?.lastIndexOfIgnoreCase(searchStr: CharSequence?): Int {
return StrUtil.lastIndexOfIgnoreCase(this ?: "", searchStr ?: "")
}
/**
* 指定范围内查找字符串，忽略大小写
* fromIndex 为搜索起始位置，从后往前计数
*
* @param str 字符串
* @param searchStr 需要查找位置的字符串
* @param fromIndex 起始位置，从后往前计数
* @return 位置
* @since 3.2.1
*/
fun CharSequence?.lastIndexOfIgnoreCase(searchStr: CharSequence?, fromIndex: Int): Int {
return StrUtil.lastIndexOfIgnoreCase(this ?: "", searchStr ?: "", fromIndex)
}
/**
* 指定范围内查找字符串
* fromIndex 为搜索起始位置，从后往前计数
*
* @param str 字符串
* @param searchStr 需要查找位置的字符串
* @param fromIndex 起始位置，从后往前计数
* @param ignoreCase 是否忽略大小写
* @return 位置
* @since 3.2.1
*/
fun CharSequence?.lastIndexOf(searchStr: CharSequence?, fromIndex: Int, ignoreCase: Boolean): Int {
return StrUtil.lastIndexOf(this ?: "", searchStr ?: "", fromIndex, ignoreCase)
}
/**
* 返回字符串 searchStr 在字符串 str 中第 ordinal 次出现的位置。
*
*
*
* 如果 str=null 或 searchStr=null 或 ordinal0 则返回-1
* 此方法来自：Apache-Commons-Lang
*
*
* 例子（*代表任意字符）：
*
*
* StrUtil.ordinalIndexOf(null, *, *) = -1
* StrUtil.ordinalIndexOf(*, null, *) = -1
* StrUtil.ordinalIndexOf("", "", *) = 0
* StrUtil.ordinalIndexOf("aabaabaa", "a", 1) = 0
* StrUtil.ordinalIndexOf("aabaabaa", "a", 2) = 1
* StrUtil.ordinalIndexOf("aabaabaa", "b", 1) = 2
* StrUtil.ordinalIndexOf("aabaabaa", "b", 2) = 5
* StrUtil.ordinalIndexOf("aabaabaa", "ab", 1) = 1
* StrUtil.ordinalIndexOf("aabaabaa", "ab", 2) = 4
* StrUtil.ordinalIndexOf("aabaabaa", "", 1) = 0
* StrUtil.ordinalIndexOf("aabaabaa", "", 2) = 0
*
*
* @param str 被检查的字符串，可以为null
* @param searchStr 被查找的字符串，可以为null
* @param ordinal 第几次出现的位置
* @return 查找到的位置
* @since 3.2.3
*/
fun String?.ordinalIndexOf(searchStr: String?, ordinal: Int): Int {
return StrUtil.ordinalIndexOf(this ?: "", searchStr, ordinal)
}
/**
* 如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串
* 不忽略大小写
*
* @param str 被检查的字符串
* @param suffix 需要添加到结尾的字符串
* @param suffixes 需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加
* @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串
* @since 3.0.7
*/
fun CharSequence?.appendIfMissing(suffix: CharSequence?, vararg suffixes: CharSequence?): String {
return StrUtil.appendIfMissing(this ?: "", suffix ?: "", *suffixes)
}
/**
* 如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串
* 忽略大小写
*
* @param str 被检查的字符串
* @param suffix 需要添加到结尾的字符串
* @param suffixes 需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加
* @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串
* @since 3.0.7
*/
fun CharSequence?.appendIfMissingIgnoreCase(suffix: CharSequence?, vararg suffixes: CharSequence?): String {
return StrUtil.appendIfMissingIgnoreCase(this ?: "", suffix, *suffixes)
}
/**
* 如果给定字符串不是以给定的一个或多个字符串为开头，则在首部添加起始字符串
* 不忽略大小写
*
* @param str 被检查的字符串
* @param prefix 需要添加到首部的字符串
* @param prefixes 需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加
* @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串
* @since 3.0.7
*/
fun CharSequence?.prependIfMissing(prefix: CharSequence?, vararg prefixes: CharSequence?): String {
return StrUtil.prependIfMissing(this ?: "", prefix, *prefixes)
}
/**
* 如果给定字符串不是以给定的一个或多个字符串为开头，则在首部添加起始字符串
* 忽略大小写
*
* @param str 被检查的字符串
* @param prefix 需要添加到首部的字符串
* @param prefixes 需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加
* @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串
* @since 3.0.7
*/
fun CharSequence?.prependIfMissingIgnoreCase(prefix: CharSequence?, vararg prefixes: CharSequence?): String {
return StrUtil.prependIfMissingIgnoreCase(this ?: "", prefix, *prefixes)
}
/**
* 反转字符串
* 例如：abcd =》dcba
*
* @param str 被反转的字符串
* @return 反转后的字符串
* @since 3.0.9
*/
fun String?.reverse(): String {
return StrUtil.reverse(this ?: "")
}
/**
* 将已有字符串填充为规定长度，如果已有字符串超过这个长度则返回这个字符串
* 字符填充于字符串前
*
* @param str 被填充的字符串
* @param filledChar 填充的字符
* @param len 填充长度
* @return 填充后的字符串
* @since 3.1.2
*/
fun String?.fillBefore(filledChar: Char, len: Int): String {
return StrUtil.fillBefore(this ?: "", filledChar, len)
}
/**
* 将已有字符串填充为规定长度，如果已有字符串超过这个长度则返回这个字符串
* 字符填充于字符串后
*
* @param str 被填充的字符串
* @param filledChar 填充的字符
* @param len 填充长度
* @return 填充后的字符串
* @since 3.1.2
*/
fun String?.fillAfter(filledChar: Char, len: Int): String {
return StrUtil.fillAfter(this ?: "", filledChar, len)
}
/**
* 截取两个字符串的不同部分（长度一致），判断截取的子串是否相同
* 任意一个字符串为null返回false
*
* @param str1 第一个字符串
* @param start1 第一个字符串开始的位置
* @param str2 第二个字符串
* @param start2 第二个字符串开始的位置
* @param length 截取长度
* @param ignoreCase 是否忽略大小写
* @return 子串是否相同
* @since 3.2.1
*/
fun CharSequence?.isSubEquals(
start1: Int,
str2: CharSequence?,
start2: Int,
length: Int,
ignoreCase: Boolean
): Boolean {
return StrUtil.isSubEquals(this, start1, str2, start2, length, ignoreCase)
}
/**
* 字符串的每一个字符是否都与定义的匹配器匹配
*
* @param value 字符串
* @param matcher 匹配器
* @return 是否全部匹配
* @since 3.2.3
*/
fun CharSequence?.isAllCharMatch(matcher: cn.hutool.core.lang.Matcher): Boolean {
return StrUtil.isAllCharMatch(this ?: "", matcher)
}
/**
* 替换字符串中的指定字符串，忽略大小写
*
* @param str 字符串
* @param searchStr 被查找的字符串
* @param replacement 被替换的字符串
* @return 替换后的字符串
* @since 4.0.3
*/
fun CharSequence?.replaceIgnoreCase(searchStr: CharSequence?, replacement: CharSequence?): String {
return StrUtil.replaceIgnoreCase(this ?: "", searchStr ?: "", replacement ?: "")
}
/**
* 替换字符串中的指定字符串
*
* @param str 字符串
* @param searchStr 被查找的字符串
* @param replacement 被替换的字符串
* @return 替换后的字符串
* @since 4.0.3
*/
fun CharSequence?.replace(searchStr: CharSequence?, replacement: CharSequence?): String {
return StrUtil.replace(this ?: "", searchStr ?: "", replacement ?: "")
}
/**
* 替换字符串中的指定字符串
*
* @param str 字符串
* @param searchStr 被查找的字符串
* @param replacement 被替换的字符串
* @param ignoreCase 是否忽略大小写
* @return 替换后的字符串
* @since 4.0.3
*/
fun CharSequence?.replace(
searchStr: CharSequence?,
replacement: CharSequence?,
ignoreCase: Boolean
): String {
return StrUtil.replace(this ?: "", searchStr ?: "", replacement ?: "", ignoreCase)
}
/**
* 替换字符串中的指定字符串
*
* @param str 字符串
* @param fromIndex 开始位置（包括）
* @param searchStr 被查找的字符串
* @param replacement 被替换的字符串
* @param ignoreCase 是否忽略大小写
* @return 替换后的字符串
* @since 4.0.3
*/
fun CharSequence?.replace(
fromIndex: Int,
searchStr: CharSequence?,
replacement: CharSequence?,
ignoreCase: Boolean
): String {
return StrUtil.replace(this ?: "", fromIndex, searchStr ?: "", replacement ?: "", ignoreCase)
}
/**
* 替换指定字符串的指定区间内字符为固定字符
*
* @param str 字符串
* @param startInclude 开始位置（包含）
* @param endExclude 结束位置（不包含）
* @param replacedChar 被替换的字符
* @return 替换后的字符串
* @since 3.2.1
*/
fun CharSequence?.replace(startInclude: Int, endExclude: Int, replacedChar: Char): String {
return StrUtil.replace(this ?: "", startInclude, endExclude, replacedChar)
}
/**
* 替换指定字符串的指定区间内字符为"*"
*
* @param str 字符串
* @param startInclude 开始位置（包含）
* @param endExclude 结束位置（不包含）
* @return 替换后的字符串
* @since 4.1.14
*/
fun CharSequence?.hide(startInclude: Int, endExclude: Int): String {
return StrUtil.hide(this ?: "", startInclude, endExclude)
}
/**
* 替换字符字符数组中所有的字符为replacedStr
* 提供的chars为所有需要被替换的字符，例如："\r\n"，则"\r"和"\n"都会被替换，哪怕他们单独存在
*
* @param str 被检查的字符串
* @param chars 需要替换的字符列表，用一个字符串表示这个字符列表
* @param replacedStr 替换成的字符串
* @return 新字符串
* @since 3.2.2
*/
fun CharSequence?.replaceChars(chars: String?, replacedStr: CharSequence?): String {
return StrUtil.replaceChars(this ?: "", chars ?: "", replacedStr ?: "")
}
/**
* 替换字符字符数组中所有的字符为replacedStr
*
* @param str 被检查的字符串
* @param chars 需要替换的字符列表
* @param replacedStr 替换成的字符串
* @return 新字符串
* @since 3.2.2
*/
fun CharSequence?.replaceChars(chars: CharArray?, replacedStr: CharSequence?): String {
return StrUtil.replaceChars(this ?: "", chars, replacedStr ?: "")
}
/**
* 计算两个字符串的相似度
*
* @param str1 字符串1
* @param str2 字符串2
* @return 相似度
* @since 3.2.3
*/
fun String?.similar(str2: String?): Double {
return StrUtil.similar(this ?: "", str2)
}
/**
* 计算连个字符串的相似度百分比
*
* @param str1 字符串1
* @param str2 字符串2
* @param scale 相似度
* @return 相似度百分比
* @since 3.2.3
*/
fun String?.similar(str2: String?, scale: Int): String {
return StrUtil.similar(this ?: "", str2 ?: "", scale)
}
/**
* 字符串指定位置的字符是否与给定字符相同
* 如果字符串为null，返回false
* 如果给定的位置大于字符串长度，返回false
* 如果给定的位置小于0，返回false
*
* @param str 字符串
* @param position 位置
* @param c 需要对比的字符
* @return 字符串指定位置的字符是否与给定字符相同
* @since 3.3.1
*/
fun CharSequence?.equalsCharAt(position: Int, c: Char): Boolean {
return StrUtil.equalsCharAt(this ?: "", position, c)
}
/**
* 给定字符串数组的总长度
* null字符长度定义为0
*
* @param strs 字符串数组
* @return 总长度
* @since 4.0.1
*/
fun Collection.totalLength(): Int {
return StrUtil.totalLength(*this.toTypedArray())
}
/**
* 循环位移指定位置的字符串为指定距离
* 当moveLength大于0向右位移，小于0向左位移，0不位移
* 当moveLength大于字符串长度时采取循环位移策略，即位移到头后从头（尾）位移，例如长度为10，位移13则表示位移3
*
* @param str 字符串
* @param startInclude 起始位置（包括）
* @param endExclude 结束位置（不包括）
* @param moveLength 移动距离，负数表示左移，正数为右移
* @return 位移后的字符串
* @since 4.0.7
*/
fun CharSequence?.move(startInclude: Int, endExclude: Int, moveLength: Int): String {
return StrUtil.move(this ?: "", startInclude, endExclude, moveLength)
}
/**
* 生成随机UUID
*
* @return UUID字符串
* @see IdUtil.randomUUID
* @since 4.0.10
*/
fun uuid(): String {
return StrUtil.uuid()
}
/**
* 给定字符串中的字母是否全部为大写，判断依据如下：
*
*
* 1. 大写字母包括A-Z
* 2. 其它非字母的Unicode符都算作大写
*
*
* @param str 被检查的字符串
* @return 是否全部为大写
* @since 4.2.2
*/
fun CharSequence?.isUpperCase(): Boolean {
return StrUtil.isUpperCase(this ?: "")
}
/**
* 给定字符串中的字母是否全部为小写，判断依据如下：
*
*
* 1. 小写字母包括a-z
* 2. 其它非字母的Unicode符都算作小写
*
*
* @param str 被检查的字符串
* @return 是否全部为小写
* @since 4.2.2
*/
fun CharSequence?.isLowerCase(): Boolean {
return StrUtil.isLowerCase(this ?: "")
}
/**
* 获取字符串的长度，如果为null返回0
*
* @param cs a 字符串
* @return 字符串的长度，如果为null返回0
* @since 4.3.2
*/
fun CharSequence?.length(): Int {
return StrUtil.length(this)
}
/**
* 给定字符串转为bytes后的byte数（byte长度）
*
* @param cs 字符串
* @param charset 编码
* @return byte长度
* @since 4.5.2
*/
fun CharSequence?.byteLength(charset: Charset?): Int {
return StrUtil.byteLength(this ?: "", charset ?: Charsets.UTF_8)
}
/**
* 切换给定字符串中的大小写。大写转小写，小写转大写。
*
*
* StrUtil.swapCase(null) = null
* StrUtil.swapCase("") = ""
* StrUtil.swapCase("The dog has a BONE") = "tHE DOG HAS A bone"
*
*
* @param str 字符串
* @return 交换后的字符串
* @since 4.3.2
*/
fun String?.swapCase(): String {
return StrUtil.swapCase(this ?: "")
}