java的switch case正则

在Java中，`switch case`结构主要用于处理有限的、已知的选项，而它本身并不直接支持正则表达式。然而，如果你想在Java中实现类似的功能，可以结合`String.matches()`方法与`switch`一起使用。

例如，你可以先判断输入字符串是否匹配某个模式，然后根据匹配的结果执行相应的`case`分支：

String input = ...; // 用户输入

// 定义一些正则表达式对应的case
switch (input.matches("^[A-Za-z]+$")) {
    case true:
        if (input.matches("^[a-z]*$")) { // 特定的小写字母模式
            System.out.println("小写字母");
        } else if (input.matches("^[A-Z]*$")) { // 特定的大写字母模式
            System.out.println("大写字母");
        }
        break;
    case false:
        System.out.println("输入不符合字母模式");
        break;
}

相关问题

java 货币正则表达式

在Java中处理货币金额通常涉及到验证输入的格式是否符合预期，比如美元、欧元或其他国家的货币。货币正则表达式可以帮助我们实现这个功能，它会匹配常见的货币格式，如金额加上货币符号。以下是一个简单的例子，用于匹配美元和欧元格式：

import java.util.regex.Pattern;

public class CurrencyRegexExample {
    private static final String US_DOLLAR_PATTERN = "^\\$[0-9]+(\\.?[0-9]{1,2})?";
    private static final String EURO_PATTERN = "^(€|EUR)[0-9]+(\\.?[0-9]{1,2})?";

    public static boolean isValid(String input, String currency) {
        Pattern pattern;
        switch (currency.toLowerCase()) {
            case "us":
                pattern = Pattern.compile(US_DOLLAR_PATTERN);
                break;
            case "eur":
                pattern = Pattern.compile(EURO_PATTERN);
                break;
            default:
                throw new IllegalArgumentException("Unsupported currency: " + currency);
        }
        return pattern.matcher(input).matches();
    }

    // 使用示例
    public static void main(String[] args) {
        System.out.println(isValid("$123.45", "us")); // 输出 true
        System.out.println(isValid("€56.78", "eur")); // 输出 true
    }
}

在这个例子中，`isValid`方法接受一个字符串和一种货币类型，根据货币类型创建相应的正则表达式模式并检查输入是否匹配。

自己使用Java手写实现简单正则表达式引擎

实现一个简单的正则表达式引擎，可以分为以下几个步骤：

1. 将正则表达式转换为后缀表达式
2. 使用后缀表达式匹配输入字符串

以下是一个简单的实现示例：

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class SimpleRegexEngine {

    private String regex;
    private List<String> postfix;

    public SimpleRegexEngine(String regex) {
        this.regex = regex;
        this.postfix = new ArrayList<>();
        convertToPostfix();
    }

    private void convertToPostfix() {
        Stack<Character> stack = new Stack<>();

        for (int i = 0; i < regex.length(); i++) {
            char c = regex.charAt(i);

            if (isOperator(c)) {
                while (!stack.isEmpty() && priority(stack.peek()) >= priority(c)) {
                    postfix.add(stack.pop().toString());
                }
                stack.push(c);
            } else if (c == '(') {
                stack.push(c);
            } else if (c == ')') {
                while (!stack.isEmpty() && stack.peek() != '(') {
                    postfix.add(stack.pop().toString());
                }
                stack.pop();
            } else {
                postfix.add(Character.toString(c));
            }
        }

        while (!stack.isEmpty()) {
            postfix.add(stack.pop().toString());
        }
    }

    private boolean isOperator(char c) {
        return c == '|' || c == '*' || c == '+';
    }

    private int priority(char c) {
        switch (c) {
            case '|':
                return 1;
            case '+':
            case '*':
                return 2;
            default:
                return 0;
        }
    }

    public boolean match(String input) {
        Stack<Boolean> stack = new Stack<>();

        for (String token : postfix) {
            char c = token.charAt(0);

            if (isOperator(c)) {
                boolean b1 = stack.pop();
                boolean b2 = c == '|' ? stack.pop() : true;
                stack.push(b1 || b2);
            } else if (c == '+') {
                stack.push(stack.pop() && matchChar(input, stack.size()));
            } else if (c == '*') {
                stack.push(true);
                while (matchChar(input, stack.size())) {
                    stack.pop();
                    stack.push(true);
                }
            } else {
                stack.push(matchChar(input, stack.size()));
            }
        }

        return stack.pop() && input.length() == stack.size();
    }

    private boolean matchChar(String input, int index) {
        if (index >= input.length()) {
            return false;
        }

        char c = input.charAt(index);
        return regex.charAt(index) == '.' || regex.charAt(index) == c;
    }

    public static void main(String[] args) {
        SimpleRegexEngine regexEngine = new SimpleRegexEngine("(a|b)*abb");
        System.out.println(regexEngine.match("aabb")); // true
        System.out.println(regexEngine.match("ababb")); // true
        System.out.println(regexEngine.match("abab")); // false
    }
}

在上面的代码中，我们首先将输入的正则表达式转换为后缀表达式，然后使用栈来匹配输入字符串。在匹配过程中，我们使用了三种操作符：`|` 表示或，`*` 表示重复零次或多次，`+` 表示重复一次或多次。我们还处理了`.` 表示匹配任意字符的情况。

该实现并不完整，可能无法支持某些正则表达式语法。但是这可以作为一个简单的起点，以帮助您更好地理解正则表达式引擎的工作原理。