正则表达式以分组提取子字符串

Question

I want to extract names from the following input using regular expression.

Student Names:
    Name1
    Name2
    Name3

Parent Names:
    Name1
    Name2
    Name3

I am using the following method to match the data and I am not supposed to modify the method. I have to come up with regular expression that works with this method.

public void parseName(String patternRegX){

        Pattern patternDomainStatus = Pattern.compile(patternRegX);
        Matcher matcherName = patternName.matcher(inputString);
        List<String> tmp=new ArrayList<String>();

        while (matcherName.find()){
            if (!matcherName.group(2).isEmpty())
                tmp.add(matcherName.group(2));
        }
}

I came up with a regular expression that could get me the desired result, but the problem I found was that grouping doesn't work inside square brackets([]).

private String studentRegX="(Student Names:\\n[ + (\\S+) \\n]+\\n)";

I am using the following regular expression now, but that is getting me only the last name in each set.

 private String studentRegX="Student Names:\\\\n( +(\\\\S+)\\\\n)+\\\\n"; private String parentRegX="Parent Names:\\\\n( +(\\\\S+)\\\\n)+\\\\n"; 

Thank you in advance for the help.

Answer 1

First of all, I hope you can change the parseName method a little bit, because it doesn't compile. patternDomainStatus and patternName are probably supposed to refer to the same object:

    Pattern pattern = Pattern.compile(patternRegX);
    Matcher matcherName = pattern.matcher(inputString);

Secondly, you need to think about your regex a little differently.

Right now, your regexes are trying to match entire chunks with multiple names in them. But matcherName.find() finds "the next subsequence of the input sequence that matches the pattern" (per the javadoc).

So what you want is a regex that matches a single name . matcherName.find() will loop through each part of your string that matches that regex.

Answer 2

If you're not already familiar with the difference between repeating a capturing group and capturing a repeating group, that's worth reading up on. One resource for that is http://www.regular-expressions.info/captureall.html , but others would be fine too.

If you already knew about that difference and were trying to capture a repeating group already with what you've written above, then please edit your post to explain what you're trying to do (a letter-by-letter explanation would be ideal, so we see what you understand and what you don't, so we can help you with whatever you're stuck on).

I see what I believe is the solution, but since this is clearly homework, I'm not willing to simply give it to you. But I'd be happy to help you figure it out.

--- Edit: ---

You're only getting one match because the regex requires "Student Names:" or "Parent Names:" to be in each match, so you can only match once. For your regex to match multiple times in a row (as required by the while (matcherName.find()) ), you need to get the "Student Names:" and "Parent Names:" out of the regex, so the regex can match repeatedly.

It's easy to get all of the names (both students and parents), with just a regex that looks for newlines followed by one or more spaces and then text. The challenge is to differentiate the student names (which come before the "Parent Names:" line) from the parent names (which come after the "Parent Names:" line). The key concept for differentiating between them is lookaheads , which can be positive or negative. Take a look at them and see if you can figure out how to implement this using lookaheads.

Also, you may find that group #2 isn't the group you really want to use. It's unfortunate that the group number is hard-coded, but since it is, you can tweak your regex to make groups non-capturing with (?:stuff) syntax. That will let you reduce the number of groups and ensure that the group you actually want is #2.

Answer 3

Because regex has little to do with algorithmic prowess, here an answer:

• On Windows the line break is unfortunately "\\r\\n".
• I check that a newline preceded and that there is at least some white space before the name.
• The name may have a space.
• With look-behind I check that "Parent Names" follows.

Then

Pattern.compile("(?s)(?<=\n)[ \t]+([^\r\n]*)\r?\n(?=.*Parent Names)");
//               ~~~~ '.' also matches newline
//                   ~~~~~~~ look-behind must be newline
//                          ~~~~~~ whitespace (spaces/tabs)
//                                ~~~~~~~~~~ group 1, name
//                                               ~~~~~~~~~~~~~~~~~~~~ look-ahead

Without say, a bit different algorithm would be more solid and understandable.

To make it group(2) instead of the above group(1), you could introduce extra braces before: ([ \\t]+)

Answer 4

It can be done using the \\G anchor all in a single regex.
This opens it up for a little regex algorithmic prowess. Each match will be either:

• Group 1 is not NULL/empty - New student group, group 3 will contain first student name.
• Group 2 is not NULL/empty - New parent group, group 3 will contain first parent name.
• Group 3 is never NULL/empty - The first/next either student or parent name depending on which
  group 1 or 2 last matched.

In all cases, group 3 will contain a name that has been trimmed and ready to put into an array.

---

 # "~(?mi-)(?:(?!\\A)\\G|^(?:(Student)|(Parent))[ ]Names:)\\s*^(?!(?:Student|Parent)[ ]Names:)[^\\S\\r\\n]*(.+?)[^\\S\\r\\n]*$~"

 (?xmi-)                     # Inline 'Expanded, multiline, case insensitive' modifiers
 (?:
      (?! \A )                    # Here, matched before, give Name a first chance
      \G                          # to match again.
   |  
      ^                           # BOL
      (?:
           ( Student )                 # (1), New 'Student' group
        |  ( Parent )                  # (2), New 'Parent' group
      )
      [ ] Names: 
 )
                             # Name section
 \s*                         # Consume all whitespace up until the start of a Name line
 ^                           # BOL 
 (?!
      (?: Student | Parent )      # Names only, Not the start of Student/Parent group here
      [ ] Names:
 )
 [^\S\r\n]*                  # Trim leading whitespace ( can use \h if supported )
 ( .+? )                     # (3), the Name
 [^\S\r\n]*                  # Trim trailing whitespace ( can use \h if supported )
 $                           # EOL