为什么这个前瞻断言在 Java 中不起作用？

Question

I come from a Perl background and am used to doing something like the following to match leading digits in a string and perform an in-place increment by one:

my $string = '0_Beginning';

$string =~ s|^(\d+)(?=_.*)|$1+1|e;

print $string;        # '1_Beginning'

With my limited knowledge of Java, things aren't so succinct:

String string = "0_Beginning";

Pattern p = Pattern.compile( "^(\\d+)(?=_.*)" );

String digit = string.replaceFirst( p.toString(), "$1" ); // To get the digit

Integer oneMore = Integer.parseInt( digit ) + 1;          // Evaluate ++digit

string.replaceFirst( p.toString(), oneMore.toString() );  //

The regex doesn't match here... but it did in Perl.

What am I doing wrong here?

Answer 1

Actually it matches. You can find out by printing

System.out.println(p.matcher(string).find());

The issue is with line

String digit = string.replaceFirst( p.toString(), "$1" );

which is actually a do-nothing, because it replaces the first group (which is all you match, the lookahead is not part of the match) with the content of the first group.

You can get the desired result (namely the digit) via the following code

Matcher m = p.matcher(string);
String digit = m.find() ? m.group(1) : "";

Note: you should check m.find() anyways if nothing matches. In this case you may not call parseInt and you'll get an error. Thus the full code looks something like

Pattern p = Pattern.compile("^(\\d+)(?=_.*)");

String string = "0_Beginning";

Matcher m = p.matcher(string);
if (m.find()) {
    String digit = m.group(1);
    Integer oneMore = Integer.parseInt(digit) + 1;
    string = m.replaceAll(oneMore.toString());
    System.out.println(string);
} else {
    System.out.println("No match");
}

Answer 2

Let's see what you are doing here.

String string = "0_Beginning";
Pattern p = Pattern.compile( "^(\\d+)(?=_.*)" );

You declare and initialize String and pattern objects.

String digit = string.replaceFirst( p.toString(), "$1" ); // To get the digit

(You are converting the pattern back into a string, and replaceFirst creates a new Pattern from this. Is this intentional?)

As Howard says, this replaces the first match of the pattern in the string with the contents of the first group, and the match of the pattern is just 0 here, as the first group. Thus digit is equal to string , ...

Integer oneMore = Integer.parseInt( digit ) + 1;          // Evaluate ++digit

... and your parsing fails here.

string.replaceFirst( p.toString(), oneMore.toString() );  //

This would work (but convert the pattern again to string and back to pattern).

Here how I would do this:

String string = "0_Beginning";
Pattern p = Pattern.compile( "^(\\d+)(?=_.*)" );

Matcher matcher = p.matcher(string);
StringBuffer result = new StringBuffer();
while(matcher.find()) {
    int number = Integer.parseInt(matcher.group());
    m.appendReplacement(result, String.valueOf(number + 1));
}
m.appendTail(result);
return result.toString(); // 1_Beginning

(Of course, for your regex the loop will only execute once, since the regex is anchored.)

---

Edit : To clarify my statement about string.replaceFirst:

This method does not return a pattern, but uses one internally. From the documentation :

Replaces the first substring of this string that matches the given regular expression with the given replacement.

An invocation of this method of the form str.replaceFirst(regex, repl) yields exactly the same result as the expression

Pattern.compile(regex).matcher(str).replaceFirst(repl)

Here we see that a new pattern is compiled from the first argument.

This also shows us another way to do what you did want to do:

String string = "0_Beginning";
Pattern p = Pattern.compile( "^(\\d+)(?=_.*)" );
Matcher m = p.matcher(string);
if(m.find()) {
    digit = m.group();
    int oneMore = Integer.parseInt( digit ) + 1
    return m.replaceFirst(string, String.valueOf(oneMore));
}

This only compiles the pattern once, instead of thrice like in your original program - but still does the matching twice (once for find, once for replaceFirst ), instead of once like in my program.