如何优化级联正则匹配实现？避免嵌套IF且兼顾性能

针对你提到的嵌套IF写法冗余，同时又要避免提前编译所有正则模式的需求，以下是几种简洁优雅的实现方式：

1. 惰性编译的正则匹配循环 #

将正则表达式字符串与对应的处理逻辑绑定，通过循环逐个尝试匹配——只有当需要匹配当前正则时才编译Pattern，既避免嵌套IF，又实现按需编译。

示例代码：

import java.util.AbstractMap.SimpleEntry;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatcher {
    public static void main(String[] args) {
        String str = "whatever";
        
        // 存储正则表达式和对应的处理逻辑
        List<SimpleEntry<String, Runnable>> regexHandlers = List.of(
            new SimpleEntry<>("abc", () -> { /* 匹配abc时的处理逻辑 */ }),
            new SimpleEntry<>("def", () -> { /* 匹配def时的处理逻辑 */ }),
            new SimpleEntry<>("ghi", () -> { /* 匹配ghi时的处理逻辑 */ })
        );
        
        for (SimpleEntry<String, Runnable> handler : regexHandlers) {
            Pattern pat = Pattern.compile(handler.getKey());
            Matcher mat = pat.matcher(str);
            if (mat.matches()) {
                handler.getValue().run();
                break; // 匹配成功后终止循环
            }
        }
    }
}

这种方式的优势是逻辑清晰，扩展性强——新增正则规则只需在列表中添加条目即可，无需修改循环结构。

2. 责任链模式 #

将每个正则匹配封装成独立的处理器，形成链式调用，每个处理器只负责自己的匹配与处理，匹配失败则传递给下一个处理器。这种方式更符合面向对象设计，适合复杂的处理逻辑。

示例代码：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

interface RegexHandler {
    void handle(String str);
    void setNext(RegexHandler next);
}

class BaseRegexHandler implements RegexHandler {
    private RegexHandler next;
    private final String regex;
    private final Runnable action;

    public BaseRegexHandler(String regex, Runnable action) {
        this.regex = regex;
        this.action = action;
    }

    @Override
    public void handle(String str) {
        Pattern pat = Pattern.compile(regex);
        Matcher mat = pat.matcher(str);
        if (mat.matches()) {
            action.run();
        } else if (next != null) {
            next.handle(str);
        }
    }

    @Override
    public void setNext(RegexHandler next) {
        this.next = next;
    }
}

public class RegexChain {
    public static void main(String[] args) {
        String str = "whatever";
        
        // 构建责任链
        RegexHandler abcHandler = new BaseRegexHandler("abc", () -> { /* 处理逻辑 */ });
        RegexHandler defHandler = new BaseRegexHandler("def", () -> { /* 处理逻辑 */ });
        RegexHandler ghiHandler = new BaseRegexHandler("ghi", () -> { /* 处理逻辑 */ });
        
        abcHandler.setNext(defHandler);
        defHandler.setNext(ghiHandler);
        
        // 启动匹配
        abcHandler.handle(str);
    }
}

责任链模式适合需要频繁新增或调整匹配规则的场景，每个处理器的逻辑完全独立，便于维护。

3. Java 8+ Stream 简化写法 #

利用Stream的filter和findFirst方法，实现按需编译与匹配，代码更简洁：

import java.util.List;
import java.util.Optional;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexStream {
    public static void main(String[] args) {
        String str = "whatever";
        
        List<String> regexes = List.of("abc", "def", "ghi");
        
        Optional<String> matchedRegex = regexes.stream()
            .filter(regex -> {
                Pattern pat = Pattern.compile(regex);
                Matcher mat = pat.matcher(str);
                return mat.matches();
            })
            .findFirst();
        
        matchedRegex.ifPresent(regex -> {
            switch (regex) {
                case "abc": /* 处理逻辑 */ break;
                case "def": /* 处理逻辑 */ break;
                case "ghi": /* 处理逻辑 */ break;
            }
        });
    }
}

这种写法利用Stream的惰性求值特性，只有在遍历到需要的正则时才会编译和匹配，同时通过findFirst快速终止遍历，避免不必要的计算。

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