CODEWITHSUNDEEP
java
user86834
user86834

Reputation: 5635

Validate a String to see if it is an Integer?

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;

Upvotes: 0

Views: 154

Answers (3)

Nico Villanueva
Nico Villanueva

Reputation: 894

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?

Upvotes: 0

Marcin Szymczak
Marcin Szymczak

Reputation: 11433

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;
    }

Upvotes: 0

Adam Rosenfield
Adam Rosenfield

Reputation: 400174

"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.

Upvotes: 1

Related Questions