Check if the First Letter of a String Is a Number

1. Overview

In this short tutorial, we’ll learn how to check if the first character of a string is a number in Java.

We’ll start by exploring ways to do this using the JDK itself. Then we’ll see how to achieve the same objective using third-party libraries such as Guava.

2. Using the JDK

Java provides multiple convenient ways to check whether a string starts with a number. So let’s take a close look at each option.

2.1. Using charAt()

The easiest way to achieve our objective is using the charAt() method.

First, we’ll use charAt(0) to return the first character:

static boolean checkUsingCharAtMethod(String str) {
    if (str == null || str.length() == 0) {
        return false;
    }

    char c = str.charAt(0);
    return c >= '0' && c <= '9';
}

In the above example, we return false if the specified string is null or its length is zero. Otherwise, we get the first character and check if it’s a number.

Next, let’s confirm this using a test case:

@Test
void givenString_whenUsingCharAtMethod_thenSuccess() {
    assertTrue(FirstCharDigit.checkUsingCharAtMethod("12 years"));
    assertFalse(FirstCharDigit.checkUsingCharAtMethod("years"));
    assertFalse(FirstCharDigit.checkUsingCharAtMethod(""));
    assertFalse(FirstCharDigit.checkUsingCharAtMethod(null));
}

2.2. Using Character.isDigit()

The Character class comes with a handy method called isDigit(). As the name implies, it determines if the specified character is a digit.

Let’s see it in action:

static boolean checkUsingIsDigitMethod(String str) {
    return Character.isDigit(str.charAt(0));
}

As we see above, we get the first character using charAt(0). Then, we pass the returned value to the isDigit() method.

Now, let’s test it using a test case:

@Test
void givenString_whenUsingIsDigitMethod_thenSuccess() {
    assertTrue(FirstCharDigit.checkUsingIsDigitMethod("10 cm"));
    assertFalse(FirstCharDigit.checkUsingIsDigitMethod("cm"));
    assertFalse(FirstCharDigit.checkUsingIsDigitMethod(""));
    assertFalse(FirstCharDigit.checkUsingIsDigitMethod(null));
}

2.3. Using Pattern Class

Alternatively, we can use the Pattern class to compile a regular expression that checks if a given string starts with a digit.

Typically, we can use the regex  “^[0-9]” or “^\\d” to match a string that begins with a number.

Next, let’s see how to use Pattern to compile our regex against a given string:

static boolean checkUsingPatternClass(String str) {

    return Pattern.compile("^[0-9].*")
      .matcher(str)
      .matches();
}

As we can see, compile() returns a Matcher which provides the matches() method.

This solution also works fine, as demonstrated in the unit test:

@Test
void givenString_whenUsingPatternClass_thenSuccess() {
    assertTrue(FirstCharDigit.checkUsingPatternClass("1 kg"));
    assertFalse(FirstCharDigit.checkUsingPatternClass("kg"));
    assertFalse(FirstCharDigit.checkUsingPatternClass(""));
    assertFalse(FirstCharDigit.checkUsingPatternClass(null));
}

2.4. Using matches()

Another way to check whether a string starts with a number is to use the matches() method. It accepts a regex as a parameter.

So, let’s reuse the same regex we specified in the previous example:

static boolean checkUsingMatchesMethod(String str) {
    return str.matches("^[0-9].*");
}

Now let’s add another test case to verify that our method works as expected:

@Test
void givenString_whenUsingMatchesMethod_thenSuccess() {
    assertTrue(FirstCharDigit.checkUsingMatchesMethod("123"));
    assertFalse(FirstCharDigit.checkUsingMatchesMethod("ABC"));
    assertFalse(FirstCharDigit.checkUsingMatchesMethod(""));
    assertFalse(FirstCharDigit.checkUsingMatchesMethod(null));
}

3. Using Guava

Similarly, we can use the Guava library to accomplish the same purpose. First, we need to add the Guava dependency to the pom.xml file:

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.0.1-jre</version>
</dependency>

Guava provides a set of ready-to-use utility classes for string and character manipulation. Among these classes, we find the CharMatcher class.

3.1. Using CharMatcher.inRange()

The utility class CharMatcher comes with a static method called inRange(), which matches any character in a given range.

The main idea here is to define a range that denotes digits only.

Now, let’s exemplify the use of CharMatcher.inRange():

static boolean checkUsingCharMatcherInRangeMethod(String str) {

    return CharMatcher.inRange('0', '9')
      .matches(str.charAt(0));
}

Notably, both endpoints ‘0’ and ‘9’ are inclusive here.

As always, let’s create a test case to test our method:

@Test
void givenString_whenUsingCharMatcherInRangeMethod_thenSuccess() {
    assertTrue(FirstCharDigit.checkUsingCharMatcherInRangeMethod("2023"));
    assertFalse(FirstCharDigit.checkUsingCharMatcherInRangeMethod("abc"));
    assertFalse(FirstCharDigit.checkUsingCharMatcherInRangeMethod(""));
    assertFalse(FirstCharDigit.checkUsingCharMatcherInRangeMethod(null));
}

3.2. Using CharMatcher.forPredicate()

Alternatively, we can use CharMatcher.forPredicate() to indicate whether a given character is a digit. So, let’s see it in practice:

static boolean checkUsingCharMatcherForPredicateMethod(String str) {

    return CharMatcher.forPredicate(Character::isDigit)
      .matches(str.charAt(0));
}

In a nutshell, we applied the predicate Character::isDigit on the first character of the given string.

Now, let’s confirm that everything works using a test case:

@Test
void givenString_whenUsingCharMatcherForPredicateMethod_thenSuccess() {
    assertTrue(FirstCharDigit.checkUsingCharMatcherForPredicateMethod("100"));
    assertFalse(FirstCharDigit.checkUsingCharMatcherForPredicateMethod("abdo"));
    assertFalse(FirstCharDigit.checkUsingCharMatcherForPredicateMethod(""));
    assertFalse(FirstCharDigit.checkUsingCharMatcherForPredicateMethod(null));
}

4. Conclusion

In this short article, we learned a variety of ways to check whether the first character of a given string is a number.

We looked at some ways to do this using the JDK methods. Then we discussed how to achieve the same objective using Guava.