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

目录

• 一、背景介绍
• 二、常见用处
• 三、核心语法规则
• 1. 特殊语法
• 2. 字符集
• 四、Kotlin中的Regex类
• 1. 创建Regex对象
• 五、核心操作方法
• 1. 匹配整个字符串
• 2. 查找匹配项
• 3. 查找并提取分组
• 4. 替换文本
• 5. 分割字符串
• 6. 检查是否包含匹配
• 六、高级用法
• 1. 命名捕获组
• 2. 多行模式和忽略大小写
• 3. 使用边界匹配
• 4. 懒惰匹配（非贪婪模式）
• 六、实际应用示例
• 1. 验证各种格式
• 2. 敏感词过滤
• 3. 日志解析
• 七、性能优化建议

最近在10几万条的日志中搜索有用信息，又或者在输入框中过滤特殊字符，都有用到正则表达式最，可是由于都不太熟练，需要上网进行搜索。于是结合网上的一些资料，编写了这篇博客，用于巩固和做备份。

正则表达式（Regular Expression）是一种用于匹配字符串模式的强大工具，主要用于：

• 验证输入格式（邮箱、手机号等）

• 搜索和提取文本内容

• 替换特定模式的文本

• 分割字符串

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

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

Kotlin通过Regex类提供正则表达式支持，有两种创建方式：

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

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

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

注意：在Kotlin中推荐使用三引号原始字符串"""..."""，避免转义反斜杠的麻烦。

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

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

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

fun extractDateInfo(dateStr: String): Triple<String, String, String>? {
    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)

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

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

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

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

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

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

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

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

fun findWholeWord(text: String, word: String): List<String> {
    // 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)

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

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

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 }
    }
}

class SensitiveFilter(private val sensitiveWords: List<String>) {
    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))  // 这是一条***信息，不要信

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对象，避免重复创建

• 使用原始字符串：三引号字符串避免双重转义

• 避免过度使用捕获组：不需要提取的内容使用非捕获组(?:...)

• 警惕灾难性回溯：避免嵌套的量词如(a*)*

到此这篇关于Kotlin版正则表达式及其常见使用代码举例的文章就介绍到这了,更多相关Kotlin正则表达式使用内容请搜索风君子博客以前的文章或继续浏览下面的相关文章希望大家以后多多支持风君子博客！

您可能感兴趣的文章:

• Kotlin利用Regex如何构建正则表达式详解
• Kotlin语言编程Regex正则表达式实例详解