We Keep Coding

How To Match Repeating Sub-Patterns

Let's say I have a string:
String sentence = "My nieces are Cara:8 Sarah:9 Tara:10";
And I would like to find all their respective names and ages with the following pattern matcher:
String regex = "My\\s+nieces\\s+are((\\s+(\\S+):(\\d+))*)";
Pattern pattern = Pattern.compile;
Matcher matcher = pattern.matcher(sentence);
I understand something like
matcher.find(0); // resets "pointer"
String niece = matcher.group(2);
String nieceName = matcher.group(3);
String nieceAge = matcher.group(4);
would give me my last niece (" Tara:10", "Tara", "10",).
How would I collect all of my nieces instead of only the last, using only one regex/pattern?
I would like to avoid using split string.

Another idea is to use the \G anchor that matches where the previous match ended (or at start).
String regex = "(?:\\G(?!\\A)|My\\s+nieces\\s+are)\\s+(\\S+):(\\d+)";
If My\s+nieces\s+are matches
\G will chain matches from there
(?!\A) neg. lookahead prevents \G from matching at \A start
\s+(\S+):(\d+) using two capturing groups for extraction
See this demo at regex101 or a Java demo at tio.run
Matcher m = Pattern.compile(regex).matcher(sentence);
while (m.find()) {
System.out.println(m.group(1));
System.out.println(m.group(2));
}

You can't iterate over repeating groups, but you can match each group individually, calling find() in a loop to get the details of each one. If they need to be back-to-back, you can iteratively bound your matcher to the last index, like this:
Matcher matcher = Pattern.compile("My\\s+nieces\\s+are").matcher(sentence);
if (matcher.find()) {
int boundary = matcher.end();
matcher = Pattern.compile("^\\s+(\\S+):(\\d+)").matcher(sentence);
while (matcher.region(boundary, sentence.length()).find()) {
System.out.println(matcher.group());
System.out.println(matcher.group(1));
System.out.println(matcher.group(2));
boundary = matcher.end();
}
}

Extract value between brackets with RegExp

I attempt to extract values between brackets ( and ), before I was managed only to check presence of value. Help me to extract it, please.
Pattern pattern;
pattern = Pattern.compile("\\b(.*\\b)");
Matcher matcher = pattern.matcher(node.toString());
if (matcher.find()){
System.out.println();// here I need to print value that I find between brackets
}

Escape the brackets in your regex:
Pattern pattern = Pattern.compile("\\((.*?)\\)");
Then you can do:
Matcher matcher = pattern.matcher(node.toString());
if (matcher.find()){
System.out.println( matcher.group(1) );
}

Pattern to match any character until boundary character

I have the string:
String myStr = "Operation=myMethod\nDataIn=A;B;C;D\nDataOut=X;Y;Z\n"
and I want to match DataIn.
I have the following code:
Pattern pattern = Pattern.compile("Operation=myMethod.*DataIn=(.*)?\n", Pattern.DOTALL);
Matcher matcher = pattern.matcher(myStr);
if (matcher.find()) {
return matcher.group(1);
}
The problem is that it is returning: "A;B;C;D\nDataOut=X;Y;Z\n"
I tried with the patter: "Operation=myMethod.DataIn=(.?\n)"
It then returns "A;B;C;D\n". I don't want the final "\n" to be returned.

Replace (.*) in your regex by ([^\n]*) to match until the line-break, or ([^\b]*) to match until any boundary character.
Pattern pattern = Pattern.compile("Operation=myMethod.*DataIn=([^\\n]*)?\n", Pattern.DOTALL);
Matcher matcher = pattern.matcher(myStr);
if (matcher.find()) {
return matcher.group(1);
}
The [^...] construct in a character class that means match any character that isn't in this set.

You can use:
Pattern pattern = Pattern.compile("Operation=myMethod.*?DataIn=([^\\n]*)", Pattern.DOTALL);
This will match until 0 or more characters in group #1 until \n is matched.

Try using this:
PATTERN
(?<=DataIn=)(.+?)(?=\\n)
CODE
Pattern pattern = Pattern.compile("(?<=DataIn=)(.+?)(?=\\n)", Pattern.DOTALL);
Matcher matcher = pattern.matcher(myStr);
if (matcher.find())
{
return matcher.group(1);
}
INPUT
Operation=myMethod\nDataIn=A;B;C;D\nDataOut=X;Y;Z\n
OUTPUT
A;B;C;D

Regex
(?s)(?<=DataIn=)(.+?)(?=\n)
Description

Regex parse string in java

I am using Java. I need to parse the following line using regex :
<actions>::=<action><action>|X|<game>|alpha
It should give me tokens <action>, <action>,X and <game>
What kind of regex will work?
I was trying sth like: "<[a-zA-Z]>" but that doesn't take care of X or alpha.

You can try something like this:
String str="<actions>::=<action><action>|X|<game>|alpha";
str=str.split("=")[1];
Pattern pattern = Pattern.compile("<.*?>|\\|.*?\\|");
Matcher matcher = pattern.matcher(str);
while (matcher.find()) {
System.out.println(matcher.group());
}

You should have something like this:
String input = "<actions>::=<action><action>|X|<game>|alpha";
Matcher matcher = Pattern.compile("(<[^>]+>)(<[^>]+>)\\|([^|]+)\\|(<[^|]+>)").matcher(input);
while (matcher.find()) {
System.out.println(matcher.group().replaceAll("\\|", ""));
}
You didn't specefied if you want to return alpha or not, in this case, it doesn't return it.
You can return alpha by adding |\\w* to the end of the regex I wrote.
This will return:
<action><action>X<game>

From the original pattern it is not clear if you mean that literally there are <> in the pattern or not, i'll go with that assumption.
String pattern="<actions>::=<(.*?)><(.+?)>\|(.+)\|<(.*?)\|alpha";
For the java code you can use Pattern and Matcher: here is the basic idea:
Pattern p = Pattern.compile(pattern, Pattern.DOTALL|Pattern.MULTILINE);
Matcher m = p.matcher(text);
m.find();
for (int g = 1; g <= m.groupCount(); g++) {
// use your four groups here..
}

You can use following Java regex:
Pattern pattern = Pattern.compile
("::=(<[^>]+>)(<[^>]+>)\\|([^|]+)\\|(<[^>]+>)\\|(\\w+)$");

Java Regular expression to extract text from square bracket

How can I extract the text with in square brackets if it contains only dot and no other special character?
For example I want to extract "com.package.file" from
"ERR|appLogger|[Manager|Request]RequestFailed[com.package.file]uploading[com.file_upload]"

String s = "ERR|appLogger|[Manager|Request]RequestFailed[com.package.file]uploading[com.file]";
Pattern pattern = Pattern.compile("\\[([A-Za-z0-9.]+)\\]");
Matcher m = pattern.matcher(s);
if (m.find()) {
System.out.println(m.group(1)); // com.package.file
}

Something in the lines of:
^\w+\|\w+\|\[\w+\|\w+\]\w+\[([\w\.]+)\]\w+\[[\w\.\_]+\]$
Would allow you to capture that.
Pattern pattern = Pattern.compile("^\\w+\\|\\w+\\|\\[\\w+\\|\\w+\\]\\w+\\[([\\w\\.]+)\\]\\w+\\[[\\w\\.\\_]+\\]$", Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher("ERR|appLogger|[Manager|Request]RequestFailed[com.package.file]uploading[com.file_upload]");
System.out.println(matcher.group(1));