Lớp Pattern (Class Pattern)

Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
boolean b = m.matches();

import java.util.regex.Pattern;

public final class Pattern
extends Object
implements Serializable

import java.util.regex.Pattern;

public class Example {
    public static void main(String[] args) {
        // Ví dụ 1: Ký tự cụ thể
        String regexChar = "x";
        String inputChar = "x";
        boolean matchesChar = Pattern.matches(regexChar, inputChar);
        System.out.println("Ký tự 'x' khớp với chuỗi 'x': " + matchesChar);

        // Ví dụ 2: Dấu gạch chéo ngược
        String regexBackslash = "\\\\";
        String inputBackslash = "\\";
        boolean matchesBackslash = Pattern.matches(regexBackslash, inputBackslash);
        System.out.println("Dấu gạch chéo ngược '\\\\' khớp với chuỗi '\\': " + matchesBackslash);

        // Ví dụ 3: Ký tự bát phân
        String regexOctal = "\\0" + "7";
        String inputOctal = "\u0007"; // Ký tự cảnh báo (bell)
        boolean matchesOctal = Pattern.matches(regexOctal, inputOctal);
        System.out.println("Ký tự bát phân '\0" + "7' khớp với ký tự cảnh báo (bell): " + matchesOctal);

        // Ví dụ 4: Ký tự thập lục phân
        String regexHex = "\\x41"; // 'A' trong hệ thập lục phân
        String inputHex = "A";
        boolean matchesHex = Pattern.matches(regexHex, inputHex);
        System.out.println("Ký tự thập lục phân '\\x41' khớp với chuỗi 'A': " + matchesHex);

        // Ví dụ 5: Ký tự Unicode
        String regexUnicode = "\\N{LATIN CAPITAL LETTER A}";
        String inputUnicode = "A"; // Đoạn mã Unicode cho 'A'
        boolean matchesUnicode = Pattern.matches(regexUnicode, inputUnicode);
        System.out.println("Ký tự Unicode '\\N{LATIN CAPITAL LETTER A}' khớp với chuỗi 'A': " + matchesUnicode);

        // Ví dụ 6: Ký tự tab
        String regexTab = "\\t";
        String inputTab = "\t";
        boolean matchesTab = Pattern.matches(regexTab, inputTab);
        System.out.println("Ký tự tab '\\t' khớp với ký tự tab: " + matchesTab);

        // Ví dụ 7: Ký tự xuống dòng
        String regexNewline = "\\n";
        String inputNewline = "\n";
        boolean matchesNewline = Pattern.matches(regexNewline, inputNewline);
        System.out.println("Ký tự xuống dòng '\\n' khớp với ký tự xuống dòng: " + matchesNewline);

        // Ví dụ 8: Ký tự trả về đầu dòng
        String regexCarriageReturn = "\\r";
        String inputCarriageReturn = "\r";
        boolean matchesCarriageReturn = Pattern.matches(regexCarriageReturn, inputCarriageReturn);
        System.out.println("Ký tự trả về đầu dòng '\\r' khớp với ký tự trả về đầu dòng: " + matchesCarriageReturn);

        // Ví dụ 9: Ký tự nạp biểu mẫu
        String regexFormFeed = "\\f";
        String inputFormFeed = "\f";
        boolean matchesFormFeed = Pattern.matches(regexFormFeed, inputFormFeed);
        System.out.println("Ký tự nạp biểu mẫu '\\f' khớp với ký tự nạp biểu mẫu: " + matchesFormFeed);

        // Ví dụ 10: Ký tự cảnh báo (chuông)
        String regexBell = "\\a";
        String inputBell = "\u0007";
        boolean matchesBell = Pattern.matches(regexBell, inputBell);
        System.out.println("Ký tự cảnh báo (chuông) '\\a' khớp với ký tự cảnh báo: " + matchesBell);

        // Ví dụ 11: Ký tự thoát
        String regexEscape = "\\e";
        String inputEscape = "\u001B"; // Ký tự thoát (escape)
        boolean matchesEscape = Pattern.matches(regexEscape, inputEscape);
        System.out.println("Ký tự thoát '\\e' khớp với ký tự thoát: " + matchesEscape);

        // Ví dụ 12: Ký tự điều khiển
        String regexControl = "\\cC";
        String inputControl = "\u0003"; // Ký tự điều khiển (Ctrl+C)
        boolean matchesControl = Pattern.matches(regexControl, inputControl);
        System.out.println("Ký tự điều khiển '\\cC' khớp với ký tự điều khiển (Ctrl+C): " + matchesControl);
    }
}

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

public class Example {
    public static void main(String[] args) {
        String input = "abc def ghijklmnopqrstuvwxyz ABC DEFGHIJKLMNOPQRSTUVWXYZ";

        // Mẫu và mô tả
        String[] patterns = {
            "[abc]",         // Các ký tự a, b, hoặc c
            "[^abc]",        // Bất kỳ ký tự nào ngoại trừ a, b, hoặc c
            "[a-zA-Z]",      // Từ a đến z hoặc từ A đến Z
            "[a-d[m-p]]",    // Từ a đến d, hoặc từ m đến p
            "[a-z&&[def]]",  // Các ký tự d, e, hoặc f
            "[a-z&&[^bc]]",  // Từ a đến z, trừ b và c
            "[a-z&&[^m-p]]"  // Từ a đến z, không bao gồm từ m đến p
        };

        // Thực hiện kiểm tra cho mỗi mẫu
        for (String patternStr : patterns) {
            // Biên dịch mẫu
            Pattern pattern = Pattern.compile(patternStr);
            Matcher matcher = pattern.matcher(input);
            
            System.out.println("Mẫu: " + patternStr);
            
            // Tìm và in ra các kết quả khớp
            while (matcher.find()) {
                System.out.println("Khớp: " + matcher.group());
            }
            System.out.println();
        }
    }
}

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

public class Example {
    public static void main(String[] args) {
        String input = "Hello 123, world! \t\n New Line \u2000 Horizontal space \u2028 Vertical space";

        // Mẫu và mô tả
        String[] patterns = {
            ".",        // Bất kỳ ký tự nào (có thể hoặc không khớp với ký tự kết thúc dòng)
            "\\d",      // Một chữ số: [0-9]
            "\\D",      // Một ký tự không phải chữ số: [^0-9]
            "\\h",      // Một ký tự khoảng trắng nằm ngang
            "\\H",      // Một ký tự khoảng trắng không nằm ngang
            "\\s",      // Một ký tự khoảng trắng: [ \t\n\x0B\f\\r]
            "\\S",      // Một ký tự không phải khoảng trắng: [^\s]
            "\\v",      // Một ký tự khoảng trắng nằm dọc
            "\\V",      // Một ký tự khoảng trắng không nằm dọc
            "\\w",      // Một ký tự từ: [a-zA-Z_0-9]
            "\\W"       // Một ký tự không phải từ: [^\w]
        };

        // Thực hiện kiểm tra cho mỗi mẫu
        for (String patternStr : patterns) {
            // Biên dịch mẫu
            Pattern pattern = Pattern.compile(patternStr);
            Matcher matcher = pattern.matcher(input);

            System.out.println("Mẫu: " + patternStr);

            // Tìm và in ra các kết quả khớp
            while (matcher.find()) {
                System.out.println("Khớp: " + matcher.group());
            }
            System.out.println();
        }
    }
}

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

public class Example {
    public static void main(String[] args) {
        String input = "Hello 123, World! \t\n Special characters: !@# $%^ &*()_+";

        // Mẫu và mô tả
        String[] patterns = {
            "\\p{Lower}",   // Ký tự chữ cái viết thường: [a-z]
            "\\p{Upper}",   // Ký tự chữ cái viết hoa: [A-Z]
            "\\p{ASCII}",   // Tất cả ký tự ASCII: [\x00-\x7F]
            "\\p{Alpha}",   // Ký tự chữ cái (cả viết thường và viết hoa): [\\p{Lower}\\p{Upper}]
            "\\p{Digit}",   // Ký tự số thập phân: [0-9]
            "\\p{Alnum}",   // Ký tự chữ cái hoặc số: [\\p{Alpha}\\p{Digit}]
            "\\p{Punct}",   // Ký tự dấu câu: Một trong các ký tự "!"#$%&'()*+,-./:;<=>?@[\\]^_{|}~"
            "\\p{Graph}",   // Ký tự hiển thị: [\\p{Alnum}\\p{Punct}]
            "\\p{Print}",   // Ký tự có thể in được: [\\p{Graph}\x20]
            "\\p{Blank}",   // Một ký tự khoảng trắng hoặc tab: [ \t]
            "\\p{Cntrl}",   // Ký tự điều khiển: [\x00-\x1F\x7F]
            "\\p{XDigit}",  // Ký tự số hexa: [0-9a-fA-F]
            "\\p{Space}"    // Ký tự khoảng trắng: [ \t\n\x0B\f\r]
        };

        // Thực hiện kiểm tra cho mỗi mẫu
        for (String patternStr : patterns) {
            // Biên dịch mẫu
            Pattern pattern = Pattern.compile(patternStr);
            Matcher matcher = pattern.matcher(input);

            System.out.println("Mẫu: " + patternStr);

            // Tìm và in ra các kết quả khớp
            while (matcher.find()) {
                System.out.println("Khớp: " + matcher.group());
            }
            System.out.println();
        }
    }
}

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

public class Example {
    public static void main(String[] args) {
        String input = "a A \t \u00AA \u212B";

        // Các mẫu kiểm tra lớp ký tự
        String[] patterns = {
            "\\p{javaLowerCase}",   // Ký tự chữ cái viết thường
            "\\p{javaUpperCase}",   // Ký tự chữ cái viết hoa
            "\\p{javaWhitespace}",   // Ký tự khoảng trắng
            "\\p{javaMirrored}"      // Ký tự được phản chiếu
        };

        // Thực hiện kiểm tra cho mỗi mẫu
        for (String patternStr : patterns) {
            // Biên dịch mẫu
            Pattern pattern = Pattern.compile(patternStr);
            Matcher matcher = pattern.matcher(input);

            System.out.println("Mẫu: " + patternStr);

            // Tìm và in ra các kết quả khớp
            while (matcher.find()) {
                System.out.println("Khớp: " + matcher.group() + " (Vị trí: " + matcher.start() + ")");
            }
            System.out.println();
        }
    }
}

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

public class Example {
    public static void main(String[] args) {
        String input = "a A € α";

        // Các mẫu kiểm tra lớp ký tự Unicode
        String[] patterns = {
            "\\p{IsLatin}",        // Ký tự thuộc tập lệnh Latin
            "\\p{InGreek}",        // Ký tự thuộc khối chữ Hy Lạp
            "\\p{Lu}",             // Chữ cái viết hoa
            "\\p{IsAlphabetic}",  // Ký tự chữ cái
            "\\p{Sc}",             // Ký hiệu tiền tệ
            "\\P{InGreek}",        // Bất kỳ ký tự nào ngoại trừ ký tự thuộc khối chữ Hy Lạp
            "[\\p{L}&&[^\\p{Lu}]]" // Bất kỳ ký tự chữ cái nào ngoại trừ chữ cái viết hoa
        };

        // Thực hiện kiểm tra cho mỗi mẫu
        for (String patternStr : patterns) {
            // Biên dịch mẫu
            Pattern pattern = Pattern.compile(patternStr);
            Matcher matcher = pattern.matcher(input);

            System.out.println("Mẫu: " + patternStr);

            // Tìm và in ra các kết quả khớp
            while (matcher.find()) {
                System.out.println("Khớp: " + matcher.group() + " (Vị trí: " + matcher.start() + ")");
            }
            System.out.println();
        }
    }
}

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

public class Example {
    public static void main(String[] args) {
        String input = "Hello world! This is a test. \nNew line.";

        // Các mẫu kiểm tra ranh giới
        String[] patterns = {
            "^",               // Đầu dòng
            "$",               // Cuối dòng
            "\\b",             // Ranh giới từ
            "\\b{g}",          // Ranh giới nhóm ký tự Unicode mở rộng
            "\\B",             // Không phải ranh giới từ
            "\\A",             // Đầu của dữ liệu đầu vào
            "\\G",             // Cuối của lần khớp trước đó
            "\\Z",             // Cuối của dữ liệu đầu vào trước dấu phân cách cuối cùng
            "\\z"              // Cuối của dữ liệu đầu vào
        };

        // Thực hiện kiểm tra cho mỗi mẫu
        for (String patternStr : patterns) {
            // Biên dịch mẫu
            Pattern pattern = Pattern.compile(patternStr, Pattern.MULTILINE);
            Matcher matcher = pattern.matcher(input);

            System.out.println("Mẫu: " + patternStr);

            // Tìm và in ra các kết quả khớp
            while (matcher.find()) {
                System.out.println("Khớp: " + matcher.group() + " (Vị trí: " + matcher.start() + ")");
            }
            System.out.println();
        }
    }
}

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

public class Example {
    public static void main(String[] args) {
        // Chuỗi đầu vào chứa các loại ngắt dòng khác nhau
        String input = "Line 1\u0085Line 2\u2028Line 3\u2029Line 4";

        // Biên dịch mẫu kiểm tra ngắt dòng
        Pattern pattern = Pattern.compile("\\R");
        Matcher matcher = pattern.matcher(input);

        // In ra các ngắt dòng và vị trí của chúng
        System.out.println("Các chuỗi ngắt dòng tìm thấy:");

        // Tìm và in ra các kết quả khớp
        while (matcher.find()) {
            System.out.println("Ngắt dòng tại vị trí: " + matcher.start() + " (Ký tự: " + matcher.group() + ")");
        }
    }
}

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

public class Example {
    public static void main(String[] args) {
        // Chuỗi đầu vào chứa các nhóm ký tự Unicode mở rộng
        String input = "a̐áâǎäåą";  // Các ký tự Unicode mở rộng bao gồm các dấu phụ

        // Biên dịch mẫu kiểm tra nhóm ký tự Unicode mở rộng
        Pattern pattern = Pattern.compile("\\X");
        Matcher matcher = pattern.matcher(input);

        // In ra các nhóm ký tự Unicode mở rộng và vị trí của chúng
        System.out.println("Các nhóm ký tự Unicode mở rộng tìm thấy:");

        // Tìm và in ra các kết quả khớp
        while (matcher.find()) {
            System.out.println("Nhóm ký tự tại vị trí: " + matcher.start() + " - " + matcher.end() + " (Ký tự: " + matcher.group() + ")");
        }
    }
}

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

public class Example {
    public static void main(String[] args) {
        // Chuỗi đầu vào để kiểm tra các ký tự định lượng tham lam
        String input = "aaabaaaabaaa";

        // Ví dụ với các ký tự định lượng tham lam khác nhau
        // X? - X xuất hiện một lần hoặc không có
        Pattern pattern1 = Pattern.compile("a?"); // X? với X là 'a'
        Matcher matcher1 = pattern1.matcher(input);
        System.out.println("Kết quả cho 'a?':");
        while (matcher1.find()) {
            System.out.println("Vị trí: " + matcher1.start() + " - " + matcher1.end() + " (Ký tự: " + matcher1.group() + ")");
        }

        // X* - X xuất hiện từ 0 lần trở lên
        Pattern pattern2 = Pattern.compile("a*"); // X* với X là 'a'
        Matcher matcher2 = pattern2.matcher(input);
        System.out.println("\nKết quả cho 'a*':");
        while (matcher2.find()) {
            System.out.println("Vị trí: " + matcher2.start() + " - " + matcher2.end() + " (Ký tự: " + matcher2.group() + ")");
        }

        // X+ - X xuất hiện ít nhất một lần
        Pattern pattern3 = Pattern.compile("a+"); // X+ với X là 'a'
        Matcher matcher3 = pattern3.matcher(input);
        System.out.println("\nKết quả cho 'a+':");
        while (matcher3.find()) {
            System.out.println("Vị trí: " + matcher3.start() + " - " + matcher3.end() + " (Ký tự: " + matcher3.group() + ")");
        }

        // X{n} - X xuất hiện chính xác n lần
        Pattern pattern4 = Pattern.compile("a{3}"); // X{3} với X là 'a'
        Matcher matcher4 = pattern4.matcher(input);
        System.out.println("\nKết quả cho 'a{3}':");
        while (matcher4.find()) {
            System.out.println("Vị trí: " + matcher4.start() + " - " + matcher4.end() + " (Ký tự: " + matcher4.group() + ")");
        }

        // X{n,} - X xuất hiện ít nhất n lần
        Pattern pattern5 = Pattern.compile("a{2,}"); // X{2,} với X là 'a'
        Matcher matcher5 = pattern5.matcher(input);
        System.out.println("\nKết quả cho 'a{2,}':");
        while (matcher5.find()) {
            System.out.println("Vị trí: " + matcher5.start() + " - " + matcher5.end() + " (Ký tự: " + matcher5.group() + ")");
        }

        // X{n,m} - X xuất hiện ít nhất n lần và không quá m lần
        Pattern pattern6 = Pattern.compile("a{2,4}"); // X{2,4} với X là 'a'
        Matcher matcher6 = pattern6.matcher(input);
        System.out.println("\nKết quả cho 'a{2,4}':");
        while (matcher6.find()) {
            System.out.println("Vị trí: " + matcher6.start() + " - " + matcher6.end() + " (Ký tự: " + matcher6.group() + ")");
        }
    }
}

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

public class Example {
    public static void main(String[] args) {
        // Chuỗi đầu vào để kiểm tra các ký tự định lượng ngần ngại
        String input = "aaabaaaabaaa";

        // Ví dụ với các ký tự định lượng ngần ngại khác nhau
        // X?? - X xuất hiện một lần hoặc không có
        Pattern pattern1 = Pattern.compile("a??"); // X?? với X là 'a'
        Matcher matcher1 = pattern1.matcher(input);
        System.out.println("Kết quả cho 'a??':");
        while (matcher1.find()) {
            System.out.println("Vị trí: " + matcher1.start() + " - " + matcher1.end() + " (Ký tự: " + matcher1.group() + ")");
        }

        // X*? - X xuất hiện từ 0 lần trở lên
        Pattern pattern2 = Pattern.compile("a*?"); // X*? với X là 'a'
        Matcher matcher2 = pattern2.matcher(input);
        System.out.println("\nKết quả cho 'a*?':");
        while (matcher2.find()) {
            System.out.println("Vị trí: " + matcher2.start() + " - " + matcher2.end() + " (Ký tự: " + matcher2.group() + ")");
        }

        // X+? - X xuất hiện ít nhất một lần
        Pattern pattern3 = Pattern.compile("a+?"); // X+? với X là 'a'
        Matcher matcher3 = pattern3.matcher(input);
        System.out.println("\nKết quả cho 'a+?':");
        while (matcher3.find()) {
            System.out.println("Vị trí: " + matcher3.start() + " - " + matcher3.end() + " (Ký tự: " + matcher3.group() + ")");
        }

        // X{n}? - X xuất hiện chính xác n lần
        Pattern pattern4 = Pattern.compile("a{3}?"); // X{3}? với X là 'a'
        Matcher matcher4 = pattern4.matcher(input);
        System.out.println("\nKết quả cho 'a{3}?':");
        while (matcher4.find()) {
            System.out.println("Vị trí: " + matcher4.start() + " - " + matcher4.end() + " (Ký tự: " + matcher4.group() + ")");
        }

        // X{n,}? - X xuất hiện ít nhất n lần
        Pattern pattern5 = Pattern.compile("a{2,}?"); // X{2,}? với X là 'a'
        Matcher matcher5 = pattern5.matcher(input);
        System.out.println("\nKết quả cho 'a{2,}?':");
        while (matcher5.find()) {
            System.out.println("Vị trí: " + matcher5.start() + " - " + matcher5.end() + " (Ký tự: " + matcher5.group() + ")");
        }

        // X{n,m}? - X xuất hiện ít nhất n lần và không quá m lần
        Pattern pattern6 = Pattern.compile("a{2,4}?"); // X{2,4}? với X là 'a'
        Matcher matcher6 = pattern6.matcher(input);
        System.out.println("\nKết quả cho 'a{2,4}?':");
        while (matcher6.find()) {
            System.out.println("Vị trí: " + matcher6.start() + " - " + matcher6.end() + " (Ký tự: " + matcher6.group() + ")");
        }
    }
}

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

public class Example {
    public static void main(String[] args) {
        // Chuỗi đầu vào để kiểm tra các ký tự định lượng chiếm hữu
        String input = "aaabaaaabaaa";

        // Ví dụ với các ký tự định lượng chiếm hữu khác nhau
        // X?+ - X xuất hiện một lần hoặc không có
        Pattern pattern1 = Pattern.compile("a?+"); // X?+ với X là 'a'
        Matcher matcher1 = pattern1.matcher(input);
        System.out.println("Kết quả cho 'a?+':");
        while (matcher1.find()) {
            System.out.println("Vị trí: " + matcher1.start() + " - " + matcher1.end() + " (Ký tự: " + matcher1.group() + ")");
        }

        // X*+ - X xuất hiện từ 0 lần trở lên
        Pattern pattern2 = Pattern.compile("a*+"); // X*+ với X là 'a'
        Matcher matcher2 = pattern2.matcher(input);
        System.out.println("\nKết quả cho 'a*+':");
        while (matcher2.find()) {
            System.out.println("Vị trí: " + matcher2.start() + " - " + matcher2.end() + " (Ký tự: " + matcher2.group() + ")");
        }

        // X++ - X xuất hiện ít nhất một lần
        Pattern pattern3 = Pattern.compile("a++"); // X++ với X là 'a'
        Matcher matcher3 = pattern3.matcher(input);
        System.out.println("\nKết quả cho 'a++':");
        while (matcher3.find()) {
            System.out.println("Vị trí: " + matcher3.start() + " - " + matcher3.end() + " (Ký tự: " + matcher3.group() + ")");
        }

        // X{n}+ - X xuất hiện chính xác n lần
        Pattern pattern4 = Pattern.compile("a{3}+"); // X{3}+ với X là 'a'
        Matcher matcher4 = pattern4.matcher(input);
        System.out.println("\nKết quả cho 'a{3}+':");
        while (matcher4.find()) {
            System.out.println("Vị trí: " + matcher4.start() + " - " + matcher4.end() + " (Ký tự: " + matcher4.group() + ")");
        }

        // X{n,}+ - X xuất hiện ít nhất n lần
        Pattern pattern5 = Pattern.compile("a{2,}+"); // X{2,}+ với X là 'a'
        Matcher matcher5 = pattern5.matcher(input);
        System.out.println("\nKết quả cho 'a{2,}+:");
        while (matcher5.find()) {
            System.out.println("Vị trí: " + matcher5.start() + " - " + matcher5.end() + " (Ký tự: " + matcher5.group() + ")");
        }

        // X{n,m}+ - X xuất hiện ít nhất n lần và không quá m lần
        Pattern pattern6 = Pattern.compile("a{2,4}+"); // X{2,4}+ với X là 'a'
        Matcher matcher6 = pattern6.matcher(input);
        System.out.println("\nKết quả cho 'a{2,4}+':");
        while (matcher6.find()) {
            System.out.println("Vị trí: " + matcher6.start() + " - " + matcher6.end() + " (Ký tự: " + matcher6.group() + ")");
        }
    }
}

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

public class Example {
    public static void main(String[] args) {
        // Chuỗi đầu vào để kiểm tra các toán tử logic
        String input = "apple banana cherry";

        // Ví dụ với các toán tử logic khác nhau
        // XY - Ký tự X theo sau ký tự Y (X followed by Y)
        Pattern pattern1 = Pattern.compile("apple banana"); // 'apple' theo sau 'banana'
        Matcher matcher1 = pattern1.matcher(input);
        System.out.println("Kết quả cho 'apple banana':");
        while (matcher1.find()) {
            System.out.println("Vị trí: " + matcher1.start() + " - " + matcher1.end() + " (Ký tự: " + matcher1.group() + ")");
        }

        // X|Y - Hoặc X hoặc Y (Either X or Y)
        Pattern pattern2 = Pattern.compile("apple|banana"); // 'apple' hoặc 'banana'
        Matcher matcher2 = pattern2.matcher(input);
        System.out.println("\nKết quả cho 'apple|banana':");
        while (matcher2.find()) {
            System.out.println("Vị trí: " + matcher2.start() + " - " + matcher2.end() + " (Ký tự: " + matcher2.group() + ")");
        }

        // (X) - Ký tự X, như là một nhóm bắt giữ (capturing group)
        Pattern pattern3 = Pattern.compile("(apple) (banana)"); // 'apple' và 'banana' là các nhóm bắt giữ
        Matcher matcher3 = pattern3.matcher(input);
        System.out.println("\nKết quả cho '(apple) (banana)':");
        while (matcher3.find()) {
            System.out.println("Vị trí: " + matcher3.start() + " - " + matcher3.end());
            System.out.println("Nhóm 1: " + matcher3.group(1)); // 'apple'
            System.out.println("Nhóm 2: " + matcher3.group(2)); // 'banana'
        }
    }
}

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

public class Example {
    public static void main(String[] args) {
        // Chuỗi đầu vào để kiểm tra các tham chiếu lại
        String input = "apple apple orange orange";

        // Ví dụ với nhóm bắt giữ thứ n
        // Mẫu tìm kiếm '(\w+) \\1' tìm một từ, theo sau bởi chính từ đó
        Pattern pattern1 = Pattern.compile("(\\w+) \\1");
        Matcher matcher1 = pattern1.matcher(input);
        System.out.println("Kết quả cho '(\\w+) \\1':");
        while (matcher1.find()) {
            System.out.println("Vị trí: " + matcher1.start() + " - " + matcher1.end());
            System.out.println("Nhóm 1: " + matcher1.group(1)); // Từ lặp lại
        }

        // Ví dụ với nhóm bắt giữ tên
        // Mẫu tìm kiếm '(?<fruit>\\w+) \\k<fruit>' tìm một từ, theo sau bởi chính từ đó với tên nhóm
        Pattern pattern2 = Pattern.compile("(?<fruit>\\w+) \\k<fruit>");
        Matcher matcher2 = pattern2.matcher(input);
        System.out.println("\nKết quả cho '(?<fruit>\\w+) \\k<fruit>':");
        while (matcher2.find()) {
            System.out.println("Vị trí: " + matcher2.start() + " - " + matcher2.end());
            System.out.println("Nhóm 'fruit': " + matcher2.group("fruit")); // Từ lặp lại với tên nhóm
        }
    }
}

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

public class Example {
    public static void main(String[] args) {
        // Chuỗi đầu vào để kiểm tra trích dẫn
        String input1 = "Hello, $pecial* characters here!";
        String input2 = "Special characters: $pecial*";

        // Ví dụ với trích dẫn ký tự đơn giản
        // Mẫu tìm kiếm 'Hello, \$pecial\* characters here!' với ký tự '$' và '*' được trích dẫn
        Pattern pattern1 = Pattern.compile("Hello, \\$pecial\\* characters here!");
        Matcher matcher1 = pattern1.matcher(input1);
        System.out.println("Kết quả cho 'Hello, \\$pecial\\* characters here!':");
        while (matcher1.find()) {
            System.out.println("Vị trí: " + matcher1.start() + " - " + matcher1.end());
            System.out.println("Khớp: " + matcher1.group());
        }

        // Ví dụ với trích dẫn toàn bộ chuỗi
        // Mẫu tìm kiếm 'Hello, \Q$pecial* characters\E here!' với ký tự '$' và '*' được trích dẫn
        Pattern pattern2 = Pattern.compile("Hello, \\Q$pecial* characters\\E here!");
        Matcher matcher2 = pattern2.matcher(input2);
        System.out.println("\nKết quả cho 'Hello, \\Q$pecial* characters\\E here!':");
        while (matcher2.find()) {
            System.out.println("Vị trí: " + matcher2.start() + " - " + matcher2.end());
            System.out.println("Khớp: " + matcher2.group());
        }
    }
}

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

public class Example {
    public static void main(String[] args) {
        String input = "The price is $100 and the discount is $10.";

        // Nhóm bắt giữ tên
        Pattern namedCapturePattern = Pattern.compile("The price is (?<price>\\$\\d+) and the discount is (?<discount>\\$\\d+).");
        Matcher namedCaptureMatcher = namedCapturePattern.matcher(input);
        System.out.println("Nhóm bắt giữ tên:");
        while (namedCaptureMatcher.find()) {
            System.out.println("Giá: " + namedCaptureMatcher.group("price"));
            System.out.println("Giảm giá: " + namedCaptureMatcher.group("discount"));
        }

        // Nhóm không bắt giữ
        Pattern nonCapturingGroupPattern = Pattern.compile("The price is (?:\\$\\d+) and the discount is (?:\\$\\d+).");
        Matcher nonCapturingGroupMatcher = nonCapturingGroupPattern.matcher(input);
        System.out.println("\nNhóm không bắt giữ:");
        while (nonCapturingGroupMatcher.find()) {
            System.out.println("Toàn bộ khớp: " + nonCapturingGroupMatcher.group());
        }

        // Kiểm tra dương không rộng
        Pattern positiveLookaheadPattern = Pattern.compile("(?=\\$\\d+)");
        Matcher positiveLookaheadMatcher = positiveLookaheadPattern.matcher(input);
        System.out.println("\nKiểm tra dương không rộng:");
        while (positiveLookaheadMatcher.find()) {
            System.out.println("Khớp tại vị trí: " + positiveLookaheadMatcher.start());
        }

        // Kiểm tra âm không rộng
        Pattern negativeLookaheadPattern = Pattern.compile("(?!\\d{3})\\d+");
        Matcher negativeLookaheadMatcher = negativeLookaheadPattern.matcher("Price is 1000");
        System.out.println("\nKiểm tra âm không rộng:");
        while (negativeLookaheadMatcher.find()) {
            System.out.println("Khớp: " + negativeLookaheadMatcher.group());
        }

        // Kiểm tra dương không rộng từ phía sau
        Pattern positiveLookbehindPattern = Pattern.compile("(?<=\\$)\\d+");
        Matcher positiveLookbehindMatcher = positiveLookbehindPattern.matcher(input);
        System.out.println("\nKiểm tra dương không rộng từ phía sau:");
        while (positiveLookbehindMatcher.find()) {
            System.out.println("Giá trị sau ký tự '$': " + positiveLookbehindMatcher.group());
        }

        // Kiểm tra âm không rộng từ phía sau
        Pattern negativeLookbehindPattern = Pattern.compile("(?<!\\$)\\d+");
        Matcher negativeLookbehindMatcher = negativeLookbehindPattern.matcher("Discount is 10, no $100 here.");
        System.out.println("\nKiểm tra âm không rộng từ phía sau:");
        while (negativeLookbehindMatcher.find()) {
            System.out.println("Giảm giá không theo sau ký tự '$': " + negativeLookbehindMatcher.group());
        }

        // Nhóm độc lập không bắt giữ
        Pattern independentGroupPattern = Pattern.compile("(?>\\d+)");
        Matcher independentGroupMatcher = independentGroupPattern.matcher("123 456");
        System.out.println("\nNhóm độc lập không bắt giữ:");
        while (independentGroupMatcher.find()) {
            System.out.println("Khớp: " + independentGroupMatcher.group());
        }
    }
}