indexOf() 是什么？

indexOf() 是 Java String 类的一个实例方法，用于查找子字符串或字符在当前字符串中第一次出现的索引位置。

它的核心思想是：从字符串的开头（索引为 0 的位置）开始向后搜索，找到第一个匹配项，并返回它的起始索引，如果找不到，则返回 -1。

方法重载（Overloaded Methods）

indexOf() 方法有几种不同的重载形式，以满足不同的查找需求。

a) 查找字符（char）的索引

这是最简单的形式,用于查找单个字符在字符串中第一次出现的位置。

语法:

public int indexOf(char ch)

参数:

• ch: 要查找的字符（char 类型）。

返回值:

• 如果找到该字符,返回它第一次出现的索引（一个 int 值）。
• 如果未找到该字符,返回 -1。

示例:

public class IndexOfExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        // 查找字符 'o' 的索引
        int index1 = str.indexOf('o');
        System.out.println("字符 'o' 的索引是: " + index1); // 输出: 4
        // 查找字符 'H' 的索引（第一个字符）
        int index2 = str.indexOf('H');
        System.out.println("字符 'H' 的索引是: " + index2); // 输出: 0
        // 查找字符 'z' 的索引（字符串中不存在）
        int index3 = str.indexOf('z');
        System.out.println("字符 'z' 的索引是: " + index3); // 输出: -1
    }
}

b) 从指定位置开始查找字符的索引

如果你不想从字符串的开头开始查找,而是想从某个特定的索引之后开始搜索，可以使用这个重载方法。

语法:

public int indexOf(char ch, int fromIndex)

参数:

• ch: 要查找的字符。
• fromIndex: 开始搜索的起始索引（包含此位置）。

返回值:

• 从 fromIndex 开始，找到该字符则返回其索引。
• 如果未找到,返回 -1。

示例:

public class IndexOfFromIndexExample {
    public static void main(String[] args) {
        String str = "Hello, World! Hello, Java!";
        // 从索引 5 开始查找字符 'o'
        int index1 = str.indexOf('o', 5);
        System.out.println("从索引 5 开始查找 'o'，索引是: " + index1); // 输出: 8
        // 从索引 10 开始查找字符 'H'
        int index2 = str.indexOf('H', 10);
        System.out.println("从索引 10 开始查找 'H'，索引是: " + index2); // 输出: 13
        // 从索引 20 开始查找字符 'H'（超出范围）
        int index3 = str.indexOf('H', 20);
        System.out.println("从索引 20 开始查找 'H'，索引是: " + index3); // 输出: -1
    }
}

c) 查找子字符串（String）的索引

这是 indexOf() 方法最常用的形式之一，用于查找一个子字符串（一串字符）在字符串中第一次出现的位置。

语法:

public int indexOf(String str)

参数:

• str: 要查找的子字符串（String 类型）。

返回值:

• 如果找到该子字符串,返回它第一次出现的起始索引。
• 如果未找到,返回 -1。

示例:

public class IndexOfStringExample {
    public static void main(String[] args) {
        String sentence = "I love Java programming. Java is great.";
        // 查找子字符串 "Java" 的索引
        int index1 = sentence.indexOf("Java");
        System.out.println("子字符串 \"Java\" 的索引是: " + index1); // 输出: 7
        // 查找子字符串 "programming" 的索引
        int index2 = sentence.indexOf("programming");
        System.out.println("子字符串 \"programming\" 的索引是: " + index2); // 输出: 12
        // 查找子字符串 "Python" 的索引（不存在）
        int index3 = sentence.indexOf("Python");
        System.out.println("子字符串 \"Python\" 的索引是: " + index3); // 输出: -1
    }
}

d) 从指定位置开始查找子字符串的索引

结合了 b 和 c 的功能，从指定索引开始查找一个子字符串。

语法:

public int indexOf(String str, int fromIndex)

参数:

• str: 要查找的子字符串。
• fromIndex: 开始搜索的起始索引（包含此位置）。

返回值:

• 从 fromIndex 开始，找到该子字符串则返回其起始索引。
• 如果未找到,返回 -1。

示例:

public class IndexOfStringFromIndexExample {
    public static void main(String[] args) {
        String sentence = "I love Java programming. Java is great.";
        // 从索引 10 开始查找子字符串 "Java"
        int index1 = sentence.indexOf("Java", 10);
        System.out.println("从索引 10 开始查找 \"Java\"，索引是: " + index1); // 输出: 23
        // 从索引 0 开始查找，效果等同于 sentence.indexOf("Java")
        int index2 = sentence.indexOf("Java", 0);
        System.out.println("从索引 0 开始查找 \"Java\"，索引是: " + index2); // 输出: 7
    }
}

重要注意事项

1. 索引从 0 开始: Java 字符串的索引就像数组一样，第一个字符的索引是 0，第二个是 1，以此类推。

2. 区分大小写: indexOf() 方法是区分大小写的。"Java" 和 "java" 会被视为不同的字符串。

   String str = "Java";
   System.out.println(str.indexOf("java")); // 输出: -1

3. 返回 -1 的含义: 当方法返回 -1 时，并不代表索引是 -1，它是一个专门的值，用来表示“未找到”，在编程中，这是一个非常重要的约定。

4. 空字符串 ("") 的特殊情况: 如果你查找的子字符串是空字符串 ，indexOf() 会返回 0，因为空字符串可以被认为在任何字符串的“开头”存在。

   String str = "Hello";
   System.out.println(str.indexOf("")); // 输出: 0

5. fromIndex 的边界:

   • fromIndex 是一个负数，它会被当作 0 来处理。
   • fromIndex 大于或等于字符串的长度，方法会直接返回 -1，因为搜索范围已经超出了字符串的末尾。

实际应用场景

indexOf() 通常与 substring() 方法结合使用，用于从字符串中提取特定部分。

场景：从一个 URL 中提取文件名

public class PracticalExample {
    public static void main(String[] args) {
        String url = "https://www.example.com/images/profile.jpg";
        // 1. 找到最后一个 '/' 的位置
        int lastSlashIndex = url.lastIndexOf('/'); // 使用 lastIndexOf 更合适
        // 2. 如果找到了 '/'，就从它的下一个位置开始截取字符串到最后
        if (lastSlashIndex != -1) {
            String filename = url.substring(lastSlashIndex + 1);
            System.out.println("提取的文件名是: " + filename); // 输出: profile.jpg
        } else {
            System.out.println("URL 中未找到文件名分隔符 '/'。");
        }
    }
}

场景：检查一个字符串是否包含另一个字符串

虽然 contains() 方法更直接，但 indexOf() 也可以实现同样的功能。

public class ContainsExample {
    public static void main(String[] args) {
        String text = "This is a test sentence.";
        // 使用 contains() 方法 (推荐)
        boolean hasWord1 = text.contains("test");
        System.out.println("使用 contains() 是否包含 'test': " + hasWord1); // true
        // 使用 indexOf() 方法
        boolean hasWord2 = text.indexOf("test") != -1;
        System.out.println("使用 indexOf() 是否包含 'test': " + hasWord2); // true
        boolean hasWord3 = text.indexOf("hello") == -1;
        System.out.println("使用 indexOf() 是否不包含 'hello': " + hasWord3); // true
    }
}

相关方法：lastIndexOf()

与 indexOf() 相对的是 lastIndexOf() 方法，它的功能和参数完全相同，只是搜索方向相反：

• indexOf(): 从前往后找，返回第一个匹配项的索引。
• lastIndexOf(): 从后往前找，返回最后一个匹配项的索引。

示例:

String str = "banana";
int firstA = str.indexOf('a');  // 从前往后找 'a'，返回 1
int lastA = str.lastIndexOf('a'); // 从后往前找 'a'，返回 5
System.out.println("第一个 'a' 的索引: " + firstA); // 输出: 1
System.out.println("最后一个 'a' 的索引: " + lastA);  // 输出: 5

掌握 indexOf() 是进行 Java 字符串处理的基础技能，希望这份详细的解释能帮助你完全理解它！