Java 中查找字符串子串的全面指南

简介

在 Java 编程中，查找字符串中的子串是一项常见且基础的操作。无论是数据处理、文本解析还是字符串匹配，都可能需要用到这一功能。本文将详细介绍在 Java 中查找字符串子串的基础概念、使用方法、常见实践以及最佳实践，帮助读者更好地掌握这一重要技能。

基础概念

在 Java 中，字符串是由字符序列组成的对象，存储在 java.lang.String 类中。子串是指字符串中的一部分连续字符序列。查找子串就是在一个字符串中定位另一个字符串首次或最后一次出现的位置，或者判断字符串中是否包含某个子串。

使用方法

`indexOf` 方法

indexOf 方法用于查找子串在字符串中首次出现的位置。如果找到，返回子串的起始索引；如果未找到，返回 -1。

public class IndexOfExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        int index = str.indexOf("World");
        if (index != -1) {
            System.out.println("子串 'World' 首次出现的位置是: " + index);
        } else {
            System.out.println("未找到子串 'World'");
        }
    }
}

`lastIndexOf` 方法

lastIndexOf 方法用于查找子串在字符串中最后一次出现的位置。如果找到，返回子串的起始索引；如果未找到，返回 -1。

public class LastIndexOfExample {
    public static void main(String[] args) {
        String str = "Hello, Hello!";
        int index = str.lastIndexOf("Hello");
        if (index != -1) {
            System.out.println("子串 'Hello' 最后一次出现的位置是: " + index);
        } else {
            System.out.println("未找到子串 'Hello'");
        }
    }
}

`contains` 方法

contains 方法用于判断字符串中是否包含指定的子串。如果包含，返回 true；否则返回 false。

public class ContainsExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        boolean isContained = str.contains("World");
        if (isContained) {
            System.out.println("字符串包含子串 'World'");
        } else {
            System.out.println("字符串不包含子串 'World'");
        }
    }
}

`Pattern` 和 `Matcher` 类

对于复杂的子串查找需求，如使用正则表达式进行匹配，可以使用 java.util.regex.Pattern 和 java.util.regex.Matcher 类。

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

public class RegexExample {
    public static void main(String[] args) {
        String str = "Hello, 123 World!";
        Pattern pattern = Pattern.compile("\\d+");
        Matcher matcher = pattern.matcher(str);
        if (matcher.find()) {
            System.out.println("找到匹配的子串: " + matcher.group());
        } else {
            System.out.println("未找到匹配的子串");
        }
    }
}

常见实践

统计子串出现的次数

可以使用 indexOf 方法统计子串在字符串中出现的次数。

public class CountSubstringExample {
    public static void main(String[] args) {
        String str = "Hello, Hello, Hello!";
        String subStr = "Hello";
        int count = 0;
        int index = 0;
        while ((index = str.indexOf(subStr, index)) != -1) {
            count++;
            index += subStr.length();
        }
        System.out.println("子串 '" + subStr + "' 出现的次数是: " + count);
    }
}

查找所有子串的位置

同样可以使用 indexOf 方法查找所有子串的位置。

import java.util.ArrayList;
import java.util.List;

public class FindAllSubstringPositionsExample {
    public static void main(String[] args) {
        String str = "Hello, Hello, Hello!";
        String subStr = "Hello";
        List<Integer> positions = new ArrayList<>();
        int index = 0;
        while ((index = str.indexOf(subStr, index)) != -1) {
            positions.add(index);
            index += subStr.length();
        }
        System.out.println("子串 '" + subStr + "' 出现的位置是: " + positions);
    }
}

最佳实践

性能优化

对于简单的子串查找，优先使用 indexOf、lastIndexOf 和 contains 方法，因为它们的性能较高。
对于复杂的匹配需求，如正则表达式匹配，使用 Pattern 和 Matcher 类。但要注意，正则表达式的性能相对较低，应尽量避免在性能敏感的场景中使用。

代码可读性

在代码中使用有意义的变量名和注释，提高代码的可读性。
对于复杂的逻辑，可以将其封装成独立的方法，使代码结构更清晰。

小结

本文详细介绍了在 Java 中查找字符串子串的多种方法，包括 indexOf、lastIndexOf、contains 方法以及 Pattern 和 Matcher 类。同时，还给出了常见实践和最佳实践，帮助读者更好地掌握这一重要技能。在实际开发中，应根据具体需求选择合适的方法，以提高代码的性能和可读性。

参考资料

《Effective Java》
《Java 核心技术》