## 1. Overview

Sometimes we need to find numeric digits or full numbers in strings. We can do this with both regular expressions or certain library functions.

In this article, we'll use regular expressions to find and extract numbers in strings. We'll also cover some ways to count digits.

## 2. Counting Numeric Digits

Let's start by counting the digits found within a string.

### 2.1. Using Regular Expressions

We can use Java Regular Expressions to count the number of matches for a digit.

In regular expressions, \d matches “any single digit”. Let's use this expression to count digits in a string:

``````int countDigits(String stringToSearch) {
Pattern digitRegex = Pattern.compile("\\d");
Matcher countEmailMatcher = digitRegex.matcher(stringToSearch);

int count = 0;
while (countEmailMatcher.find()) {
count++;
}

return count;
}``````

Once we have defined a Matcher for the regex, we can use it in a loop to find and count all the matches. Let's test it:

``````int count = countDigits("64x6xxxxx453xxxxx9xx038x68xxxxxx95786xxx7986");

assertThat(count, equalTo(21));``````

### 2.2. Using the Google Guava CharMatcher

To use Guava, we first need to add the Maven dependency:

``````<dependency>
<artifactId>guava</artifactId>
<version>30.1.1</version>
</dependency>``````

Guava provides the CharMatcher.inRange​ method for counting digits:

``````int count = CharMatcher.inRange('0', '9')
.countIn("64x6xxxxx453xxxxx9xx038x68xxxxxx95786xxx7986");

assertThat(count, equalTo(21));``````

## 3. Finding Numbers

Counting numbers requires patterns that capture all the digits of a valid numeric expression.

### 3.1. Finding Integers

To construct an expression to recognize integers, we must consider that they can be positive or negative and consist of a sequence of one or more digits. We also note that negative integers are preceded by a minus sign.

Thus, we can find integers by extending our regex to “-?\d+“. This pattern means “an optional minus sign, followed by one or more digits”.

Let's create an example method that uses this regex to find integers in a string:

``````List<String> findIntegers(String stringToSearch) {
Pattern integerPattern = Pattern.compile("-?\\d+");
Matcher matcher = integerPattern.matcher(stringToSearch);

List<String> integerList = new ArrayList<>();
while (matcher.find()) {
}

return integerList;
}``````

Once we have created a Matcher on the regex, we use it in a loop to find all the integers in a string. We call group on each match to get all the integers.

Let's test findIntegers:

``````List<String> integersFound =
findIntegers("646xxxx4-53xxx34xxxxxxxxx-35x45x9xx3868xxxxxx-95786xxx79-86");

assertThat(integersFound)
.containsExactly("646", "4", "-53", "34", "-35", "45", "9", "3868", "-95786", "79", "-86");
``````

### 3.2. Finding Decimal Numbers

To create a regex that finds decimal numbers, we need to consider the pattern of characters used when writing them.

If a decimal number is negative, it starts with a minus sign. This is followed by one or more digits and an optional fractional part. This fractional part starts with a decimal point, with another sequence of one or more digits after that.

We can define this using the regular expression “-?\d+(\.\d+)?“:

``````List<String> findDecimalNums(String stringToSearch) {
Pattern decimalNumPattern = Pattern.compile("-?\\d+(\\.\\d+)?");
Matcher matcher = decimalNumPattern.matcher(stringToSearch);

List<String> decimalNumList = new ArrayList<>();
while (matcher.find()) {
}

return decimalNumList;
}``````

Now we'll test findDecimalNums:

``````List<String> decimalNumsFound =
findDecimalNums("x7854.455xxxxxxxxxxxx-3x-553.00x53xxxxxxxxxxxxx3456xxxxxxxx3567.4xxxxx");

assertThat(decimalNumsFound)
.containsExactly("7854.455", "-3", "-553.00", "53", "3456", "3567.4");
``````

## 4. Converting the Strings Found into Numeric Values

We may also wish to convert the found numbers into their Java types.

Let's convert our integer numbers into Long using Stream mapping:

``````LongStream integerValuesFound = findIntegers("x7854x455xxxxxxxxxxxx-3xxxxxx34x56")
.stream()
.mapToLong(Long::valueOf);

assertThat(integerValuesFound)
.containsExactly(7854L, 455L, -3L, 34L, 56L);``````

Next, we'll convert decimal numbers to Double in the same way:

``````DoubleStream decimalNumValuesFound = findDecimalNums("x7854.455xxxxxxxxxxxx-3xxxxxx34.56")
.stream()
.mapToDouble(Double::valueOf);

assertThat(decimalNumValuesFound)
.containsExactly(7854.455, -3.0, 34.56);``````

## 5. Finding Other Types of Numbers

Numbers can be expressed in other formats, which we can detect by adjusting our regular expressions.

### 5.1. Scientific Notation

Let's find some numbers formatted using scientific notation:

``````String strToSearch = "xx1.25E-3xxx2e109xxx-70.96E+105xxxx-8.7312E-102xx919.3822e+31xxx";

Matcher matcher = Pattern.compile("-?\\d+(\\.\\d+)?[eE][+-]?\\d+")
.matcher(strToSearch);

// loop over the matcher

assertThat(sciNotationNums)
.containsExactly("1.25E-3", "2e109", "-70.96E+105", "-8.7312E-102", "919.3822e+31");
``````

Now we'll find hexadecimal numbers in a string:

``````String strToSearch = "xaF851Bxxx-3f6Cxx-2Ad9eExx70ae19xxx";

Matcher matcher = Pattern.compile("-?[0-9a-fA-F]+")
.matcher(strToSearch);

// loop over the matcher

assertThat(hexNums)