Java：在字符串中，如何提取正则表达式匹配之前的数字？

Question

I have a string that contains a fraction of 100. The string looks like this:

blah
SCORE
95 / 100
USAGE
1.4GB / Unlimited
blah

I want to get the value that is before " / 100". In the above case, this value would be 95. But it can be any number between 0 and 100.

I know that if I use the following regex expression matches the " / 100" portion of the string. What I need to know is how to get the number that precedes this match.

\s\/\s100

Answer 1

You can use a positive lookahead in order to make digits preceded by that pattern.

In the expression below, "95" would be in the capturing group.

\b(\d+)\b(?= \/ 100\b)

• \\b - Word boundary to ensure that the digit isn't surrounded by any other characters.

• (\\d+) - Capturing group to match one or more digits.

• (?= \\/ 100\\b) - Positive lookahead to match the preceeding digits if they are followed by / 100 .

---

But it can be any number between 0 and 100.

If the number has to be between 0 and 100, use could also use the following:

\b(\d{1,2}|100)\b(?= \/ 100\b)

• \\d{1,2}|100 matches a number between 0-100
• The rest is the same as the example above.

Answer 2

Assuming there is only one XX / 100 (where XX can be 100 or a 1- or 2-digit integer) in your string and it appears at the beginning of some line, you can safely use

"(?m)^(100|\\d{1,2})\\s*/\\s*100\\b"

See Java demo :

String str = "blah\nSCORE\n95 / 100\nUSAGE\n1.4GB / Unlimited\nblah";
Pattern ptrn = Pattern.compile("(?m)^(100|\\d{2})\\s*/\\s*100\\b");
Matcher matcher = ptrn.matcher(str);
if (matcher.find()) {
    System.out.println(matcher.group(1));
} // => 95

The regex matches :

• (?m)^ - start of a line (since (?m) enables a multiline mode when ^ matches a line start rather than a string start) that is followed by...
• (100|\\\\d{1,2}) - a capturing group #1 that matches 100 or any 1 or 2 digits
• \\\\s*/\\\\s* - zero or more whitespaces followed by / followed by zero or more whitespaces
• 100\\\\b - a whole word 100 (that is, there can be no more digits, or even letters and an underscore _ right after).

Note that the value is captured (due to a paire of unescaped parentheses (...) ) into Group 1 that we get with matcher.group(1) after executing the matcher. Capturing is more appropriate for this task since you need no overlapping matches where lookarounds are necessary, and they are less efficient than capturing.