Check if the Given String Is a Valid Number

1. Introduction

In this tutorial, we’ll explore different ways to check if a given string is a valid number in Java. We’ll cover several techniques, including built-in parsing methods, regular expressions, and third-party libraries.

2. Using Character and Looping

A straightforward way to check if a string is numeric is by iterating through each character in the string and verifying that each character is a digit:

boolean isNumeric(String str) {
    if (str == null || str.isEmpty()){
        return false;
    }

    int decimalCount = 0;
    boolean hasDigits = false;
    for (char c : str.toCharArray()) {
        if (c == '.') {
            decimalCount++;
            if (decimalCount > 1) {
                return false;
            }
        } else if (Character.isDigit(c)) {
            hasDigits = true;
        } else {
            return false;
        }
    }
    return hasDigits && decimalCount <= 1;
}

This code validates a numeric string by examining each character individually. If a character is a digit, the code continues to the next character. When it encounters a decimal point (.), it increments a decimalCount variable to keep track of the number of decimal points.

If there is more than one decimal point, the method returns false, marking the string as invalid. Any non-numeric or non-decimal characters also return false results.

We can validate the method with some test cases:

assertTrue(isNumeric("123"));
assertTrue(isNumeric("123.45"));
assertFalse(isNumeric("123a"));
assertFalse(isNumeric("123.45.67"));
assertFalse(isNumeric(""));
assertFalse(isNumeric("."));
assertFalse(isNumeric(null));

This method only handles basic decimal numbers (such as 123.45) and cannot process scientific notation (like 1.23E3) or negative signs (as in -123).

3. Using Integer.parseInt() and Double.parseDouble()

One common approach is using Integer.parseInt() or Double.parseDouble() to check if a string can be converted to a numeric type. If the parsing is successful, the string is a valid number. However, if the parsing fails, a NumberFormatException is thrown, indicating an invalid number.

Let’s see a code snippet demonstrating their usage:

boolean isInteger(String str) {
    if (str == null) {
        return false;
    }
    try {
        Integer.parseInt(str);
        return true;
    } catch (NumberFormatException e) {
        return false;
    }
}

boolean isDouble(String str) {
    if (str == null){
        return false;
    }
    try {
        Double.parseDouble(str);
        return true;
    } catch (NumberFormatException e) {
        return false;
    }
}

Let’s validate the method with some test cases:

assertTrue(isInteger("123"));
assertFalse(isInteger("123.45"));
assertFalse(isInteger("abc"));

assertTrue(isDouble("123.45"));
assertTrue(isDouble("123"));
assertFalse(isDouble("12a"));

Both methods throw NumberFormatException if the string is not a valid number, so we use a try-catch block to handle this exception and return false. This method is straightforward but limited to numeric types (int and double) within their ranges.

4. Using BigDecimal

Next, we can use BigDecimal to handle larger numbers and diverse formats, making it an excellent choice for precise number validation. The BigDecimal class is part of Java’s java.math package and is designed to manage arbitrary-precision decimal values. It’s capable of parsing integers, decimals, and even numbers in scientific notation.

Let’s see how we can use BigDecimal for numeric validation:

boolean isBigDecimal(String str) {
    if (str == null) {
        return false;
    }
    try {
        new BigDecimal(str);
        return true;
    } catch (NumberFormatException e) {
        return false;
    }
}

Similar to the parsing approach, if the string can’t be parsed into a valid BigDecimal, a NumberFormatException is thrown to indicate an invalid number.

Let’s validate the method with some test cases:

assertTrue(isBigDecimal("123.45"));
assertTrue(isBigDecimal("123"));
assertTrue(isBigDecimal("1.23E3"));
assertFalse(isBigDecimal("123abc"));
assertFalse(isBigDecimal(null));

Since BigDecimal can handle integers, decimals, and scientific notation, it’s well-suited for financial applications where precision is critical.

5. Using Regular Expressions

Using regular expressions is another way to verify if a string is a valid number. This method allows us to customize the pattern for different types of numbers (integers, decimals, positive/negative numbers).

Let’s write a regular expression that can match valid numbers:

^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?$

This regular expression matches:

• Optional leading + or – sign
• Zero or more digits
• Optional decimal point
• Zero or more digits after the decimal point
• Match scientific notation

Let’s use Regex to validate a numeric string:

static final Pattern NUMBER_PATTERN = Pattern.compile("^[-+]?[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?$");

boolean isValidNumberRegex(String str) {
    return str != null && NUMBER_PATTERN.matcher(str).matches();
}

Let’s write a few test cases to validate the method:

assertTrue(isValidNumberRegex("123"));
assertTrue(isValidNumberRegex("-123.45"));
assertTrue(isValidNumberRegex("+123.45"));
assertTrue(isValidNumberRegex("1.23E3"));
assertFalse(isValidNumberRegex("123a"));
assertFalse(isValidNumberRegex("123..45"));

This method is flexible and allows us to define exact numeric formats, making it ideal for specific requirements like positive/negative numbers or decimals. However, creating complex patterns such as currency formats or exponential numbers may increase complexity and maintenance requirements.

6. Using Apache Commons NumberUtils

Apache Commons NumberUtils is a powerful library that offers a suite of utility methods for working with numbers. One of its key functionalities is validating whether a given string represents a number.

To use this method, we’ll need to add the Apache Commons Lang library to our project:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.17.0</version>
</dependency>

Then, we can use NumberUtils.isCreatable() to determine whether a given string can be converted to a number. It handles various number formats, including integers, decimals, and scientific notation.

Let’s validate the method with some test cases:

assertTrue(NumberUtils.isCreatable("123"));
assertTrue(NumberUtils.isCreatable("123.45"));
assertTrue(NumberUtils.isCreatable("-123.45"));
assertTrue(NumberUtils.isCreatable("1.23E3"));
assertFalse(NumberUtils.isCreatable("123a"));
assertFalse(NumberUtils.isCreatable("12.3.45"));

7. Conclusion

In this article, we explored multiple methods for validating if a string is numeric in Java. We covered approaches from basic character iteration to using regular expressions and Java’s built-in parsing methods, such as Integer.parseInt(), Double.parseDouble(), and BigDecimal. We also looked at the NumberUtils.isCreatable() method from Apache Commons.