If you have a few years of experience in the Java ecosystem and you’d like to share that with the community, have a look at our **Contribution Guidelines**.

# Find All Numbers in a String in Java

Last modified: January 19, 2022

## 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>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>31.0.1-jre</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()) {
integerList.add(matcher.group());
}
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()) {
decimalNumList.add(matcher.group());
}
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");
```

### 5.2. Hexadecimal

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)
.containsExactly("aF851B", "-3f6C", "-2Ad9eE", "70ae19");
```

## 6. Conclusion

In this article, we first discussed how to count digits in a string using regular expressions and the *CharMatcher* class from Google Guava.

Then, we explored using regular expressions to find integers and decimal numbers.

Finally, we covered finding numbers in other formats such as scientific notation and hexadecimal.

As always, the source code for this tutorial can be found over on GitHub.