Matcher.find()

在Java的Regex包中，Matcher.find()是一個非常有用的方法，它可以在字元串中搜索一個正則匹配，從而創建一個Match對象，這個Match對象包含了所匹配的字元的位置和值。

一、搜索匹配

Matcher.find()是一個非常有用的工具，它可以幫助你在一個字元串中搜索你想要的匹配。例如，你有以下的字元串，你想要在其中搜索一個名為”hello”的單詞：

String text = "hello world! This is a test.";
Pattern pattern = Pattern.compile("\\bhello\\b");
Matcher matcher = pattern.matcher(text);

在這個例子中，我們先定義了一個字元串，然後正則表達式中用\\b來匹配單詞的邊界。最後，我們創建了一個Matcher對象，用於搜索匹配。

現在，我們可以使用Matcher.find()來搜索匹配並輸出。代碼如下：

while (matcher.find()) {
    System.out.println("Match found at index " + matcher.start() + " to " + matcher.end());
    System.out.println("Match: " + matcher.group());
}

這裡使用了一個while循環，因為你可以在同一個字元串中找到多個匹配。輸出結果如下：

Match found at index 0 to 5
Match: hello

在這個例子中，我們只找到了一個匹配。matcher.start()返回匹配的起始位置，matcher.end()返回匹配的結束位置。同時，matcher.group()返回實際匹配的字元串。

二、正則表達式組

可以使用括弧分組對Matcher.find()方法進行更高級的利用，例如將所有匹配的單詞提取出來放到一個數組中。例如：

String text = "hello world, how are you?";
Pattern pattern = Pattern.compile("(\\w+)");
Matcher matcher = pattern.matcher(text);
List matches = new ArrayList();

while (matcher.find()) {
    matches.add(matcher.group(1));
}

System.out.println(matches);

這裡，我們的正則表達式是”(\\w+)”。括弧中的”\\w+”將匹配任何單詞字元，而括弧表明我們要將整個匹配作為一組。我們在循環中多次使用了Matcher.find()來找到多個匹配，並將每個匹配的字元串添加到數組中。

三、區分大小寫

默認情況下，Matcher.find()是區分大小寫的。這意味著如果你搜索”hello”，它將只匹配”hello”，而不是”Hello”或”HELLO”。如果你想要執行大小寫不敏感的匹配，你需要在正則表達式模式中添加”(?i)”標誌。例如：

String text = "HELLO world! This is a test.";
Pattern pattern = Pattern.compile("(?i)\\bhello\\b");
Matcher matcher = pattern.matcher(text);

while (matcher.find()) {
    System.out.println("Match found at index " + matcher.start() + " to " + matcher.end());
    System.out.println("Match: " + matcher.group());
}

這裡，我們在正則表達式模式中添加了”(?i)”標誌，這表示執行不區分大小寫的匹配。輸出結果如下：

Match found at index 0 to 5
Match: HELLO

四、多行模式

有時候，你可能需要在整個文本字元串中搜索匹配，而不只是在單行中搜索匹配。默認情況下，Matcher.find()只搜索一行。

你可以使用”(?m)”標誌來啟用多行模式。多行模式允許在整個文本字元串中進行搜索匹配。例如：

String text = "hello world\nhow are you\ntoday?";
Pattern pattern = Pattern.compile("^h", Pattern.MULTILINE);
Matcher matcher = pattern.matcher(text);

while (matcher.find()) {
    System.out.println("Match found at index " + matcher.start() + " to " + matcher.end());
    System.out.println("Match: " + matcher.group());
}

這裡，我們的正則表達式是”^h”，這將匹配以字母”h”開頭的任何行。我們也傳遞了Pattern.MULTILINE參數來啟用多行模式。輸出結果如下：

Match found at index 6 to 7
Match: w
Match found at index 18 to 19
Match: t

五、貪婪模式和懶惰模式

Matcher.find()默認是貪婪模式的。這意味著它會儘可能多地匹配字元。例如，如果你要匹配字元串”aaaaaaaaaaaaaab”中的”a+”，Matcher.find()將匹配整個字元串：

String text = "aaaaaaaaaaaaaab";
Pattern pattern = Pattern.compile("a+");
Matcher matcher = pattern.matcher(text);

while (matcher.find()) {
    System.out.println("Match found at index " + matcher.start() + " to " + matcher.end());
    System.out.println("Match: " + matcher.group());
}

輸出結果如下：

Match found at index 0 to 13
Match: aaaaaaaaaaaa
Match found at index 13 to 14
Match: b

你可以使用”?在正則表達式模式中表示懶惰模式，這意味著它會儘可能少地匹配字元。例如：

String text = "aaaaaaaaaaaaaab";
Pattern pattern = Pattern.compile("a+?");
Matcher matcher = pattern.matcher(text);

while (matcher.find()) {
    System.out.println("Match found at index " + matcher.start() + " to " + matcher.end());
    System.out.println("Match: " + matcher.group());
}

輸出結果如下：

Match found at index 0 to 0
Match: a
Match found at index 1 to 1
Match: a
Match found at index 2 to 2
Match: a
Match found at index 3 to 3
Match: a
Match found at index 4 to 4
Match: a
Match found at index 5 to 5
Match: a
Match found at index 6 to 6
Match: a
Match found at index 7 to 7
Match: a
Match found at index 8 to 8
Match: a
Match found at index 9 to 9
Match: a
Match found at index 10 to 10
Match: a
Match found at index 11 to 11
Match: a
Match found at index 12 to 12
Match: a
Match found at index 13 to 13
Match: a
Match found at index 13 to 14
Match: b

總結

Matcher.find()是一個非常有用的工具，可以幫助你搜索和提取字元串中的模式。你可以在不同的情況下使用括弧分組、大小寫敏感和多行模式來控制匹配。而貪婪和懶惰模式則允許你更好地控制匹配的細節。

代碼示例：

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

public class MatcherExample {
    public static void main(String[] args) {
        // Search for a single word
        String text = "hello world! This is a test.";
        Pattern pattern = Pattern.compile("\\bhello\\b");
        Matcher matcher = pattern.matcher(text);

        System.out.println("Searching for: " + pattern.pattern());

        while (matcher.find()) {
            System.out.println("Match found at index " + matcher.start() + " to " + matcher.end());
            System.out.println("Match: " + matcher.group());
        }

        // Using groups
        String text2 = "hello world, how are you?";
        Pattern pattern2 = Pattern.compile("(\\w+)");
        Matcher matcher2 = pattern2.matcher(text2);
        List matches = new ArrayList();

        System.out.println("\nSearching for: " + pattern2.pattern());

        while (matcher2.find()) {
            matches.add(matcher2.group(1));
        }

        System.out.println("Matches: " + matches);

        // Case insensitive search
        String text3 = "HELLO world! This is a test.";
        Pattern pattern3 = Pattern.compile("(?i)\\bhello\\b");
        Matcher matcher3 = pattern3.matcher(text3);

        System.out.println("\nSearching for: " + pattern3.pattern());

        while (matcher3.find()) {
            System.out.println("Match found at index " + matcher3.start() + " to " + matcher3.end());
            System.out.println("Match: " + matcher3.group());
        }

        // Multi-line search
        String text4 = "hello world\nhow are you\ntoday?";
        Pattern pattern4 = Pattern.compile("^h", Pattern.MULTILINE);
        Matcher matcher4 = pattern4.matcher(text4);

        System.out.println("\nSearching for: " + pattern4.pattern());

        while (matcher4.find()) {
            System.out.println("Match found at index " + matcher4.start() + " to " + matcher4.end());
            System.out.println("Match: " + matcher4.group());
        }

        // Greedy and lazy matching
        String text5 = "aaaaaaaaaaaaaab";

        // Greedy match
        Pattern pattern5a = Pattern.compile("a+");
        Matcher matcher5a = pattern5a.matcher(text5);

        System.out.println("\nSearching for: " + pattern5a.pattern());

        while (matcher5a.find()) {
            System.out.println("Match found at index " + matcher5a.start() + " to " + matcher5a.end());
            System.out.println("Match: " + matcher5a.group());
        }

        // Lazy match
        Pattern pattern5b = Pattern.compile("a+?");
        Matcher matcher5b = pattern5b.matcher(text5);

        System.out.println("\nSearching for: " + pattern5b.pattern());

        while (matcher5b.find()) {
            System.out.println("Match found at index " + matcher5b.start() + " to " + matcher5b.end());
            System.out.println("Match: " + matcher5b.group());
        }
    }
}