CharSequence 相关扩展收集

前言

主要是关于一些字符串判断相关内容，主要包括判断字符串是否含有空格、是否含有汉字、是否含有字母、是否含有数字、特殊符号等，字符串本身就有很多 Api 可以实现很多功能，但是对于判断方面就少了点，这里把收集到的常用的整理起来，可以直接使用。

函数列表

• 判断相关

isNotNullOrEmpty		:CharSequence不为 null 或者 empty
isHasSpecial			:是否含有特殊字符,true有，false没有
isHasChinese			:是否含有汉字,true有，false没有
isChinese			:是否全是汉字
isHasLower			:是否含有小写字母,true有，false没有
isLower				:是否全是大写字母
isHasCapital			:是否含有大写字母,true有，false没有
isCapital			:是否全是大写字母
isHasLetter			:是否含有字母，不区分大小写，true有，false没有
isLetter			:是否全是字母
isHasDigit			:是否含有数字，true有，false没有
isDigits			:是否全是数字，也可以用isDigitsOnly
isDigits2			:是否全是数字，也可以用isDigitsOnly
isHasSpace			:是否含有空格，true有，false没有
isSpace				:是否全是空格

Char.isSpace()			:判断字符是否是空格

• 其他

substringBetween		:指定裁剪出str中open和close包含着的那部分字符串
toFirstUpperCase		:首字母大写，或者调用capitalize
toFirstLowerCase		:首字母小写，或者调用decapitalize
substringUnDigits		:截取非数字，只能截取第一段连续的，不在首位截取不到
substringDigits			:截取数字，只能截取第一段连续的数字
substringAllDigits		:截取数字，截取所有的数字
stringSize			:特定字符串的数量
charSize			:含有特定字符的数量
spaceSize			:含有空格数量

工具类

object CharSequenceKtx {
    //匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效
    const val SPACE = "[\\s]"

    //匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效
    const val UN_SPACE = "[\\S]"

    //数字字符匹配。等效于 [0-9]
    const val DIGITS = "[\\d]"

    //非数字字符匹配。等效于 [^0-9]
    const val UN_DIGITS = "[\\D]"

    //匹配任何字类字符，包括下划线。与"[A-Za-z0-9_]"等效
    const val DIGITS_LETTER_UNDERLINE = "[\\w]"

    //与任何非单词字符匹配。与"[^A-Za-z0-9_]"等效
    const val UN_DIGITS_LETTER = "[\\W]"

    //匹配大写字母
    const val UPPERCASE_LETTER = "[A-Z]"

    //匹配小写字母
    const val LOWER_LETTER = "[a-z]"

    //匹配字母
    const val LETTER = "[a-zA-Z]"

    //匹配字母和数字
    const val DIGITS_LETTER = "[a-zA-Z0-9]"

    //匹配汉字
    const val CHINESE = "[\u4e00-\u9fa5]"

    //匹配特殊字符
    const val SPECIAL_CHARACTERS =
        "[ _`~!@#$%^&*()+=|{}':;',\\[\\].<>/?~！@#￥%……&*（）——+|{}【】‘；：”“’。，、？]|\n|\r|\t"
}

//fun CharSequence?.isBank() = this.isBlank()


fun testSpace(): Unit {
    val test: String = "hello"
    val test2 = "noSpace"
    val test3 = " 2321fdf汉字 --9**&"
    val test4 = " he llo "
    val test5 = "函数 zifu 2134"
    println("----------------")

    println(test4.removePrefix(" "))//移除前缀
    println(test4.removeSuffix(" "))//移除后缀
/*    println(test3.stringSize("2"))
    println(test.stringSize("2"))
    println(test.stringSize("l"))*/

/*    println(test5.replace(Regex("[\\d]"), "*"))//数字替换

    println(test5.replace(Regex(CharSequenceKtx.SPACE), ""))//删除所有空格
    println(test4.trim())
    println(test3.substringBefore("f"))//截取指定字符串之前的内容*/


/*    println(test5.toUpperCase())//字母大写
    println(test.capitalize())//首字母大写
    println(test2.decapitalize())//首字母小写
    println(test2.toLowerCase())//字母小写*/

//    println(test5.contains(Regex(CharSequenceKtx.DIGITS)))
//    println(test5.contains(Regex(CharSequenceKtx.UPPERCASE_LETTER)))
/*    println(test.matches(Regex("[a-z]*")))//是否全是小写字母
    println(test2.matches(Regex("[a-z]*")))//是否全是小写字母

    println(test.contains(Regex(CharSequenceKtx.LOWER_LETTER)))
    println(test.matches(Regex("${CharSequenceKtx.LOWER_LETTER}*")))
    println("${CharSequenceKtx.LOWER_LETTER}*")
    println(test5.contains(Regex(CharSequenceKtx.CHINESE)))
    println(test5.matches(Regex(CharSequenceKtx.CHINESE + "*")))*/
//    println(test2.first().toUpperCase() + test2.substring(1))
    //过滤非数字
    /*  println(test3.filter {
          it.isDigit()
      })*/
    /*  println(test3.substringUnDigits())
      println(test2.substringUnDigits())*/
//    println(test.substringDigits())
//    println(test5.substringDigits())

}

/**
 *CharSequence不为 null 或者 empty
 */
fun CharSequence?.isNotNullOrEmpty() = !isNullOrEmpty()

/**
 *〈指定裁剪出str中open和close包含着的那部分字符串〉
 * @param open
 * @param close
 * @return
 */
fun CharSequence?.substringBetween(open: String?, close: String?): String? {
    if (isNullOrEmpty() || open.isNullOrEmpty() || close.isNullOrEmpty()) return null
    val start = this!!.indexOf(open)
    if (start != -1) {
        val end = indexOf(close, start + open.length)
        if (end != -1) {
            return substring(start + open.length, end)
        }
    }
    return null
}

fun CharSequence?.substringBetween(tag: String?) = substringBetween(tag, tag)

/**
 *首字母大写，或者调用capitalize
 * @return
 */
fun CharSequence.toFirstUpperCase(): CharSequence {
    if (isEmpty()) {
        return ""
    }
    return first().toUpperCase() + substring(1)
}

/**
 *首字母小写，或者调用decapitalize
 * @return
 */
fun CharSequence.toFirstLowerCase(): CharSequence {
    if (isEmpty()) {
        return ""
    }
    return first().toLowerCase() + substring(1)
}

/**
 *截取非数字，只能截取第一段连续的，不在首位截取不到
 * @return
 */
fun CharSequence.substringUnDigits(): CharSequence {
    val pattern = Pattern.compile("\\D+")
    val matcher = pattern.matcher(this)
    while (matcher.find()) {
        return matcher.group(0)
    }
    return ""
}

/**
 *截取数字，只能截取第一段连续的数字
 * @return
 */
fun CharSequence.substringDigits(): CharSequence {
    val pattern = Pattern.compile("\\d+")
    val matcher = pattern.matcher(this)
    while (matcher.find()) {
        return matcher.group(0)
    }
    return ""
}

/**
 *截取数字，截取所有的数字
 * @return
 */
fun CharSequence.substringAllDigits(): CharSequence {
    val pattern = Pattern.compile("\\d+")
    val matcher = pattern.matcher(this)
    val sb = StringBuilder()
    while (matcher.find()) {
        sb.append(matcher.group())
    }
    return sb
}

/**
 *特定字符串的数量
 * @param tag
 * @return
 */
fun CharSequence.stringSize(tag: String): Int {
    return split(tag).size - 1
}

/**
 *含有特定字符的数量
 * @param char
 * @return
 */
fun CharSequence.charSize(char: Char): Int {
    var count = 0
    forEach {
        if (it == char) {
            count++
        }
    }
    return count
}

/**
 *含有空格数量
 * @return
 */
fun CharSequence.spaceSize(): Int {
    var count = 0
    forEach {
        if (it.isSpace()) {
            count++
        }
    }
    return count
}

/**
 *是否含有特殊字符,true有，false没有
 */
fun CharSequence.isHasSpecial() = contains(Regex(CharSequenceKtx.SPECIAL_CHARACTERS))

/**
 *是否含有汉字,true有，false没有
 */
fun CharSequence.isHasChinese() = contains(Regex(CharSequenceKtx.CHINESE))

/**
 *是否全是汉字
 */
fun CharSequence.isChinese() = matches(Regex(CharSequenceKtx.CHINESE + "+"))

/**
 *是否含有小写字母,true有，false没有
 */
fun CharSequence.isHasLower() = contains(Regex(CharSequenceKtx.LOWER_LETTER))

/**
 *是否全是大写字母
 */
fun CharSequence.isLower() = matches(Regex(CharSequenceKtx.LOWER_LETTER + "+"))

/**
 *是否含有大写字母,true有，false没有
 */
fun CharSequence.isHasCapital() = contains(Regex(CharSequenceKtx.UPPERCASE_LETTER))

/**
 *是否全是大写字母
 */
fun CharSequence.isCapital() = matches(Regex(CharSequenceKtx.UPPERCASE_LETTER + "+"))

/**
 *是否含有字母，不区分大小写，true有，false没有
 */
fun CharSequence.isHasLetter() = contains(Regex(CharSequenceKtx.LETTER))

/**
 *是否全是字母
 */
fun CharSequence.isLetter() = matches(Regex(CharSequenceKtx.LETTER + "+"))

/**
 *是否含有数字，true有，false没有
 */
fun CharSequence.isHasDigit() = contains(Regex(CharSequenceKtx.DIGITS))

/**
 *是否全是数字，也可以用isDigitsOnly
 */
fun CharSequence.isDigits() = matches(Regex(CharSequenceKtx.DIGITS + "+"))

/**
 *是否全都是数字
 */
fun CharSequence.isDigits2() = Pattern.compile("[\\d]+").matcher(this).matches()

/**
 *是否含有空格，true有，false没有
 */
fun CharSequence.isHasSpace() = contains(Regex(CharSequenceKtx.SPACE))

/**
 *是否全是空格
 */
fun CharSequence.isSpace() = matches(Regex(CharSequenceKtx.SPACE + "+"))

/**
 *判断字符是否是空格
 */
fun Char.isSpace() = this.toString().isHasSpace()

持续整理中...