创建正则表达式匹配数组

在Java中，我试图返回所有正则表达式匹配到一个数组，但似乎你只能检查模式是否匹配某些东西(布尔)。

我如何使用正则表达式匹配形成一个数组的所有字符串匹配正则表达式在给定的字符串?

231800 次浏览
小开

这里有一个简单的例子:

Pattern pattern = Pattern.compile(regexPattern);
List<String> list = new ArrayList<String>();
Matcher m = pattern.matcher(input);
while (m.find()) {
list.add(m.group());
}

(如果您有更多的捕获组，您可以通过它们的索引作为group方法的参数引用它们。如果你需要一个数组，那么使用list.toArray())

小开
最佳答案

(4castle的答案比下面更好，如果你可以假设Java >= 9)

您需要创建一个匹配器并使用它来迭代地查找匹配项。

 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());
}

在此之后，allMatches包含匹配项，如果确实需要数组，可以使用allMatches.toArray(new String[0])获取数组。

你也可以使用MatchResult来编写辅助函数来循环匹配 因为Matcher.toMatchResult()返回当前组状态的快照

例如，您可以编写一个惰性迭代器来实现

for (MatchResult match : allMatches(pattern, input)) {
// Use match, and maybe break without doing the work to find all possible matches.
}

通过这样做:

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(); }
};
}
};
}

用这个,

for (MatchResult match : allMatches(Pattern.compile("[abc]"), "abracadabra")) {
System.out.println(match.group() + " at " + match.start());
}

收益率

a at 0
b at 1
a at 3
c at 4
a at 5
a at 7
b at 8
a at 10
小开

从官方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;
}

使用find并将结果group插入到数组/列表/任何对象中。

小开

Java使regex过于复杂，而且它不遵循perl风格。看一下MentaRegex，看看你如何在一行Java代码中完成这一点:

String[] matches = match("aa11bb22", "/(\\d+)/g" ); // => ["11", "22"]
小开 
        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;
小开

在Java 9中，你现在可以使用Matcher#results()来获得一个Stream<MatchResult>，你可以使用它来获得一个匹配的列表/数组。

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())

提交答案