Java正则子串提取：能否用函数式风格或第三方库简化重复代码？

太懂这种重复写样板代码的痛苦了！Java原生正则的Matcher用法确实有点啰嗦，每次都要写Pattern编译、Matcher实例化、find/判断、取组这一套，很容易出错（比如忘了检查find返回值就调用group，或者组索引写错）。

刚好你想要的函数式风格写法，其实可以通过自己封装工具类轻松实现，另外Guava、Apache Commons以及Java 9+的原生API也能帮你简化代码，下面分情况说：

1. 自己封装工具类（Java 8+ 通用） #

这是最灵活的方式，完全按照你想要的API来实现，代码量很小：

import java.util.Optional;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public class RegexHelpers {

    // 提取指定组，返回Optional<String>（组不存在或匹配失败都返回空）
    public static Optional<String> matchedGroup(Pattern pattern, CharSequence input, int groupIndex) {
        Matcher matcher = pattern.matcher(input);
        return matcher.find() ? Optional.ofNullable(matcher.group(groupIndex)) : Optional.empty();
    }

    // 生成所有匹配结果的Stream<MatchResult>，支持流式操作
    public static Stream<MatchResult> findMatches(Pattern pattern, CharSequence input) {
        Matcher matcher = pattern.matcher(input);
        // 把Matcher的find迭代转换成Stream
        return StreamSupport.stream(
            ((Iterable<MatchResult>) () -> new java.util.Iterator<>() {
                @Override
                public boolean hasNext() {
                    return matcher.find();
                }

                @Override
                public MatchResult next() {
                    return matcher.toMatchResult();
                }
            }).spliterator(),
            false
        );
    }
}

使用示例：

// 单个组提取
Pattern emailPattern = Pattern.compile("([a-zA-Z0-9._%+-]+)@([a-zA-Z0-9.-]+)\\.[a-z]{2,}");
String input = "Reach me at alice@example.com or bob@test.net";

RegexHelpers.matchedGroup(emailPattern, input, 1)
    .map(username -> "Extracted username: " + username)
    .orElse("No valid email found")
    .let(System.out::println); // 输出 Extracted username: alice

// 遍历所有匹配结果
RegexHelpers.findMatches(emailPattern, input)
    .map(result -> String.format("User: %s, Domain: %s", result.group(1), result.group(2)))
    .forEach(System.out::println);
// 输出：
// User: alice, Domain: example
// User: bob, Domain: test

2. Java 9+ 原生API简化 #

如果你用的是Java 9及以上，Matcher新增了results()方法，直接返回Stream<MatchResult>，省去了自己转流的麻烦：

Pattern tagPattern = Pattern.compile("<(\\w+)>");
String html = "<div><p>Hello</p></div>";

// 直接获取所有匹配结果的流
tagPattern.matcher(html).results()
    .map(mr -> mr.group(1))
    .forEach(tag -> System.out.println("Found tag: " + tag));
// 输出：div, p, div

结合Optional提取单个组可以这样写：

Optional<String> firstTag = tagPattern.matcher(html).results()
    .map(mr -> mr.group(1))
    .findFirst();

3. Guava 辅助实现 #

Guava没有直接提供你想要的matchedGroup方法，但可以借助它的迭代器工具类和Optional（不过Java 8+自带Optional了）来简化：

import com.google.common.collect.Iterables;
import java.util.Optional;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

Pattern pattern = Pattern.compile("\\d+");
String input = "Values: 100, 200, 300";

// 把Matcher的匹配结果转成Iterable
Iterable<String> matches = Iterables.transform(
    () -> pattern.matcher(input).results().iterator(),
    MatchResult::group
);

// 提取第一个匹配项
Optional<String> firstMatch = Optional.ofNullable(Iterables.getFirst(matches, null));

4. Apache Commons Lang 辅助 #

Apache Commons Lang的RegExUtils主要做替换，StringUtils有一些正则相关的工具方法，但提取组还是需要结合Matcher，不过可以封装成类似的工具方法：

import org.apache.commons.lang3.StringUtils;
import java.util.Optional;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class CommonsRegexUtils {
    public static Optional<String> getMatchedGroup(Pattern pattern, String input, int group) {
        if (StringUtils.isBlank(input)) {
            return Optional.empty();
        }
        Matcher matcher = pattern.matcher(input);
        return matcher.find() ? Optional.ofNullable(matcher.group(group)) : Optional.empty();
    }
}

总的来说，自己封装工具类是最贴合你需求的方式，代码量小且完全自定义；如果用Java 9+，原生的results()已经能满足流处理的需求；Guava和Apache Commons更多是辅助简化，核心还是围绕Matcher来封装。

内容的提问来源于stack exchange，提问作者tkruse