How to Check if a String Is Numeric in Java

By the end of this page, you will understand how to check whether a String is numeric in Java, when to use parsing with exception handling versus pattern-based validation, and how to avoid common mistakes with signs, decimals, whitespace, and null values.

A common Java task is deciding whether text can safely be treated as a number.

A String is just text. Even if it looks like a number, Java does not automatically treat it as one. Before converting it with methods like Integer.parseInt() or Double.parseDouble(), you often need to validate the input.

There are two common ways to check if a string is numeric:

1. Try parsing it

   • Attempt to convert the string to a number.
   • If parsing succeeds, the string is numeric.
   • If it throws NumberFormatException, it is not numeric.

2. Check the format first

   • Use logic such as regular expressions or character checks.
   • This is useful when you want stricter rules, such as "digits only".

Why this matters in real programming:

• User input from forms often arrives as strings.
• Query parameters and API payloads may contain invalid numeric text.
• Configuration files may contain missing or malformed values.
• Validation helps prevent crashes and improves error messages.

An important detail: "numeric" can mean different things depending on the problem.

For example:

• "123" → integer-like numeric string
• "-45" → signed integer
• "3.14" → decimal number
• "1e3" → scientific notation, valid for Double.parseDouble()
• → may need trimming first

Think of parsing like trying a key in a lock.

• If the key fits, the string is a valid number for that parser.
• If it does not fit, Java throws an error.

Think of regex or character checks like inspecting the key before using it.

• You look at its shape first.
• This can be faster for simple rules like "digits only".
• But if the rules get more complex, inspection can become harder than simply trying the lock.

A good beginner rule is:

• If you want to know whether Java can parse the value, try parsing.
• If you want a custom definition like "only positive whole numbers", validate the format explicitly.

The most reliable general-purpose approach in Java is to try parsing the string.

Example: check for an integer

public class Main {
    public static boolean isInteger(String value) {
        if (value == null) {
            return false;
        }

        try {
            Integer.parseInt(value);
            return true;
        } catch (NumberFormatException e) {
            return false;
        }
    }

    public static void main(String[] args) {
        System.out.println(isInteger("123"));   // true
        System.out.println(isInteger("-45"));   // true
        System.out.println(isInteger("3.14"));  // false
        System.out.println(isInteger("abc"));   // false
        System.out.println(isInteger(null));     // false
    }
}

This works because Integer.parseInt() only accepts valid integer strings within the range.

Consider this example:

public static boolean isInteger(String value) {
    if (value == null) {
        return false;
    }

    try {
        Integer.parseInt(value);
        return true;
    } catch (NumberFormatException e) {
        return false;
    }
}

Now trace isInteger("42"):

1. The method receives "42".
2. It checks value == null.
3. The value is not null, so execution continues.
4. Inside the try block, Integer.parseInt("42") runs.
5. Java successfully converts the string to the integer 42.
6. No exception is thrown.
7. The method returns true.

Now trace isInteger("4.2"):

1. The method receives .

Checking whether a string is numeric appears in many real applications.

Form validation

A user enters their age in a text field. You need to ensure it is a whole number before saving it.

String ageInput = "27";
if (isInteger(ageInput)) {
    int age = Integer.parseInt(ageInput);
}

Reading query parameters in web apps

A URL might contain ?page=3. Since query parameters arrive as strings, you validate before using them.

Importing CSV data

When reading rows from a file, columns such as price, quantity, or score may contain invalid text like N/A or empty strings.

Configuration values

Environment variables and properties files store values as strings. If a timeout or port number should be numeric, validation prevents startup errors.

API request validation

Incoming JSON fields may be strings even when they represent numbers. Validation helps return a clear error instead of a server exception.

In real projects, developers usually do more than just check whether a value is numeric.

Guard clauses

A common pattern is to reject invalid input early.

public int parseUserId(String input) {
    if (input == null || input.isBlank()) {
        throw new IllegalArgumentException("User ID is required");
    }

    try {
        return Integer.parseInt(input);
    } catch (NumberFormatException e) {
        throw new IllegalArgumentException("User ID must be a valid integer");
    }
}

Validation before business logic

Developers often validate request data before performing database operations, calculations, or service calls.

Trimming input

User input often contains spaces.

String input = " 42 ";
if (isInteger(input.trim())) {
    int value = Integer.parseInt(input.trim());
}

Range validation after parsing

Here are common beginner mistakes when checking numeric strings in Java.

Mistake 1: Assuming digits-only means every numeric value

Broken example:

"-12".matches("\\d+")

This returns false because \d+ does not allow a minus sign.

Use parsing if you want standard Java numeric formats, or write a regex that matches your exact rules.

Mistake 2: Forgetting about null

Broken example:

value.matches("\\d+")

If value is null, this throws NullPointerException.

Safer version:

value != null && value.matches("\\d+")

Mistake 3: Ignoring whitespace

Broken example:

Integer.parseInt(" 42 ");

This throws because does not accept surrounding spaces.

Here is how common approaches compare.

Quick rules

• Use Integer.parseInt() for integer strings.
• Use Double.parseDouble() for decimal strings.
• Use try/catch when you want to match Java's parsing behavior.
• Use regex when you want custom format rules.
• Check for null first.
• Trim input if spaces are possible.

Common helpers

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

public static boolean isDouble(String value) {
    if (value == null) return false;
    try {
        Double.parseDouble(value);
         ;
    }  (NumberFormatException e) {
         ;
    }
}

How do I check if a string is an integer in Java?

Use Integer.parseInt() inside a try/catch block. Return true if parsing succeeds and false if it throws NumberFormatException.

Is regex better than parseInt() for numeric checks?

Not always. Regex is good for custom rules like digits only. If you want to know whether Java accepts the value as a number, parsing is usually the better choice.

Does Integer.parseInt() allow spaces?

No. Strings like " 42 " must usually be trimmed first with trim().

How do I check if a string is a decimal number in Java?

Use Double.parseDouble() in a try/catch block.

What exception is thrown for invalid numbers in Java?

NumberFormatException.

Is "-123" numeric?

Yes, if your definition includes signed integers. Integer.parseInt("-123") succeeds.

• Integer.parseInt() — converts a string to an int and is central to integer validation.
• Double.parseDouble() — used for decimal and floating-point string parsing.
• NumberFormatException — the exception Java throws when numeric parsing fails.
• try/catch — the control structure used to handle parsing failures safely.
• Regular expressions — useful for format-based checks such as digits-only validation.
• trim() — often needed before validation when user input may contain spaces.
• Input validation — the broader practice of checking data before using it.
• Guard clauses — a common pattern for rejecting invalid input early.