Java字符串匹配案例怎么开发

本文目录导读：

1. 基础字符串匹配方法
2. 正则表达式匹配
3. KMP算法实现
4. 实用字符串匹配工具类
5. 性能测试与比较
6. 最佳实践建议

我来详细介绍Java字符串匹配的几种常见开发案例：

基础字符串匹配方法

public class StringMatchExample {
    public static void main(String[] args) {
        String text = "Hello World, Welcome to Java Programming";
        String pattern = "Java";
        // 1. contains() - 是否包含
        System.out.println("Contains 'Java': " + text.contains("Java"));
        // 2. indexOf() - 查找首次出现位置
        int index = text.indexOf("World");
        System.out.println("Index of 'World': " + index);
        // 3. lastIndexOf() - 查找最后出现位置
        int lastIndex = text.lastIndexOf("o");
        System.out.println("Last index of 'o': " + lastIndex);
        // 4. startsWith() / endsWith()
        System.out.println("Starts with 'Hello': " + text.startsWith("Hello"));
        System.out.println("Ends with 'Programming': " + text.endsWith("Programming"));
        // 5. 使用matches()进行正则匹配
        boolean isMatch = text.matches(".*Java.*");
        System.out.println("Matches pattern '.*Java.*': " + isMatch);
    }
}

正则表达式匹配

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatchExample {
    public static void main(String[] args) {
        String text = "我的邮箱是user@example.com，电话是138-1234-5678";
        // 1. 匹配邮箱
        String emailPattern = "\\w+@\\w+\\.\\w+";
        Pattern pattern = Pattern.compile(emailPattern);
        Matcher matcher = pattern.matcher(text);
        if (matcher.find()) {
            System.out.println("找到邮箱: " + matcher.group());
        }
        // 2. 匹配电话号码
        String phonePattern = "\\d{3}-\\d{4}-\\d{4}";
        Pattern phonePatternCompiled = Pattern.compile(phonePattern);
        Matcher phoneMatcher = phonePatternCompiled.matcher(text);
        if (phoneMatcher.find()) {
            System.out.println("找到电话: " + phoneMatcher.group());
        }
        // 3. 多模式匹配
        String multiPattern = "(邮箱|电话|地址)";
        Pattern multiPatternCompiled = Pattern.compile(multiPattern);
        Matcher multiMatcher = multiPatternCompiled.matcher(text);
        while (multiMatcher.find()) {
            System.out.println("匹配到关键词: " + multiMatcher.group() + 
                             " 位置: " + multiMatcher.start());
        }
    }
}

KMP算法实现

public class KMPAlgorithm {
    // 构建部分匹配表
    private static int[] buildPMT(String pattern) {
        int[] pmt = new int[pattern.length()];
        int j = 0;
        for (int i = 1; i < pattern.length(); i++) {
            while (j > 0 && pattern.charAt(i) != pattern.charAt(j)) {
                j = pmt[j - 1];
            }
            if (pattern.charAt(i) == pattern.charAt(j)) {
                j++;
            }
            pmt[i] = j;
        }
        return pmt;
    }
    // KMP搜索
    public static int kmpSearch(String text, String pattern) {
        if (pattern.isEmpty()) return 0;
        int[] pmt = buildPMT(pattern);
        int j = 0;
        for (int i = 0; i < text.length(); i++) {
            while (j > 0 && text.charAt(i) != pattern.charAt(j)) {
                j = pmt[j - 1];
            }
            if (text.charAt(i) == pattern.charAt(j)) {
                j++;
            }
            if (j == pattern.length()) {
                return i - j + 1;  // 返回匹配起始位置
            }
        }
        return -1;  // 未找到
    }
    public static void main(String[] args) {
        String text = "ABCABCABD";
        String pattern = "ABCABD";
        int index = kmpSearch(text, pattern);
        if (index != -1) {
            System.out.println("找到模式 '" + pattern + "' 在文本中的位置: " + index);
            System.out.println("匹配子串: '" + text.substring(index, index + pattern.length()) + "'");
        } else {
            System.out.println("未找到模式 '" + pattern + "'");
        }
    }
}

实用字符串匹配工具类

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class StringMatchUtils {
    // 查找所有匹配位置
    public static List<Integer> findAllMatches(String text, String pattern) {
        List<Integer> positions = new ArrayList<>();
        Pattern p = Pattern.compile(Pattern.quote(pattern));
        Matcher m = p.matcher(text);
        while (m.find()) {
            positions.add(m.start());
        }
        return positions;
    }
    // 模糊匹配（忽略大小写）
    public static boolean fuzzyMatch(String text, String pattern) {
        return text.toLowerCase().contains(pattern.toLowerCase());
    }
    // 通配符匹配 (* 和 ?)
    public static boolean wildcardMatch(String text, String pattern) {
        String regex = pattern
            .replace(".", "\\.")
            .replace("*", ".*")
            .replace("?", ".");
        return text.matches(regex);
    }
    // 提取匹配内容
    public static List<String> extractMatches(String text, String regex) {
        List<String> matches = new ArrayList<>();
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);
        while (matcher.find()) {
            matches.add(matcher.group());
        }
        return matches;
    }
    // 测试
    public static void main(String[] args) {
        String text = "Hello Java, hello Python, Hello JavaScript";
        // 查找所有"hello"位置（忽略大小写）
        List<Integer> positions = findAllMatches(text.toLowerCase(), "hello");
        System.out.println("'hello'的所有位置: " + positions);
        // 模糊搜索
        System.out.println("包含'java': " + fuzzyMatch(text, "java"));
        // 通配符匹配
        System.out.println("通配符匹配 'H*llo': " + wildcardMatch(text, "H*llo"));
        // 提取单词
        List<String> words = extractMatches(text, "\\w+");
        System.out.println("提取的单词: " + words);
    }
}

性能测试与比较

public class PerformanceTest {
    public static void main(String[] args) {
        // 准备测试数据
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 100000; i++) {
            sb.append("test" + i + " ");
        }
        String text = sb.toString();
        String pattern = "test99999";
        // 测试不同方法
        long startTime, endTime;
        // 1. contains()
        startTime = System.nanoTime();
        boolean result1 = text.contains(pattern);
        endTime = System.nanoTime();
        System.out.println("contains() 耗时: " + (endTime - startTime) + " ns");
        // 2. indexOf()
        startTime = System.nanoTime();
        int index = text.indexOf(pattern);
        endTime = System.nanoTime();
        System.out.println("indexOf() 耗时: " + (endTime - startTime) + " ns");
        // 3. matches()
        startTime = System.nanoTime();
        boolean result3 = text.matches(".*" + Pattern.quote(pattern) + ".*");
        endTime = System.nanoTime();
        System.out.println("matches() 耗时: " + (endTime - startTime) + " ns");
        // 4. 使用Pattern
        startTime = System.nanoTime();
        Pattern p = Pattern.compile(Pattern.quote(pattern));
        Matcher m = p.matcher(text);
        boolean result4 = m.find();
        endTime = System.nanoTime();
        System.out.println("Pattern.find() 耗时: " + (endTime - startTime) + " ns");
    }
}

最佳实践建议

1. 简单匹配：优先使用 contains(), indexOf() 等基础方法
2. 复杂模式：使用正则表达式，但注意预编译Pattern对象提升性能
3. 大量数据：考虑使用KMP等高效算法
4. 错误处理：添加null检查和异常处理
5. 国际化：注意字符编码和Unicode支持

这些案例涵盖了Java字符串匹配的常用场景和实现方法,你可以根据实际需求选择合适的方案。