Kotlin Regex

Introduction

In Kotlin, the Regex class is used for working with regular expressions. Regular expressions are used for matching patterns within strings, allowing for sophisticated text processing and validation. The Regex class provides various methods to create, match, and manipulate regular expressions.

Table of Contents

1. What is Regex?
2. Creating a Regex
3. Common Operations
4. Examples of Regex
5. Real-World Use Case
6. Conclusion

1. What is Regex?

The Regex class in Kotlin represents a regular expression, which is a sequence of characters that forms a search pattern. It can be used for searching, extracting, and manipulating text based on the pattern defined by the regular expression.

Syntax

class Regex(pattern: String)

2. Creating a Regex

You can create a Regex object by providing a pattern string. Kotlin also supports raw strings (enclosed in triple quotes) for patterns that contain many backslashes.

Example

val regex = Regex("pattern")
val regexRaw = Regex("""\d{3}-\d{2}-\d{4}""") // Raw string pattern

3. Common Operations

Regex supports various operations for matching and manipulating strings.

Matching Functions

• matches(input: CharSequence): Checks if the entire input sequence matches the regular expression.
• containsMatchIn(input: CharSequence): Checks if the input sequence contains any match of the regular expression.
• find(input: CharSequence): Finds the first match of the regular expression in the input sequence.
• findAll(input: CharSequence): Finds all matches of the regular expression in the input sequence.

Replacement Functions

• replace(input: CharSequence, replacement: String): Replaces all matches of the regular expression in the input sequence with the replacement string.
• replace(input: CharSequence, transform: (MatchResult) -> CharSequence): Replaces all matches of the regular expression in the input sequence using the specified transform function.

Splitting Functions

• split(input: CharSequence): Splits the input sequence around matches of the regular expression.

4. Examples of Regex

Example 1: Basic Pattern Matching

This example demonstrates how to check if a string matches a specific pattern.

fun main() {
    val regex = Regex("""\d{3}-\d{2}-\d{4}""")
    val input = "123-45-6789"
    if (regex.matches(input)) {
        println("The input matches the pattern.")
    } else {
        println("The input does not match the pattern.")
    }
}

Output:

The input matches the pattern.

Explanation:
This example checks if the input string matches the pattern for a Social Security number format.

Example 2: Finding Matches

This example demonstrates how to find and print all matches of a pattern in a string.

fun main() {
    val regex = Regex("""\b\w{4}\b""")
    val input = "This is a test string with some four-letter words."
    val matches = regex.findAll(input)
    matches.forEach { println(it.value) }
}

Output:

This
test
with
some

Explanation:
This example finds all four-letter words in the input string and prints them.

Example 3: Replacing Matches

This example demonstrates how to replace all matches of a pattern in a string with a replacement string.

fun main() {
    val regex = Regex("""\d+""")
    val input = "There are 123 apples and 456 oranges."
    val result = regex.replace(input, "#")
    println(result) // Output: There are # apples and # oranges.
}

Output:

There are # apples and # oranges.

Explanation:
This example replaces all numeric sequences in the input string with the hash symbol.

Example 4: Splitting Strings

This example demonstrates how to split a string around matches of a pattern.

fun main() {
    val regex = Regex("""\s+""")
    val input = "This is a test string."
    val result = regex.split(input)
    result.forEach { println(it) }
}

Output:

This
is
a
test
string.

Explanation:
This example splits the input string into words using whitespace as the delimiter.

Example 5: Using Transform Function in Replacement

This example demonstrates how to replace all matches of a pattern in a string using a transform function.

fun main() {
    val regex = Regex("""\d+""")
    val input = "There are 123 apples and 456 oranges."
    val result = regex.replace(input) { matchResult -> "[${matchResult.value}]" }
    println(result) // Output: There are [123] apples and [456] oranges.
}

Output:

There are [123] apples and [456] oranges.

Explanation:
This example replaces all numeric sequences in the input string with the same sequence enclosed in square brackets.

5. Real-World Use Case: Email Validation

You can use Regex to validate email addresses in a user registration form.

Example: Email Validation

fun isValidEmail(email: String): Boolean {
    val emailRegex = Regex("^[A-Za-z0-9+_.-]+@(.+)\
quot;)
    return emailRegex.matches(email)
}

fun main() {
    val email = "user@example.com"
    if (isValidEmail(email)) {
        println("The email address is valid.")
    } else {
        println("The email address is invalid.")
    }
}

Output:

The email address is valid.

Explanation:
This example validates an email address using a regular expression pattern.

Conclusion

The Regex class in Kotlin is a powerful and flexible way to work with regular expressions. It is part of the Kotlin standard library and provides essential operations for pattern matching, replacement, and splitting of strings. Understanding and utilizing the Regex class can greatly enhance your ability to perform complex text processing and validation in Kotlin.