In Java, I am trying to return all regex matches to an array but it seems that you can only check whether the pattern matches something or not (boolean).
How can I use a regex match to form an array of all string matching a regex expression in a given string?
(4castle's answer is better than the below if you can assume Java >= 9)
You need to create a matcher and use that to iteratively find matches.
import java.util.regex.Matcher; import java.util.regex.Pattern; ... List<String> allMatches = new ArrayList<String>(); Matcher m = Pattern.compile("your regular expression here") .matcher(yourStringHere); while (m.find()) { allMatches.add(m.group()); } After this, allMatches contains the matches, and you can use allMatches.toArray(new String[0]) to get an array if you really need one.
You can also use MatchResult to write helper functions to loop over matches since Matcher.toMatchResult() returns a snapshot of the current group state.
For example you can write a lazy iterator to let you do
for (MatchResult match : allMatches(pattern, input)) { // Use match, and maybe break without doing the work to find all possible matches. } by doing something like this:
public static Iterable<MatchResult> allMatches( final Pattern p, final CharSequence input) { return new Iterable<MatchResult>() { public Iterator<MatchResult> iterator() { return new Iterator<MatchResult>() { // Use a matcher internally. final Matcher matcher = p.matcher(input); // Keep a match around that supports any interleaving of hasNext/next calls. MatchResult pending; public boolean hasNext() { // Lazily fill pending, and avoid calling find() multiple times if the // clients call hasNext() repeatedly before sampling via next(). if (pending == null && matcher.find()) { pending = matcher.toMatchResult(); } return pending != null; } public MatchResult next() { // Fill pending if necessary (as when clients call next() without // checking hasNext()), throw if not possible. if (!hasNext()) { throw new NoSuchElementException(); } // Consume pending so next call to hasNext() does a find(). MatchResult next = pending; pending = null; return next; } /** Required to satisfy the interface, but unsupported. */ public void remove() { throw new UnsupportedOperationException(); } }; } }; } With this,
for (MatchResult match : allMatches(Pattern.compile("[abc]"), "abracadabra")) { System.out.println(match.group() + " at " + match.start()); } yields
a at 0 b at 1 a at 3 c at 4 a at 5 a at 7 b at 8 a at 10
ArrayList and LinkedList, the results may be surprising.
allMatches vs yourStringHere.length()), you can probably precompute a good size for allMatches. In my experience, the cost of LinkedList memory and iteration efficiency-wise is not usually worth it so LinkedList is not my default posture. But when optimizing a hot-spot, it is definitely worth swapping list implementations to see if you get an improvement.
Matcher#results to get a Stream which you can use to generate an array (see my answer).In Java 9, you can now use Matcher#results() to get a Stream<MatchResult> which you can use to get a list/array of matches.
import java.util.regex.Pattern; import java.util.regex.MatchResult; String[] matches = Pattern.compile("your regex here") .matcher("string to search from here") .results() .map(MatchResult::group) .toArray(String[]::new); // or .collect(Collectors.toList()) 
Java makes regex too complicated and it does not follow the perl-style. Take a look at MentaRegex to see how you can accomplish that in a single line of Java code:
String[] matches = match("aa11bb22", "/(\\d+)/g" ); // => ["11", "22"] 
Here's a simple example:
Pattern pattern = Pattern.compile(regexPattern); List<String> list = new ArrayList<String>(); Matcher m = pattern.matcher(input); while (m.find()) { list.add(m.group()); } (if you have more capturing groups, you can refer to them by their index as an argument of the group method. If you need an array, then use list.toArray())
Pattern.matches() is a static method, you shouldn't call it on a Pattern instance. Pattern.matches(regex, input) is simply a shorthand for Pattern.compile(regex).matcher(input).matches().From the Official Regex Java Trails:
Pattern pattern = Pattern.compile(console.readLine("%nEnter your regex: ")); Matcher matcher = pattern.matcher(console.readLine("Enter input string to search: ")); boolean found = false; while (matcher.find()) { console.format("I found the text \"%s\" starting at " + "index %d and ending at index %d.%n", matcher.group(), matcher.start(), matcher.end()); found = true; } Use find and insert the resulting group at your array / List / whatever.
Set<String> keyList = new HashSet(); Pattern regex = Pattern.compile("#\\{(.*?)\\}"); Matcher matcher = regex.matcher("Content goes here"); while(matcher.find()) { keyList.add(matcher.group(1)); } return keyList; 
Matcher.find() multiple time:Interestingly Java Matcher class have matcher.find(int start) method - Method Overloading
public class Main { public static void main(String[] args) { List<String> familyHiearchy = Arrays.asList( "A", "Level_00/Level_01_first", "Level_00/Level_01_second", "Level_00/Level_01_first/Level_02_first" ); for (String ele : familyHiearchy) { Matcher matcher_child = ((Pattern) Pattern.compile("\\w+$", Pattern.CASE_INSENSITIVE)).matcher(ele); Matcher matcher_parent = ((Pattern) Pattern.compile("\\w+(?=/\\w+$)", Pattern.CASE_INSENSITIVE)).matcher(ele); System.out.println("-----------------"); if(matcher_child.find(0) && matcher_parent.find(0)) { System.out.println("Both Child and Parent are available"); } else if(matcher_child.find(0) && !matcher_parent.find(0)) { System.out.println("Child available, but parent not available"); } if (matcher_child.find(0)) { String childName = matcher_child.group(); System.out.println("Name : " + childName); } if (matcher_parent.find(0)) { String parentName = matcher_parent.group(); System.out.println("Parent Name : " + parentName); } } } } 