Java regex capturing groups indexes

by

Capturing and grouping

Capturing group (pattern) creates a group that has capturing property.

A related one that you might often see (and use) is (?:pattern), which creates a group without capturing property, hence named non-capturing group.

A group is usually used when you need to repeat a sequence of patterns, e.g. (\.\w+)+, or to specify where alternation should take effect, e.g. ^(0*1|1*0)$ (^, then 0*1 or 1*0, then $) versus ^0*1|1*0$ (^0*1 or 1*0$).

A capturing group, apart from grouping, will also record the text matched by the pattern inside the capturing group (pattern). Using your example, (.*):, .* matches ABC and : matches :, and since .* is inside capturing group (.*), the text ABC is recorded for the capturing group 1.

Group number

The whole pattern is defined to be group number 0.

Any capturing group in the pattern start indexing from 1. The indices are defined by the order of the opening parentheses of the capturing groups. As an example, here are all 5 capturing groups in the below pattern:

(group)(?:non-capturing-group)(g(?:ro|u)p( (nested)inside)(another)group)(?=assertion)
|     |                       |          | |      |      ||       |     |
1-----1                       |          | 4------4      |5-------5     |
                              |          3---------------3              |
                              2-----------------------------------------2

The group numbers are used in back-reference \n in pattern and $n in replacement string.

In other regex flavors (PCRE, Perl), they can also be used in sub-routine calls.

You can access the text matched by certain group with Matcher.group(int group). The group numbers can be identified with the rule stated above.

In some regex flavors (PCRE, Perl), there is a branch reset feature which allows you to use the same number for capturing groups in different branches of alternation.

Group name

From Java 7, you can define a named capturing group (?<name>pattern), and you can access the content matched with Matcher.group(String name). The regex is longer, but the code is more meaningful, since it indicates what you are trying to match or extract with the regex.

The group names are used in back-reference \k<name> in pattern and ${name} in replacement string.

Named capturing groups are still numbered with the same numbering scheme, so they can also be accessed via Matcher.group(int group).

Internally, Java’s implementation just maps from the name to the group number. Therefore, you cannot use the same name for 2 different capturing groups.

More Related Contents:

  1. how to write regex for this expression in java
  2. Regular expression for SSN and phone number [closed]
  3. Regex for converting xml tags key to camel case
  4. How do i find the first un-escaped quotes in Java?
  5. Incrementing only the digits from an alphanumeric string
  6. Specific String validation using regex
  7. Regexp Java for password validation
  8. Create array of regex matches
  9. Split string into array of character strings
  10. List of all special characters that need to be escaped in a regex
  11. Regular expression to match URLs in Java
  12. Using Java to find substring of a bigger string using Regular Expression
  13. Regex exactly n OR m times
  14. Detect and extract url from a string?
  15. What is the regex for “Any positive integer, excluding 0”
  16. Extract string between two strings in java
  17. Is Java Regex Thread Safe?
  18. How to extract parameters from a given url
  19. How to use java regex to match a line
  20. How to remove the backslash in string using regex in Java?
  21. Regex pattern including all special characters
  22. Java; String replace (school project)?
  23. Remove all non-“word characters” from a String in Java, leaving accented characters?
  24. java.util.regex.PatternSyntaxException: Dangling meta character ‘+’ near index 0 +
  25. How to match repeated patterns?
  26. How to escape a square bracket for Pattern compilation?
  27. What is a regex “independent non-capturing group”?
  28. Java regex error – Look-behind group does not have an obvious maximum length
  29. How can I perform a partial match with java.util.regex.*?
  30. Java replace all square brackets in a string

Leave a Comment