Check whether a string is parsable into Long without try-catch?

Question

Hello, Long.parseLong( string ) throws an error if string is not parsable into long. Is there a way to validate the string faster than using try-catch? Thanks

Answer 1

From commons-lang StringUtils:

public static boolean isNumeric(String str) {
    if (str == null) {
        return false;
    }
    int sz = str.length();
    for (int i = 0; i < sz; i++) {
        if (Character.isDigit(str.charAt(i)) == false) {
            return false;
        }
    }
    return true;
}

Answer 2

Have a look here.

Answer 3

You could try using a regular expression to check the form of the string before trying to parse it?

Answer 4

You could do something like

if(s.matches("\\d*")){
}

Using regular expression - to check if String s is full of digits. But what do you stand to gain? another if condition?

Answer 5

I think that's the only way of checking if a String is a valid long value. but you can implement yourself a method to do that, having in mind the biggest long value.

Answer 6

You can create rather complex regular expression but it isn't worth that. Using exceptions here is absolutely normal.

It's natural exceptional situation: you assume that there is an integer in the string but indeed there is something else. Exception should be thrown and handled properly.

If you look inside parseLong code, you'll see that there are many different verifications and operations. If you want to do all that stuff before parsing it'll decrease the performance (if we are talking about parsing millions of numbers because otherwise it doesn't matter). So, the only thing you can do if you really need to improve performance by avoiding exceptions is: copy parseLong implementation to your own function and return NaN instead of throwing exceptions in all correspondent cases.

Answer 7

There are much faster ways to parse a long than Long.parseLong. If you want to see an example of a method that is not optimized then you should look at parseLong :)

Do you really need to take into account "digits" that are non-ASCII?

Do you really need to make several methods calls passing around a radix even tough you're probably parsing base 10?

:)

Using a regexp is not the way to go: it's harder to determine if you're number is too big for a long: how do you use a regexp to determine that 9223372036854775807 can be parsed to a long but that 9223372036854775907 cannot?

That said, the answer to a really fast long parsing method is a state machine and that no matter if you want to test if it's parseable or to parse it. Simply, it's not a generic state machine accepting complex regexp but a hardcoded one.

I can both write you a method that parses a long and another one that determines if a long can be parsed that totally outperforms Long.parseLong().

Now what do you want? A state testing method? In that case a state testing method may not be desirable if you want to avoid computing twice the long.

Simply wrap your call in a try/catch.

And if you really want something faster than the default Long.parseLong, write one that is tailored to your problem: base 10 if you're base 10, not checking digits outside ASCII (because you're probably not interested in Japanese's itchi-ni-yon-go etc.).

Answer 8

You can use java.util.Scanner

Scanner sc = new Scanner(s);
if (sc.hasNextLong()) {
   long num = sc.nextLong();
}

This does range checking etc, too. Of course it will say that "99 bottles of beer" hasNextLong(), so if you want to make sure that it only has a long you'd have to do extra checks.