Kotlin Check if String is Number: A Simple Guide to Type Validation

Validating user input is a crucial part of building robust Kotlin applications.

One common challenge is determining whether a given string represents a number, especially when handling user inputs dynamically.

In this blog, you'll learn various techniques for checking if a string is numeric in Kotlin. Along the way, we'll dive into useful methods, functions, and regular expressions while exploring best practices for ensuring accurate and reliable validation.

Why Validate Strings as Numbers in Kotlin?

Imagine you're building a Kotlin-based calculator or a form validation system. You may need to check if a string is a valid number to prevent unexpected errors during operations. Correctly identifying numeric strings ensures smooth application behavior, whether it's an integer, a whole number, or a value with a fractional part. This blog explains how you can achieve this validation using idiomatic Kotlin.

How to Check if a String Is a Number in Kotlin

There are multiple ways to validate if a string represents a numeric value. These methods range from using regular expressions to parsing techniques. Below, you'll find practical examples for each approach.

1. Using Regular Expressions

Regular expressions (regex) offer a powerful way to validate numeric strings. Here’s an example:

Copy
fun isNumericUsingRegex(input: String): Boolean {
    val regex = """^-?\d+(\.\d+)?$""".toRegex() // Corrected the regex by removing the extra backslash
    return input.matches(regex)
}

fun main() {
    println(isNumericUsingRegex("123")) // true
    println(isNumericUsingRegex("-123.45")) // true
    println(isNumericUsingRegex("abc")) // false
}

In this code, the matches method checks if the input string conforms to a pattern that includes optional negative signs and fractional parts.

2. Using Built-in Parsing Functions

Kotlin's standard library provides parsing methods like toIntOrNull and toDoubleOrNull. These functions return null if parsing fails, making them a great choice for validation.

Copy
fun isNumericUsingParsing(input: String): Boolean {
    return input.toIntOrNull() != null || input.toDoubleOrNull() != null
}

fun main() {
    println(isNumericUsingParsing("42")) // true
    println(isNumericUsingParsing("42.5")) // true
    println(isNumericUsingParsing("not a number")) // false
}

This approach avoids exceptions and handles nullable types gracefully.

Handling Edge Cases

1. Non-Empty State Validation

Before validating a string, ensure it is in a non-empty state. A blank input cannot represent a number:

Copy
fun isValidAndNumeric(input: String): Boolean {
    if (input.isEmpty()) return false
    return input.toDoubleOrNull() != null
}

println(isValidAndNumeric("")) // false
println(isValidAndNumeric("123")) // true

2. Whole Numbers vs. Floating-Point Numbers

You can refine your validation to distinguish between integers and doubles:

Copy
fun isInteger(input: String): Boolean {
    return input.toIntOrNull() != null
}

fun isDouble(input: String): Boolean {
    return input.toDoubleOrNull() != null
}

println(isInteger("123")) // true
println(isDouble("123.45")) // true
println(isInteger("123.45")) // false

This approach ensures clarity when differentiating between whole numbers and numeric values with a fractional part.

Error Handling and Fail-Safe Design

1. Catching Parsing Exceptions

While idiomatic Kotlin prefers toIntOrNull and toDoubleOrNull to avoid exceptions, you can use try-catch blocks to handle unexpected inputs:

Here, exceptions are caught to prevent your program from crashing.

2. Custom Error Messages

Provide user-friendly messages when validation fails:

Advantages of Idiomatic Kotlin Approaches

• Nullable Types: Using toIntOrNull or toDoubleOrNull integrates well with Kotlin’s nullable type system.

• Minimal Overhead: These approaches avoid unnecessary exception handling.

• Readability: Using functions like toIntOrNull is an idiomatic way to achieve clarity in your code.

Best Practices for Numeric Validation in Kotlin

1. Use non-empty state checks before validation.

2. Employ regular expressions for complex patterns or specific numeric formats.

3. Prefer built-in functions like toIntOrNull for simplicity and safety.

4. Test your validation code with various examples, including edge cases like negative numbers and fractional parts.

Examples of Real-World Applications

1. Form Validation: Ensure a field accepts only numeric values before processing user inputs.

2. Math Calculators: Validate inputs for calculations to avoid NumberFormatException.

3. File Parsing: Check if strings from a file are numeric before converting them to integers or doubles.

The Bottom Line!

In this article, we explored various approaches to validate if a string represents a numeric value in Kotlin. From using regular expressions for pattern matching to leveraging idiomatic functions like toIntOrNull and toDoubleOrNull, you now have multiple tools to handle numeric validation effectively. We also covered handling edge cases, distinguishing between whole numbers and doubles, and ensuring inputs are in a non-empty state.

By applying these methods, you can confidently implement robust validation logic in your applications. Whether you're parsing user input, processing file data, or building mathematical tools, mastering Kotlin check if string is number validation is essential for creating reliable and error-free code.

fun isNumericWithTryCatch(input: String): Boolean {
    return try {
        input.toDouble()
        true
    } catch (e: NumberFormatException) {
        false
    }
}

fun main() {
    println(isNumericWithTryCatch("123")) // true
    println(isNumericWithTryCatch("abc")) // false
}

fun validateInput(input: String): String {
    return if (input.toIntOrNull() != null) "Valid integer"
           else if (input.toDoubleOrNull() != null) "Valid double"
           else "Invalid input"
}

println(validateInput("123"))  // Valid integer
println(validateInput("12.34"))  // Valid double
println(validateInput("abc"))  // Invalid input