Validate a String to see if it is an Integer?

Question

Not keen on using the parseInteger solution, it is ugly, and as Joshua Bloch says you should "Use exceptions only for exceptional conditions". Of course, I can use something like block of code below, but it doesn't guarantee it is an Integer.

for (char c : str.toCharArray())
{
    if (!Character.isDigit(c)) return false;
}
return true;

_but it doesn't guarantee it is an Integer_ Can you explain, why? If a string is digit-only it should be — BackSlash, Sep 07 '13 at 20:06
`Integer`, as in 32-bit integer, or an integer, as in arbitrarily integer that can be represented with `BigInteger`? — nhahtdh, Sep 07 '13 at 20:09
You can rewrite the `parseInt()` method to return `false` instead of throwing an exception. The method is pretty easy to read. Would that be a better solution to you? — Petr Janeček, Sep 07 '13 at 20:12
What you are suggesting is more or less what `parseInteger` does. Just look at the source code and adapt it. — Sotirios Delimanolis, Sep 07 '13 at 20:15
There may be some tips [in here](http://stackoverflow.com/q/237159/1005481). — barfuin, Sep 07 '13 at 20:16

score 1 · Accepted Answer · answered Sep 07 '13 at 20:17

"Use exceptions only for exceptional conditions" is a good practice to follow in general, but it's not a hard-and-fast rule. I think that this is one of the cases where using exceptions is better than the alternatives.

Since parseInteger() can return any possible int value, you can't use any other return value to indicate failure. If you know you're never going to process a particular value (such as -1 or -2147483648), you can return that as a sentinel value to indicate a parse failure.

The only alternative is to return a boolean indicating success or failure and to store the parsed value into a parameter. However, since function calls are always pass-by-value in Java, you'd need to create a new class to do this:

public class IntWrapper
{
    int value;
}
...

public static boolean myParseInt(String s, IntWrapper outValue)
{
    try
    {
        outValue.value = Integer.parseInt(s);
        return true;
    }
    catch(NumberFormatException e)
    {
        return false;
    }
}
...

IntWrapper value = new IntWrapper();
if (myParseInt(value))
{
    // Use value.value
}
else
{
    // Parsing failed
}

Given these alternatives, I think the simplest usage is just to use exceptions and deal with them appropriately, even though non-numeric input may not necessary be an "exceptional" condition.

score 0 · Answer 2 · answered Sep 08 '13 at 01:23

I'd leave it with exception but if you REALLY want solution without exception you can copy method parseInt() from this site with java internal classes and change it a little bit

(You can modify it a little bit more, since you do not need result)

public static false isValidInt(String s, int radix)
                throws NumberFormatException
    {
        if (s == null) {
            return false;
        }

        if (radix < Character.MIN_RADIX) {
            return false;
        }

        if (radix > Character.MAX_RADIX) {
            return false;
        }

        int result = 0;
        boolean negative = false;
        int i = 0, len = s.length();
        int limit = -Integer.MAX_VALUE;
        int multmin;
        int digit;

        if (len > 0) {
            char firstChar = s.charAt(0);
            if (firstChar < '0') { // Possible leading "-"
                if (firstChar == '-') {
                    negative = true;
                    limit = Integer.MIN_VALUE;
                } else
                    return false;

                if (len == 1) // Cannot have lone "-"
                    return false;
                i++;
            }
            multmin = limit / radix;
            while (i < len) {
                // Accumulating negatively avoids surprises near MAX_VALUE
                digit = Character.digit(s.charAt(i++),radix);
                if (digit < 0) {
                    return false;
                }
                if (result < multmin) {
                    return false;
                }
                result *= radix;
                if (result < limit + digit) {
                    return false;
                }
                result -= digit;
            }
        } else {
            return false;
        }
        return true;
    }

score 0 · Answer 3 · edited May 23 '17 at 10:31

You could use:

public static boolean isInteger(String str) {
    if (str == null) {
        return false;
    }
    int length = str.length();
    if (length == 0) {
        return false;
    }
int i = 0;
if (str.charAt(0) == '-') {
    if (length == 1) {
        return false;
    }
    i = 1;
}
for (; i < length; i++) {
    char c = str.charAt(i);
    if (c <= '/' || c >= ':') {
        return false;
    }
}
return true;
}

Already answered here: What's the best way to check to see if a String represents an integer in Java?

Validate a String to see if it is an Integer?

3 Answers3