Is it better to check `c >= '0'` or `c >= 48`?

Question

After a discussion with some my colleagues, I've a 'philosophical' question about how treat the char data type in Java, following the best practices.

Suppose a simple scenario (obviously this is only a very simple example in order to give a practice meaning to my question) where, given a String 's' as input, you have to count the number of numeric characters present in it.

These are the 2 possible solutions:

1)

    for(int i=0; i<s.length(); i++) {
        if(s.charAt(i) >= 48 && s.charAt(i) <= 57) {
            n++;
        }
    }

2)

    for(int i=0; i<s.length(); i++) {
        if(s.charAt(i) >= '0' && s.charAt(i) <= '9' ) {
            n++;
        }
    }

Which of the two is more 'clean' and compliant with the Java best practices?

Answer 1

Both are horrible, but the first is more horrible.

Both ignore Java's built-in capability to decide what characters are "numeric" (via methods in Character). But the first one not only ignores the Unicode nature of strings, assuming that there can be only 0123456789, it also obscures even this invalid reasoning by using character codes that make sense only if you know something about the history of character encodings.

Answer 2

Neither. Let Java's built-in Character class figure it out for you.

for (int i = 0; i < s.length(); ++i) {
  if (Character.isDigit(s.charAt(i))) {
    ++n;
  }
}

There are a few more character ranges than the ASCII digits that count as digits, and neither example you posted will count them. The JavaDoc for Character.isDigit() lists these character ranges as being valid digits:

Some Unicode character ranges that contain digits:

• '\u0030' through '\u0039', ISO-LATIN-1 digits ('0' through '9')
• '\u0660' through '\u0669', Arabic-Indic digits
• '\u06F0' through '\u06F9', Extended Arabic-Indic digits
• '\u0966' through '\u096F', Devanagari digits
• '\uFF10' through '\uFF19', Fullwidth digits

Many other character ranges contain digits as well.

That being said, one should delegate to Character.isDigit() even with this list. As new Unicode planes are populated, the Java code will be updated. Upgrading the JVM could make old code work with new digit characters seamlessly. It is also DRY: by localizing the "is this a digit" code to one place referenced elsewhere, the negative aspects of code duplication (i.e. bugs) can be avoided. Finally, note the last line: this list is not exhaustive, and there are other digits.

Personally, I would rather delegate to the core Java libraries and spend my time on more productive tasks than "figuring what is a digit."

---

The only exception to this rule is if you really do need to test for the literal ASCII digits and not other digits. For example, if you are parsing a stream and only ASCII digits (as opposed to other digits) have special meaning, then it would not be appropriate to use Character.isDigit().

In that case, I would write another method, e.g. MyClass.isAsciiDigit() and put the logic in there. You get the same benefits of code reuse, the name is super-clear as to what it is checking, and the logic is correct.

Answer 3

If you ever write an application in C that uses EBCDIC as the basic character set and needs to process ASCII characters then use 48 and 57. Are you doing that? I don't think so.

About using isDigit(): it depends. Are you writing a JSON parser? Only 0 to 9 are accepted as digits, so don't use isDigit(), check for >= '0' and <= '9'. Are you processing user input? Use isDigit() as long as the rest of your code actually can handle the string and turn it into a number correctly.

Answer 4

The second example is clearly superior. The meaning of the second example is immediately obvious when you look at the code. The meaning of the first example is only obvious if you have memorized the entire ASCII table in your head.

You should distinguish between checking for a specific character, or checking for a range or class of characters.

1) Checking for a specific character.

For ordinary characters, use the character literal, e.g., if(ch=='z').... If you check against special characters like tab or line break, you should use the escapes, like if (ch=='\n').... If the character you are checking for is unusual (e.g not immediately recognizable or not available on a standard keyboard), you might use a hex character code rather than the literal character. But since a hex code is a "magic value", you would extract it to a constant and document it:

const char snowman = 0x2603; // snowman char used to detect encoding issues
...
if (ch==showman)...

Hex codes is the standard way of specifying character codes.

2) Checking for a character class or range

You really shouldn't be doing this directly in application code, but should encapsulate it in a separate class only concerned with character classification. And you should be vary of this, since libraries already exists for this purpose, and character classification is usually more complex than you think, at least if you consider characters outside the ASCII-range.

If you are only concerned about characters in the ASCII range, you could use character literals in this library, otherwise you would probably use hex-literals. If you look at the source code for the the Java builtin character library, it also refers to character values and ranges using hexadecimal, since this is how they are specified in the Unicode standard.

Answer 5

It's always better to use c >= '0' because for c >= 48 you need to convert c in ascii code.

Answer 6

Regular Expressions (RegExs) have a specific character class for digits - \d - that can be used to remove any other character from your string. The length of the resulting string is the desired value.

public static int countDigits(String str) {
    str = Objects.requireNonNull(str).trim();

    return str.replaceAll("[^\\d]", "").length();
}

Notice, however, that RegExs are computationally more demanding than the other proposed solutions therefore they should not be generally preferred.