Kotlin版正则表达式及其常见使用代码举例

一、背景介绍

在处理十几万条日志的时候，或者在输入框里过滤特殊字符的时候，正则表达式总是绕不开的工具。但坦白讲，这东西用起来没那么顺手，每次都得现查资料。于是结合网上的一些资源，整理了一份完整的参考，方便随时翻阅。

二、常见用处

正则表达式（Regular Expression）说到底是一套字符串匹配的利器，搞定了以下几个场景：验证输入格式——邮箱、手机号是不是合法；搜索和提取文本内容——从大段文字中捞出想要的信息；替换特定模式的文本——比如把手机号中间四位隐藏起来；分割字符串——按照特定符号把一句话拆成几段。

三、核心语法规则

1. 特殊语法

.       // 匹配任意单个字符（除换行符）
^       // 匹配字符串开始
$       // 匹配字符串结束
*       // 匹配前一个元素0次或多次
+       // 匹配前一个元素1次或多次
?       // 匹配前一个元素0次或1次
{n}     // 精确匹配n次
{n,}    // 至少匹配n次
{n,m}   // 匹配n到m次
|       // 或运算符
()      // 分组
[]      // 字符集
d      // 数字，等价于[0-9]
D      // 非数字
w      // 单词字符，等价于[a-zA-Z0-9_]
W      // 非单词字符
s      // 空白字符
S      // 非空白字符

2. 字符集

[abc]      // 匹配a、b或c
[^abc]     // 匹配除a、b、c外的字符
[a-z]      // 匹配a到z的小写字母
[a-zA-Z]   // 匹配所有字母
[0-9]      // 匹配数字

四、Kotlin中的Regex类

Kotlin里的正则支持，核心就是Regex类。创建方式灵活，体现在三种写法上：

1. 创建Regex对象

// 方式1：使用构造函数
val regex1 = Regex("""d+""")  // 原始字符串，推荐

// 方式2：使用字符串扩展函数
val regex2 = "\d+".toRegex()

// 方式3：使用编译选项
val regex3 = Regex("pattern", RegexOption.IGNORE_CASE)

注意：在Kotlin里，强烈建议使用三引号原始字符串"""..."""，这样就没必要去纠结反斜杠转义的问题了，写起来清爽很多。

五、核心操作方法

1. 匹配整个字符串

val emailRegex = """^w+@[a-zA-Z_]+?.[a-zA-Z]{2,3}$""".toRegex()

fun validateEmail(email: String): Boolean {
    return email.matches(emailRegex)
}

// 使用
println(validateEmail("test@example.com"))  // true
println(validateEmail("invalid-email"))     // false

2. 查找匹配项

fun findNumbers(text: String): List {
    val numberRegex = """d+""".toRegex()
    return numberRegex.findAll(text).map { it.value }.toList()
}

// 使用
val text = "订单号：12345，金额：678元"
println(findNumbers(text))  // [12345, 678]

3. 查找并提取分组

fun extractDateInfo(dateStr: String): Triple? {
    val regex = """(d{4})-(d{2})-(d{2})""".toRegex()
    val match = regex.find(dateStr) ?: return null
    
    // group(0)是整个匹配，group(1)开始是捕获组
    return Triple(
        match.groupValues[1],  // 年
        match.groupValues[2],  // 月
        match.groupValues[3]   // 日
    )
}

// 使用
val result = extractDateInfo("今天日期是2024-01-15")
println(result)  // (2024, 01, 15)

4. 替换文本

fun maskPhoneNumber(phone: String): String {
    val regex = """(d{3})d{4}(d{4})""".toRegex()
    return regex.replace(phone, "$1****$2")  // $1和$2引用捕获组
}

// 使用
println(maskPhoneNumber("13812345678"))  // 138****5678

5. 分割字符串

fun splitByPunctuation(text: String): List {
    val regex = """[,.;!?]""".toRegex()
    return text.split(regex)
}

// 使用
val words = splitByPunctuation("Hello,world!How are you?")
println(words)  // [Hello, world, How are you]

6. 检查是否包含匹配

fun containsUrl(text: String): Boolean {
    val urlRegex = """https?://[^s]+""".toRegex()
    return urlRegex.containsMatchIn(text)
}

// 使用
println(containsUrl("访问 https://example.com 了解更多"))  // true

六、高级用法

1. 命名捕获组

fun parseLogLine(log: String): Map {
    val regex = """(?d{4}-d{2}-d{2}) (?w+): (?.+)""".toRegex()
    val match = regex.find(log) ?: return emptyMap()
    
    return match.groups as? Map ?: emptyMap()
}

// 使用
val log = "2024-01-15 ERROR: 数据库连接失败"
val parsed = parseLogLine(log)
println(parsed["timestamp"])  // 2024-01-15

2. 多行模式和忽略大小写

val multiLineRegex = """^start.*end$""".toRegex(
    setOf(RegexOption.MULTILINE, RegexOption.IGNORE_CASE)
)

val text = """
    start first END
    middle
    start second End
""".trimIndent()

println(multiLineRegex.findAll(text).count())  // 2

3. 使用边界匹配

fun findWholeWord(text: String, word: String): List {
    // b 表示单词边界
    val regex = """b$wordb""".toRegex(RegexOption.IGNORE_CASE)
    return regex.findAll(text).map { it.value }.toList()
}

// 使用
val result = findWholeWord("cat catalog scatter", "cat")
println(result)  // [cat] (不会匹配到catalog和scatter中的cat)

4. 懒惰匹配（非贪婪模式）

fun extractHtmlTag(html: String, tagName: String): String? {
    // *? 表示非贪婪匹配，尽可能少地匹配字符
    val regex = """<$tagName>.*?""".toRegex()
    return regex.find(html)?.value
}

// 使用
val html = "
内容1
内容2
"
println(extractHtmlTag(html, "div"))  // 
内容1

六、实际应用示例

1. 验证各种格式

object Validator {
    // 手机号（中国）
    private val phoneRegex = """^1[3-9]d{9}$""".toRegex()
    
    // 邮箱
    private val emailRegex = """^[w.-]+@[w.-]+.[a-zA-Z]{2,}$""".toRegex()
    
    // 身份证号（18位）
    private val idCardRegex = """^d{17}[dXx]$""".toRegex()
    
    // URL
    private val urlRegex = """^https?://[^s/$.?#].[^s]*$""".toRegex()
    
    // IPv4地址
    private val ipv4Regex = """^(d{1,3}).(d{1,3}).(d{1,3}).(d{1,3})$""".toRegex()
    
    fun isValidPhone(phone: String) = phone.matches(phoneRegex)
    fun isValidEmail(email: String) = email.matches(emailRegex)
    fun isValidIdCard(idCard: String) = idCard.matches(idCardRegex)
    fun isValidUrl(url: String) = url.matches(urlRegex)
    fun isValidIpv4(ip: String): Boolean {
        if (!ip.matches(ipv4Regex)) return false
        return ip.split(".").all { it.toInt() in 0..255 }
    }
}

2. 敏感词过滤

class SensitiveFilter(private val sensitiveWords: List) {
    private val regex by lazy {
        // 构建或模式，如：b(词1|词2|词3)b
        val pattern = sensitiveWords.joinToString("|") { Regex.escape(it) }
        """b($pattern)b""".toRegex(RegexOption.IGNORE_CASE)
    }
    
    fun filter(text: String, replacement: String = "***"): String {
        return regex.replace(text, replacement)
    }
    
    fun hasSensitiveWord(text: String): Boolean {
        return regex.containsMatchIn(text)
    }
}

// 使用
val filter = SensitiveFilter(listOf("广告", "反诈", "违规"))
val text = "这是一条广告信息，不要信"
println(filter.filter(text))  // 这是一条***信息，不要信

3. 日志解析

data class LogEntry(
    val timestamp: String,
    val level: String,
    val thread: String,
    val className: String,
    val message: String
)

fun parseLog(log: String): LogEntry? {
    val regex = """(d{4}-d{2}-d{2} d{2}:d{2}:d{2},d{3})s+(w+)s+[([^]]+)]s+([w.]+)s+(.+)"""
        .toRegex()
    
    val match = regex.find(log) ?: return null
    
    return LogEntry(
        timestamp = match.groupValues[1],
        level = match.groupValues[2],
        thread = match.groupValues[3],
        className = match.groupValues[4],
        message = match.groupValues[5]
    )
}

七、性能优化建议

• 预编译Pattern：Regex对象复用就好，别每次匹配都重新new一个——这算是基本功了。

• 使用原始字符串：三引号字符串避免双重转义，写起来轻松，读起来也清爽。

• 避免过度使用捕获组：如果不需要提取分组内容，用非捕获组(?:...)替代，能省不少性能。

• 警惕灾难性回溯：嵌套的量词如(a*)*，一旦踩到，性能直接崩盘，务必提前避免。