Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

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.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

2 Comments
Oldest
Newest