Java 如何在另一个模式中再次使用声明的正则表达式模式？

我需要匹配嵌套数组的模式

我有一个

模式

，负责一个带数字的数组。我想知道如何将单个数组

模式

用于嵌套数组

这就是我想说的

[1 2 3-34]我已经涵盖了这个

Pattern digit = Pattern.compile("^[(((-?[1-9][0-9]*)\\s*)+)");

[1 2[-34 7]34]我需要一个使用先前定义的模式处理此问题的模式

---

如何回收[1 2[-34 7]34]样本的数字模式

您需要编写自己的解析器（）。我写过类似的东西。应用程序仅显示其是否为格式良好的数组

public class Main {

    private enum Type {
      LB, RB, NUMBER, END
    }

    private static class Token {
      Type type;
      String value;

      public Token(Type type, String value) {
          super();
          this.type = type;
          this.value = value;
      }

      @Override
      public String toString() {
          return "Token [type=" + type + ", value=" + value + "]";
      }

    }

    private static class Lexer {

      private int current;
      private String input;

      public Lexer(String input) {
          this.input = input;
      }

      private char getChar() {
          return input.charAt(current++);
      }

      private void unputChar() {
          current--;
      }

      private boolean hasNextChar() {
          return current < input.length();
      }

      Token next() {

          if (!hasNextChar()) {
            return new Token(Type.END, "");
          }

          char c = getChar();

          while (Character.isWhitespace(c)) {
            c = getChar();
          }

          if (c == '[') {
            return new Token(Type.LB, "[");
          }

          if (c == ']') {
            return new Token(Type.RB, "]");
          }

          int s = 1;
          if (c == '-') {
            s = -1;
          } else {
            unputChar();
          }

          StringBuilder buffer = new StringBuilder();
          while (hasNextChar()) {

            c = getChar();

            if (Character.isDigit(c)) {
              buffer.append(c);
            } else {
              unputChar();
              break;
            }

          }

          return new Token(Type.NUMBER, s > 0 ? buffer.toString() : "-" + buffer.toString());

      }
    }

    private static boolean match(Type type) {
      return type == currentToken.type;
    }

    private static void consume(Type type) {
      if (!match(type)) {
          throw new RuntimeException(String.format("Should be %s is %s", type.name(), currentToken.type.name()));
      }
      currentToken = lexer.next();
    }

    private static void array() {

      consume(Type.LB);

      while (true) {

          if (match(Type.NUMBER)) {
            consume(Type.NUMBER);
          } else if (match(Type.LB)) {
            array();
          } else {
            break;
          }

      }

      consume(Type.RB);
    }

    private static Lexer lexer;
    private static Token currentToken;

    private static void parse(String line) {

      lexer = new Lexer(line);
      currentToken = lexer.next();

      try {
          array();
          consume(Type.END);
          System.out.println(String.format("%s is a proper array", line));
      } catch (Exception e) {
          System.out.println(String.format("%s is not a proper array because %s", line, e.getMessage()));
      }

    }

    public static void main(String[] args) {

      parse("[1 2 [-34 7] 34]");
      parse("[1 2 -34 7] 34]");
      parse("[1 2 [-34] [7] 34]");
      parse("[1 2 [-34 [7] 34]");
      parse("[1 2 [-34 [7] 34]]");

    }

}

---

嗯，有一些正则表达式引擎可以进行递归匹配，不幸的是，Java的正则表达式引擎不是其中之一……您到底需要匹配什么？您的源代码是什么？例如，您是需要每个数组中的单个数字，还是只需要整个数组（或其他数组）。也许有一种不同的方法可以实现这个目标。理论计算机科学中正则表达式的一个基本定义属性是，它们不能匹配任意嵌套的成对括号（所谓的“泵引理”有一些名称下降：-），对于一个固定的嵌套深度，你可能可以派生出一些东西，但它会很难看。以防万一，你认为你可以推广到任意的深度：这是行不通的。你需要一个上下文无关的语法分析器来匹配你的嵌套数组。。。我需要检查字符串是否有效。有效字符串为1个或多个介于[]之间的整数和/或嵌套数组。您的“digit”正则表达式是无意义的，并在运行时引发异常。你能检查一下你的密码吗？

[1 2 [-34 7] 34] is a proper array
[1 2 -34 7] 34] is not a proper array because Should be END is NUMBER
[1 2 [-34] [7] 34] is a proper array
[1 2 [-34 [7] 34] is not a proper array because Should be RB is END
[1 2 [-34 [7] 34]] is a proper array