Tạo mảng phù hợp với regex

Trong Java, tôi đang cố gắng trả lại tất cả các kết quả regex cho một mảng nhưng có vẻ như bạn chỉ có thể kiểm tra xem mẫu đó có khớp với thứ gì đó hay không (boolean).

Làm cách nào tôi có thể sử dụng kết hợp biểu thức chính quy để tạo thành một mảng gồm tất cả các chuỗi khớp với biểu thức regex trong một chuỗi đã cho?

( Câu trả lời của 4 Castle tốt hơn câu trả lời dưới đây nếu bạn có thể giả sử Java> = 9)

Bạn cần tạo một công cụ đối sánh và sử dụng công cụ đó để lặp lại tìm kết quả khớp.

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

 ...

 List<String> allMatches = new ArrayList<String>();
 Matcher m = Pattern.compile("your regular expression here")
     .matcher(yourStringHere);
 while (m.find()) {
   allMatches.add(m.group());
 }

Sau này, allMatcheschứa các kết quả khớp và bạn có thể sử dụng allMatches.toArray(new String[0])để lấy một mảng nếu bạn thực sự cần.

Bạn cũng có thể sử dụng MatchResultđể viết các hàm trợ giúp để lặp lại các kết quả trùng khớp vì Matcher.toMatchResult()trả về một ảnh chụp nhanh về trạng thái nhóm hiện tại.

Ví dụ, bạn có thể viết một trình vòng lặp lười biếng để cho phép bạn làm

for (MatchResult match : allMatches(pattern, input)) {
  // Use match, and maybe break without doing the work to find all possible matches.
}

bằng cách làm một cái gì đó như thế này:

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

Với cái này,

for (MatchResult match : allMatches(Pattern.compile("[abc]"), "abracadabra")) {
  System.out.println(match.group() + " at " + match.start());
}

sản lượng

a at 0
b at 1
a at 3
c at 4
a at 5
a at 7
b at 8
a at 10

Trong Java 9, bây giờ bạn có thể sử dụng Matcher#results()để lấy cái Stream<MatchResult>mà bạn có thể sử dụng để lấy danh sách / mảng khớp.

import java.util.regex.Pattern;
import java.util.regex.MatchResult;

String[] matches = Pattern.compile("your regex here")
                          .matcher("string to search from here")
                          .results()
                          .map(MatchResult::group)
                          .toArray(String[]::new);
                    // or .collect(Collectors.toList())

Java làm cho regex quá phức tạp và nó không theo kiểu perl. Hãy xem MentaRegex để xem làm thế nào bạn có thể thực hiện điều đó trong một dòng mã Java duy nhất:

String[] matches = match("aa11bb22", "/(\\d+)/g" ); // => ["11", "22"]

Đây là một ví dụ đơn giản:

Pattern pattern = Pattern.compile(regexPattern);
List<String> list = new ArrayList<String>();
Matcher m = pattern.matcher(input);
while (m.find()) {
    list.add(m.group());
}

(nếu bạn có nhiều nhóm bắt hơn, bạn có thể gọi chúng theo chỉ mục của chúng như là một đối số của phương thức nhóm. Nếu bạn cần một mảng, sau đó sử dụng list.toArray())

Từ các đường chính Java chính thức :

        Pattern pattern = 
        Pattern.compile(console.readLine("%nEnter your regex: "));

        Matcher matcher = 
        pattern.matcher(console.readLine("Enter input string to search: "));

        boolean found = false;
        while (matcher.find()) {
            console.format("I found the text \"%s\" starting at " +
               "index %d and ending at index %d.%n",
                matcher.group(), matcher.start(), matcher.end());
            found = true;
        }

Sử dụng findvà chèn kết quả grouptại mảng / Danh sách / bất cứ điều gì.

        Set<String> keyList = new HashSet();
        Pattern regex = Pattern.compile("#\\{(.*?)\\}");
        Matcher matcher = regex.matcher("Content goes here");
        while(matcher.find()) {
            keyList.add(matcher.group(1)); 
        }
        return keyList;