Kotlin 正则表达式

在Kotlin中除了使用Java的 Pattern、Matcher 等类外，还可以使用Kotlin提供的 Regex 类来创建正则表达式。

构造Regex表达式

1. 使用Regex构造函数
2. 使用String的toRegex()扩展函数

Regex函数

1. matches() 函数，如果输入字符串全部匹配，那么返回true，否则就返回false
2. containsMatchIn() 函数，输入字符串至少有一个匹配就返回true，没有匹配就返回false
3. matchEntire() 函数，如果输入字符串全部匹配则返回一个MatcherMatchResult对象，否则返回null
4. replace(input: CharSequence, replacement: String):String 函数，将输入字符串input中匹配的部分 替换成replacement内容
5. replace(input: CharSequence, transform: (MatchResult) -> CharSequence): String 函数，把输入字符串中匹配到的值，用transform()函数处理后的新值进行替换
6. find() 函数，返回 输入字符串中第一个匹配的MatcherMatchResult对象
7. findAll() 函数,返回 输入字符串中所有匹配的MatchResult序列

代码测试：

fun testRegex(): Unit {
    // 构造Regex表达式
    val r1 = Regex("[a-z]+")
    val r2 = Regex("[a-z]+", RegexOption.IGNORE_CASE)
    val r3 = "[A-Z]+".toRegex()

    println("matches() 函数")
    // matches() 函数，输入字符串全部匹配
    val x1 = r1.matches("ABCxyz")
    println(x1) // 输出：false，这个正则表达式要求输入字符串每个字符都是小写，"ABC"大写不匹配
    val x2 = r2.matches("ABCxyz")
    println(x2) // 输出：true，RegexOption.IGNORE_CASE，正则表达式忽略大小写
    val x3 = r3.matches("OPQSN")
    println(x3) // 输出：true，都是大写，满足[A-Z]

    println("containsMatchIn() 函数")
    // containsMatchIn() 函数，输入字符串至少有一个匹配就返回true，没有匹配就返回false
    val y1 = r1.containsMatchIn("a12345.")
    println(y1) // 输出：true，输入字符串中"a"就满足正则表达式[a-z]
    val y11 = r1.containsMatchIn("ABC12345")
    println(y11) // 输出：false，输入字符串没有一个满足正则表达式[a-z]

    println("matchEntire() 函数")
    // matchEntire() 函数，如果输入字符串全部匹配则返回一个MatcherMatchResult对象，否则返回null
    val z1 = r1.matchEntire("kotlin")
    println(z1) // 输出：kotlin.text.MatcherMatchResult@27a418fe，输入字符串全部满足正则表达式
    println(z1?.value) // 输出：kotlin，通过访问MatcherMatchResult的value属性，获得匹配的值
    val z11 = r1.matchEntire("kotlin_java_C++")
    println(z11) // 输出：null，输入中的"_"、"+"不匹配正则表达式[a-z]
    println(z11?.value) // 输出：null

    println("replace(input: CharSequence, replacement: String):String 函数")
    // replace(input: CharSequence, replacement: String):String 函数,
    // 将输入字符串input中匹配的部分 替换成replacement内容
    val a1 = r1.replace("abc12345","TEST*")
    println(a1) // 输出：TEST*12345，输入字符串中的"abc"匹配正则表达式[a-z]，因此它被替换了
    val a11 = r1.replace("aBcD567xyz#", "TEST*")
    println(a11) // 输出：TEST*BTEST*D567TEST*#，输入字符串中的"a"、"c"、"xyz"匹配正则表达式[a-z]

    println("replace(input: CharSequence, transform: (MatchResult) -> CharSequence): String 函数")
    // 把输入字符串中匹配到的值，用transform()函数处理后的新值进行替换
    val b1 = r1.replace("ab345cD") { "[${it.value}]" }
    println(b1) // 输出：[ab]345[c]D，将输入字符串中匹配正则表达式[a-z]的内容用"[]"标出来了

    println("find() 函数")
    // find() 函数，返回 输入字符串中第一个匹配的MatcherMatchResult对象
    val c1 = r1.find("ABcd5678efG")
    println(c1) // 输出：kotlin.text.MatcherMatchResult@77459856
    println(c1?.value) // 输出：cd，获得匹配的值

    println("findAll() 函数")
    // findAll() 函数,返回 输入字符串中所有匹配的MatchResult序列
    val d1 = r1.findAll("ABcd5678efGhi")
    println(d1) // 输出：kotlin.sequences.GeneratorSequence@4dd8da9
    d1.forEach { println(it.value) } // 输出：cd ef hi，遍历输出所有匹配的值
}

使用Java的正则表达式类

fun testRegexJ(): Unit {
    val re = Regex("[0-9]+")
    val p = re.toPattern()
    val m = p.matcher("S50UT678")
    while (m.find()) {
        val g = m.group()
        println(g)
    } // 输出： 50  678
}