Các nhóm bắt giữ Regex Java

Tôi đang cố gắng để hiểu khối mã này. Trong cái đầu tiên, chúng ta đang tìm kiếm cái gì trong biểu thức?

Tôi hiểu rằng đó là bất kỳ ký tự nào (0 hoặc nhiều lần *) được theo sau bởi bất kỳ số nào trong khoảng từ 0 đến 9 (một hoặc nhiều lần +) theo sau bởi bất kỳ ký tự nào (0 hoặc nhiều lần *).

Khi điều này được thực hiện, kết quả là:

Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0

Ai đó có thể xin vui lòng thông qua điều này với tôi?

Lợi thế của việc sử dụng các nhóm Chụp là gì?

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

public class RegexTut3 {

    public static void main(String args[]) {
        String line = "This order was placed for QT3000! OK?"; 
        String pattern = "(.*)(\\d+)(.*)";

        // Create a Pattern object
        Pattern r = Pattern.compile(pattern);

        // Now create matcher object.
        Matcher m = r.matcher(line);

        if (m.find()) {
            System.out.println("Found value: " + m.group(0));
            System.out.println("Found value: " + m.group(1));
            System.out.println("Found value: " + m.group(2));
        } else {
            System.out.println("NO MATCH");
        }
    }

}

Vấn đề bạn gặp phải là với loại định lượng. Bạn đang sử dụng bộ định lượng tham lam trong nhóm đầu tiên của mình (chỉ số 1 - chỉ số 0 đại diện cho toàn bộ Pattern), có nghĩa là nó sẽ khớp nhiều nhất có thể (và vì nó là bất kỳ ký tự nào , nên nó sẽ khớp với nhiều ký tự như có để đáp ứng điều kiện cho các nhóm tiếp theo).

Nói tóm lại, nhóm 1 của bạn .*khớp với bất cứ thứ gì miễn là nhóm tiếp theo \\d+có thể khớp với thứ gì đó (trong trường hợp này là chữ số cuối cùng).

Theo nhóm thứ 3, nó sẽ khớp với bất cứ thứ gì sau chữ số cuối cùng.

Nếu bạn thay đổi nó thành một bộ định lượng miễn cưỡng trong nhóm 1 của bạn, bạn sẽ nhận được kết quả mà tôi cho rằng bạn đang mong đợi, đó là phần 3000 .

Lưu ý các dấu hỏi trong nhóm 1.

String line = "This order was placed for QT3000! OK?";
Pattern pattern = Pattern.compile("(.*?)(\\d+)(.*)");
Matcher matcher = pattern.matcher(line);
while (matcher.find()) {
    System.out.println("group 1: " + matcher.group(1));
    System.out.println("group 2: " + matcher.group(2));
    System.out.println("group 3: " + matcher.group(3));
}

Đầu ra:

group 1: This order was placed for QT
group 2: 3000
group 3: ! OK?

Thêm thông tin về Java Pattern tại đây .

Cuối cùng, các nhóm chụp được phân định bằng dấu ngoặc tròn và cung cấp một cách rất hữu ích để sử dụng tham chiếu ngược (trong số những thứ khác), khi bạn Patternkhớp với đầu vào.

Trong Java 6, các nhóm chỉ có thể được tham chiếu theo thứ tự của chúng (hãy cẩn thận với các nhóm lồng nhau và sự tinh tế của việc đặt hàng).

Trong Java 7, điều đó dễ dàng hơn nhiều, vì bạn có thể sử dụng các nhóm được đặt tên.

Điều này là hoàn toàn OK.

1. Nhóm đầu tiên ( m.group(0)) luôn chụp toàn bộ khu vực được bao phủ bởi biểu thức chính quy của bạn . Trong trường hợp này, đó là toàn bộ chuỗi.
2. Các biểu thức thông thường là tham lam theo mặc định, có nghĩa là nhóm đầu tiên nắm bắt càng nhiều càng tốt mà không vi phạm regex. (.*)(\\d+)( Phần đầu tiên trong regex của bạn) bao gồm ...QT300int nhóm đầu tiên và0 thứ hai.
3. Bạn có thể nhanh chóng khắc phục điều này bằng cách làm cho nhóm đầu tiên không tham lam: thay đổi (.*)thành (.*?).

Để biết thêm thông tin về tham lam so với lười biếng, hãy kiểm tra trang web này.

Từ tài liệu:

Capturing groups</a> are indexed from left
 * to right, starting at one.  Group zero denotes the entire pattern, so
 * the expression m.group(0) is equivalent to m.group().

Vì vậy, chụp nhóm 0 gửi toàn bộ dòng.

Sự am hiểu của bạn đa đung đăn. Tuy nhiên, nếu chúng ta đi qua:

• (.*) sẽ nuốt cả chuỗi;
• nó sẽ cần phải trả lại các ký tự sao cho phù hợp (\\d+)(đó là lý do tại sao0 bị bắt và không 3000);
• cuối cùng (.*) sau đó sẽ nắm bắt phần còn lại.

Tuy nhiên, tôi không chắc ý định ban đầu của tác giả là gì.