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.
As always, the complete source code of the examples is available over on GitHub.
