正则表达式，用于在每个字符处拆分，但将数字保持在一起

Question

我正在寻找一个正则表达式，它可以按如下方式拆分字符串：

String input = "x^(24-3x)";
String[] signs = input.split("regex here");
for (int i = 0; i < signs.length; i++) { System.out.println(sings[i]); }

其结果是：

"x", "^", "(", "24", "-", "3", "x", ")"

字符串在每个字符处被拆分。但是，如果数字相邻，则它们应保持在一个字符串中。

Answer 1

您还可以使用模式和匹配器拆分成令牌，这是相当可读性

String regex="\\d+|[a-z]+|[\\-()\\^]";
String  str="x^(24-3x)";

如果使用str=“xxx^（24-3xyz）”也很容易；

要获得所有代币，有点棘手：

我用这个：

提供：创建正则表达式匹配数组

for (MatchResult match : allMatches(Pattern.compile(regex), str)) {
  System.out.println(match.group() + " at " + match.start());
}

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

Answer 2

您可以使用这个基于lookaround的正则表达式：

String[] signs = input.split("(?<!^)(?=\\D)|(?<=\\D)");

正则表达式演示

RegEx分手

(?<!^)(?=\\D)  # assert if next char is non-digit and we're not at start
|              # regex alternation
(?<=\\D)       # assert if previous character is a non-digit