Repeating regular expression

Question

I have a log file which i want to parse. It is about getting the Values between the square brackets and after the "OK:" using regex. The Problem is i do not know how many times the pattern is occuring and i can not say how long each code is. So i can only relay on the fact that it is surrounded by "[OK:" and "]".

So far i tried to use this pattern here as regex:

String ok_pattern = "(.*itId=<)(.{1,10})(>.*)(\\[OK:)(.{4,27})(].*)";
Pattern p_ok = Pattern.compile(ok_pattern);

String testString = "RANDOMTEXT itId=<1232> Code < [OK:AZ1000105]  [OK:10000006] [OK:F1000000007] > RANDOMTEXT";

Matcher m = p_ok.matcher(testString);
if(m.find()) {
    System.out.println(m.group(5));
}

But this only works for the case when there is only one "[OK:...]". I played around with using a "*" and "+" after the 5th group but i could not succeed. How do i do this repetetive and still capture all results?

My goal is to extract the itemId and the (char-)number combination after the "OK:" using regex. So in this example I want to get "1232"(ItemID) and "AZ1000105", "10000006", "F1000000007".

I am thankful for every help!

Answer 1

Your basic setup is correct, but your pattern is somewhat off from ideal. Try using the following regex pattern:

(?<=\[OK:)[^\]]+|(?<=itId=<)[^>]+

This still uses a lookbehind, but it only asserts that what precedes is [OK: . Then, it matches, without even using a capture group, any amount of characters which are not a closing square bracket. This corresponds to the content you are trying to find. The portion to the right of the alternation matches itId values.

String ok_pattern = "(?<=\\[OK:)[^\\]]+|(?<=itId=<)[^>]+";
Pattern p_ok = Pattern.compile(ok_pattern);
String testString = "RANDOMTEXT itId=<1232> Code < [OK:AZ1000105]  [OK:10000006] [OK:F1000000007] > RANDOMTEXT";

Matcher m = p_ok.matcher(testString);
while (m.find()) {
    System.out.println(m.group(0));
}

1232
AZ1000105
10000006
F1000000007

Answer 2

If you want to capture the digits in itId=<1232> followed by subsequent captures of what is after OK: in that order , you could make use of the \\G anchor to assert the position at the end of the previous match.

Match the itId digits in the first capturing group and the value of OK: in the second capturing group:

itId=<(\d+)> Code < |\G(?!^)\[OK:([A-Z0-9]+)\]\s*

In Java:

String ok_pattern = "itId=<(\\d+)> Code < |\\G(?!^)\\[OK:([A-Z0-9]+)\\]\\s*";

Explanation

• itId=<(\\d+)> Code < Match the first part and capture 1+ digits in group 1
• | Or
• \\G(?!^) End of the previous match, not at the start
• \\[OK:([A-Z0-9]+)\\]\\s* Match [OK: , then capture your value in group 2 and match ] followed by 0+ whitespace chars

Regex demo | Java demo

Note that if you want to match more than ([A-Z0-9]+) you could also use a negated character class to match not a square bracket ([^]]+)

For example, you might check for the existence of the groups:

String ok_pattern = "itId=<(\\d+)> Code < |\\G(?!^)\\[OK:([^]]+)\\]\\s*";
Pattern p_ok = Pattern.compile(ok_pattern);
String testString = "RANDOMTEXT itId=<1232> Code < [OK:AZ1000105]  [OK:10000006] [OK:F1000000007] > RANDOMTEXT";
Matcher m = p_ok.matcher(testString);

while(m.find()) {
    if (null != m.group(1)) {
        System.out.println("itId: " + m.group(1));  
    }
    if (null != m.group(2)) {
        System.out.println("Ok code: " + m.group(2));   
    }   
}