前言

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

函数列表

  • 判断相关 ```kotlin 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() :判断字符是否是空格

  2. - 其他
  3. ```kotlin
  4. substringBetween        :指定裁剪出str中open和close包含着的那部分字符串
  5. toFirstUpperCase        :首字母大写，或者调用capitalize
  6. toFirstLowerCase        :首字母小写，或者调用decapitalize
  7. substringUnDigits        :截取非数字，只能截取第一段连续的，不在首位截取不到
  8. substringDigits            :截取数字，只能截取第一段连续的数字
  9. substringAllDigits        :截取数字，截取所有的数字
  10. stringSize                :特定字符串的数量
  11. charSize                :含有特定字符的数量
  12. spaceSize                :含有空格数量
  14. parseUrlByUri            :通过 uri 解析网址各部分内容
  15. str2HexStr                :字符串转为 16 进制字符串
  16. hexStr2Str                :16 进制字符串转为字符串
  17. str2Unicode                :字符串转换unicode
  18. unicode2Str                :unicode 转字符串

工具类

  1. object CharSequenceKtx {
  2.     //匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效
  3.     const val SPACE = "[\\s]"
  5.     //匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效
  6.     const val UN_SPACE = "[\\S]"
  8.     //数字字符匹配。等效于 [0-9]
  9.     const val DIGITS = "[\\d]"
  11.     //非数字字符匹配。等效于 [^0-9]
  12.     const val UN_DIGITS = "[\\D]"
  14.     //匹配任何字类字符，包括下划线。与"[A-Za-z0-9_]"等效
  15.     const val DIGITS_LETTER_UNDERLINE = "[\\w]"
  17.     //与任何非单词字符匹配。与"[^A-Za-z0-9_]"等效
  18.     const val UN_DIGITS_LETTER = "[\\W]"
  20.     //匹配大写字母
  21.     const val UPPERCASE_LETTER = "[A-Z]"
  23.     //匹配小写字母
  24.     const val LOWER_LETTER = "[a-z]"
  26.     //匹配字母
  27.     const val LETTER = "[a-zA-Z]"
  29.     //匹配字母和数字
  30.     const val DIGITS_LETTER = "[a-zA-Z0-9]"
  32.     //匹配汉字
  33.     const val CHINESE = "[\u4e00-\u9fa5]"
  35.     //匹配特殊字符
  36.     const val SPECIAL_CHARACTERS =
  37.         "[ _`~!@#$%^&*()+=|{}':;',\\[\\].<>/?~！@#￥%……&*（）——+|{}【】‘；：”“’。，、？]|\n|\r|\t"
  38. }
  40. //fun CharSequence?.isBank() = this.isBlank()
  43. fun testSpace(): Unit {
  44.     val test: String = "hello"
  45.     val test2 = "noSpace"
  46.     val test3 = " 2321fdf汉字 --9**&"
  47.     val test4 = " he llo "
  48.     val test5 = "函数 zifu 2134"
  49.     println("----------------")
  51.     println(test4.removePrefix(" "))//移除前缀
  52.     println(test4.removeSuffix(" "))//移除后缀
  53. /*    println(test3.stringSize("2"))
  54.     println(test.stringSize("2"))
  55.     println(test.stringSize("l"))*/
  57. /*    println(test5.replace(Regex("[\\d]"), "*"))//数字替换
  59.     println(test5.replace(Regex(CharSequenceKtx.SPACE), ""))//删除所有空格
  60.     println(test4.trim())
  61.     println(test3.substringBefore("f"))//截取指定字符串之前的内容*/
  64. /*    println(test5.toUpperCase())//字母大写
  65.     println(test.capitalize())//首字母大写
  66.     println(test2.decapitalize())//首字母小写
  67.     println(test2.toLowerCase())//字母小写*/
  69. //    println(test5.contains(Regex(CharSequenceKtx.DIGITS)))
  70. //    println(test5.contains(Regex(CharSequenceKtx.UPPERCASE_LETTER)))
  71. /*    println(test.matches(Regex("[a-z]*")))//是否全是小写字母
  72.     println(test2.matches(Regex("[a-z]*")))//是否全是小写字母
  74.     println(test.contains(Regex(CharSequenceKtx.LOWER_LETTER)))
  75.     println(test.matches(Regex("${CharSequenceKtx.LOWER_LETTER}*")))
  76.     println("${CharSequenceKtx.LOWER_LETTER}*")
  77.     println(test5.contains(Regex(CharSequenceKtx.CHINESE)))
  78.     println(test5.matches(Regex(CharSequenceKtx.CHINESE + "*")))*/
  79. //    println(test2.first().toUpperCase() + test2.substring(1))
  80.     //过滤非数字
  81.     /*  println(test3.filter {
  82.           it.isDigit()
  83.       })*/
  84.     /*  println(test3.substringUnDigits())
  85.       println(test2.substringUnDigits())*/
  86. //    println(test.substringDigits())
  87. //    println(test5.substringDigits())
  89. }
  91. /**
  92.  *CharSequence不为 null 或者 empty
  93.  */
  94. fun CharSequence?.isNotNullOrEmpty() = !isNullOrEmpty()
  96. /**
  97.  *〈指定裁剪出str中open和close包含着的那部分字符串〉
  98.  * @param open
  99.  * @param close
  100.  * @return
  101.  */
  102. fun CharSequence?.substringBetween(open: String?, close: String?): String? {
  103.     if (isNullOrEmpty() || open.isNullOrEmpty() || close.isNullOrEmpty()) return null
  104.     val start = this!!.indexOf(open)
  105.     if (start != -1) {
  106.         val end = indexOf(close, start + open.length)
  107.         if (end != -1) {
  108.             return substring(start + open.length, end)
  109.         }
  110.     }
  111.     return null
  112. }
  114. fun CharSequence?.substringBetween(tag: String?) = substringBetween(tag, tag)
  116. /**
  117.  *首字母大写，或者调用capitalize
  118.  * @return
  119.  */
  120. fun CharSequence.toFirstUpperCase(): CharSequence {
  121.     if (isEmpty()) {
  122.         return ""
  123.     }
  124.     return first().toUpperCase() + substring(1)
  125. }
  127. /**
  128.  *首字母小写，或者调用decapitalize
  129.  * @return
  130.  */
  131. fun CharSequence.toFirstLowerCase(): CharSequence {
  132.     if (isEmpty()) {
  133.         return ""
  134.     }
  135.     return first().toLowerCase() + substring(1)
  136. }
  138. /**
  139.  *截取非数字，只能截取第一段连续的，不在首位截取不到
  140.  * @return
  141.  */
  142. fun CharSequence.substringUnDigits(): CharSequence {
  143.     val pattern = Pattern.compile("\\D+")
  144.     val matcher = pattern.matcher(this)
  145.     while (matcher.find()) {
  146.         return matcher.group(0)
  147.     }
  148.     return ""
  149. }
  151. /**
  152.  *截取数字，只能截取第一段连续的数字
  153.  * @return
  154.  */
  155. fun CharSequence.substringDigits(): CharSequence {
  156.     val pattern = Pattern.compile("\\d+")
  157.     val matcher = pattern.matcher(this)
  158.     while (matcher.find()) {
  159.         return matcher.group(0)
  160.     }
  161.     return ""
  162. }
  164. /**
  165.  *截取数字，截取所有的数字
  166.  * @return
  167.  */
  168. fun CharSequence.substringAllDigits(): CharSequence {
  169.     val pattern = Pattern.compile("\\d+")
  170.     val matcher = pattern.matcher(this)
  171.     val sb = StringBuilder()
  172.     while (matcher.find()) {
  173.         sb.append(matcher.group())
  174.     }
  175.     return sb
  176. }
  178. /**
  179.  *特定字符串的数量
  180.  * @param tag
  181.  * @return
  182.  */
  183. fun CharSequence.stringSize(tag: String): Int {
  184.     return split(tag).size - 1
  185. }
  187. /**
  188.  *含有特定字符的数量
  189.  * @param char
  190.  * @return
  191.  */
  192. fun CharSequence.charSize(char: Char): Int {
  193.     var count = 0
  194.     forEach {
  195.         if (it == char) {
  196.             count++
  197.         }
  198.     }
  199.     return count
  200. }
  202. /**
  203.  *含有空格数量
  204.  * @return
  205.  */
  206. fun CharSequence.spaceSize(): Int {
  207.     var count = 0
  208.     forEach {
  209.         if (it.isSpace()) {
  210.             count++
  211.         }
  212.     }
  213.     return count
  214. }
  216. /**
  217.  *是否含有特殊字符,true有，false没有
  218.  */
  219. fun CharSequence.isHasSpecial() = contains(Regex(CharSequenceKtx.SPECIAL_CHARACTERS))
  221. /**
  222.  *是否含有汉字,true有，false没有
  223.  */
  224. fun CharSequence.isHasChinese() = contains(Regex(CharSequenceKtx.CHINESE))
  226. /**
  227.  *是否全是汉字
  228.  */
  229. fun CharSequence.isChinese() = matches(Regex(CharSequenceKtx.CHINESE + "+"))
  231. /**
  232.  *是否含有小写字母,true有，false没有
  233.  */
  234. fun CharSequence.isHasLower() = contains(Regex(CharSequenceKtx.LOWER_LETTER))
  236. /**
  237.  *是否全是大写字母
  238.  */
  239. fun CharSequence.isLower() = matches(Regex(CharSequenceKtx.LOWER_LETTER + "+"))
  241. /**
  242.  *是否含有大写字母,true有，false没有
  243.  */
  244. fun CharSequence.isHasCapital() = contains(Regex(CharSequenceKtx.UPPERCASE_LETTER))
  246. /**
  247.  *是否全是大写字母
  248.  */
  249. fun CharSequence.isCapital() = matches(Regex(CharSequenceKtx.UPPERCASE_LETTER + "+"))
  251. /**
  252.  *是否含有字母，不区分大小写，true有，false没有
  253.  */
  254. fun CharSequence.isHasLetter() = contains(Regex(CharSequenceKtx.LETTER))
  256. /**
  257.  *是否全是字母
  258.  */
  259. fun CharSequence.isLetter() = matches(Regex(CharSequenceKtx.LETTER + "+"))
  261. /**
  262.  *是否含有数字，true有，false没有
  263.  */
  264. fun CharSequence.isHasDigit() = contains(Regex(CharSequenceKtx.DIGITS))
  266. /**
  267.  *是否全是数字，也可以用isDigitsOnly
  268.  */
  269. fun CharSequence.isDigits() = matches(Regex(CharSequenceKtx.DIGITS + "+"))
  271. /**
  272.  *是否全都是数字
  273.  */
  274. fun CharSequence.isDigits2() = Pattern.compile("[\\d]+").matcher(this).matches()
  276. /**
  277.  *是否含有空格，true有，false没有
  278.  */
  279. fun CharSequence.isHasSpace() = contains(Regex(CharSequenceKtx.SPACE))
  281. /**
  282.  *是否全是空格
  283.  */
  284. fun CharSequence.isSpace() = matches(Regex(CharSequenceKtx.SPACE + "+"))
  286. /**
  287.  *判断字符是否是空格
  288.  */
  289. fun Char.isSpace() = this.toString().isHasSpace()
  291. /**
  292.  *通过 uri 解析网址各部分内容
  293.  * @param action
  294.  */
  295. fun CharSequence?.parseUrlByUri(action: String?) = UriUtils.parseUrlByUri(this?.toString(), action)
  297. /**
  298.  * 字符串转为 16 进制字符串
  299.  *
  300.  * @return
  301.  */
  302. fun CharSequence?.str2HexStr() = BytesUtils.str2HexStr(this?.toString())
  304. /**
  305.  *  16 进制字符串转为字符串
  306.  *
  307.  * @return
  308.  */
  309. fun CharSequence?.hexStr2Str() = BytesUtils.hexStr2Str(this?.toString())
  311. /**
  312.  * 字符串转换unicode
  313.  */
  314. fun CharSequence?.str2Unicode() = BytesUtils.string2Unicode(this?.toString())
  316. /**
  317.  * unicode 转字符串
  318.  */
  319. fun CharSequence?.unicode2Str() = BytesUtils.unicode2String(this?.toString())

持续整理中…