java实现匹配字符串（附完整源码）

以下是一个简单的 Java 实现，用于匹配一个字符串是否包含另一个字符串：

public class StringMatcher {

    // 判断 text 字符串是否包含 pattern 字符串
    public static boolean isMatch(String text, String pattern) {
        int n = text.length();
        int m = pattern.length();

        // 如果 pattern 为空，则 text 必须也为空才匹配
        if (m == 0) {
            return (n == 0);
        }

        // 初始化 dp 数组
        boolean[][] dp = new boolean[n + 1][m + 1];
        dp[0][0] = true;

        // 处理 pattern 的第一行
        for (int j = 1; j <= m; j++) {
            if (pattern.charAt(j - 1) == '*') {
                dp[0][j] = dp[0][j - 2];
            }
        }

        // 处理剩余的行和列
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                char c = text.charAt(i - 1);
                char p = pattern.charAt(j - 1);

                // 如果当前字符匹配，则 dp[i][j] 取决于 dp[i-1][j-1]
                if (c == p || p == '.') {
                    dp[i][j] = dp[i - 1][j - 1];
                }

                // 如果当前字符是 '*'，则有两种情况：
                // 1. '*' 匹配了 0 个前一个字符，此时 dp[i][j] 取决于 dp[i][j-2]
                // 2. '*' 匹配了 1 个或多个前一个字符，此时 dp[i][j] 取决于 dp[i-1][j]
                else if (p == '*') {
                    if (dp[i][j - 2]) {
                        dp[i][j] = true;
                    } else if (c == pattern.charAt(j - 2) || pattern.charAt(j - 2) == '.') {
                        dp[i][j] = dp[i - 1][j];
                    }
                }

                // 如果当前字符不匹配，则 dp[i][j] 为 false
                else {
                    dp[i][j] = false;
                }
            }
        }

        return dp[n][m];
    }

    public static void main(String[] args) {
        String text = "hello world";
        String pattern = "ll";

        boolean isMatched = isMatch(text, pattern);

        if (isMatched) {
            System.out.println("Text contains pattern.");
        } else {
            System.out.println("Text does not contain pattern.");
        }
    }
}

在这个实现中，我们使用了动态规划的思想。具体来说，我们定义一个二维的 dp 数组，其中 dp[i][j] 表示 text 的前 i 个字符是否包含 pattern 的前 j 个字符。然后，我们根据 pattern 的第一个字符是普通字符、'.' 还是 '*'，以及 text 和 pattern 的前一个字符是否匹配，来更新 dp[i][j] 的值。

最后，我们返回 dp[n][m]，其中 n 和 m 分别是 text 和 pattern 的长度，表示 text 是否包含 pattern。