LabEx
登录免费加入

Java 中使用 indexOf() 方法查找字符串中的单词

JavaBeginner
立即练习

简介

在这个 Java 编程教程中，我们将探讨 indexOf() 方法，这是一个用于在 Java 字符串中查找单词或字符的通用工具。 indexOf() 方法对于在 Java 应用程序中处理文本至关重要，它允许你搜索大型字符串中的特定内容。在本教程结束时，你将了解如何有效地使用此方法，并在各种场景中应用它，以增强你的 Java 字符串处理技能。

创建你的第一个字符串搜索程序

在这一步中，我们将创建一个简单的 Java 程序，演示如何使用 indexOf() 方法在字符串中查找特定的单词。

理解 indexOf() 方法

indexOf() 方法是 Java 的 String 类中的一个内置函数，它帮助你定位子字符串在较大字符串中的位置。以下是基本语法：

int indexOf(String str)

此方法返回指定子字符串第一次出现的索引（位置）。如果未找到子字符串，则该方法返回 -1。

创建 Java 文件

让我们创建第一个程序，看看 indexOf() 方法的实际应用：

  1. 在你的 LabEx 环境中打开 WebIDE
  2. 通过单击“新建文件”图标或使用“文件”菜单创建一个新文件
  3. 将文件命名为 StringSearchDemo.java
  4. 在文件中输入以下代码：
public class StringSearchDemo {
    public static void main(String[] args) {
        // 创建一个示例句子以供搜索
        String sentence = "Java programming is both fun and challenging";

        // 使用 indexOf() 查找单词的位置
        int position = sentence.indexOf("fun");

        // 显示结果
        System.out.println("原始句子：" + sentence);
        System.out.println("搜索单词 'fun'");

        if (position != -1) {
            System.out.println("单词 'fun' 在位置：" + position);
        } else {
            System.out.println("单词 'fun' 未在句子中找到");
        }
    }
}

编译和运行程序

现在让我们编译并运行我们的程序：

  1. 在 WebIDE 中打开一个终端（如果尚未打开）

  2. 通过运行以下命令编译 Java 文件：

    javac StringSearchDemo.java

  3. 运行编译后的程序：

    java StringSearchDemo

你应该看到类似于以下的输出：

原始句子: Java programming is both fun and challenging
搜索单词 'fun'
单词 'fun' 在位置: 25

探索结果

输出显示我们的程序成功地在字符串的第 25 个位置找到了单词 "fun"。在 Java 中，字符串索引从 0 开始，因此第 26 个字符位于索引 25 处。

你可以通过计算字符来验证这一点：“Java programming is both”正好有 25 个字符，然后 "fun" 开始。

尝试搜索不同的单词

让我们修改我们的程序以搜索不同的单词。在你的代码中，将搜索词从 "fun" 更改为 "programming"：

int position = sentence.indexOf("programming");
System.out.println("搜索单词 'programming'");

再次编译并运行程序：

javac StringSearchDemo.java
java StringSearchDemo

你现在应该看到：

原始句子: Java programming is both fun and challenging
搜索单词 'programming'
单词 'programming' 在位置: 5

单词 "programming" 从位置 5 开始，这是正确的，因为 "Java " 有 5 个字符。

查找一个单词的多次出现

现在我们了解了使用 indexOf() 查找单词的单次出现的基本知识，让我们通过学习如何在一个字符串中查找一个单词的所有出现来增强我们的技能。

理解第二个 indexOf() 方法签名

indexOf() 方法还有另一种有用的形式：

int indexOf(String str, int fromIndex)

此版本允许你指定搜索的起始位置。通过使用这种形式，我们可以通过从上次停止的位置开始每次新的搜索来找到一个单词的所有出现。

创建一个多重搜索程序

让我们创建一个新的 Java 程序，该程序查找特定单词的所有出现：

  1. 创建一个名为 MultipleFinder.java 的新文件
  2. 输入以下代码：
public class MultipleFinder {
    public static void main(String[] args) {
        // 创建一个包含单词多次出现的示例文本
        String paragraph = "Java is a popular programming language. Java runs on various platforms. " +
                          "Java is used for developing web applications, mobile apps, and more. " +
                          "Learning Java is essential for many software development roles.";

        System.out.println("原始文本：");
        System.out.println(paragraph);
        System.out.println("\n搜索 'Java' 的所有出现：");

        // 查找 "Java" 的所有出现
        String searchWord = "Java";
        int position = 0;
        int count = 0;

        // 循环直到找不到更多出现
        while (position != -1) {
            position = paragraph.indexOf(searchWord, position);

            if (position != -1) {
                count++;
                System.out.println("出现 " + count + " 位于位置：" + position);

                // 移过这次出现以找到下一个
                position += searchWord.length();
            }
        }

        System.out.println("\n找到的总出现次数：" + count);
    }
}

编译和运行多重搜索程序

现在让我们编译并运行我们的新程序：

  1. 在终端中，编译 Java 文件：

    javac MultipleFinder.java

  2. 运行编译后的程序：

    java MultipleFinder

你应该看到类似于以下的输出：

原始文本:
Java is a popular programming language. Java runs on various platforms. Java is used for developing web applications, mobile apps, and more. Learning Java is essential for many software development roles.

搜索 'Java' 的所有出现:
出现 1 位于位置: 0
出现 2 位于位置: 42
出现 3 位于位置: 72
出现 4 位于位置: 149

找到的总出现次数: 4

程序的工作原理

让我们分解一下这个程序是如何找到所有出现的：

  1. 我们将初始搜索位置设置为 0（字符串的开头）
  2. 我们进入一个 while 循环，该循环持续到 indexOf() 返回 -1（没有更多匹配项）
  3. 对于每个匹配项，我们：
    • 打印找到单词的位置
    • 更新搜索位置，以通过添加搜索词的长度从当前匹配项之后开始
  4. 循环继续，直到找不到更多匹配项
  5. 最后，我们打印找到的总出现次数

处理大小写敏感性

indexOf() 方法默认是区分大小写的。让我们修改我们的程序，通过将文本和搜索词都转换为小写来执行不区分大小写的搜索：

在 MultipleFinder.java 中，在 main 方法开始后添加以下几行：

// 不区分大小写的搜索演示
System.out.println("\n--- 不区分大小写的搜索 ---");
String lowercaseParagraph = paragraph.toLowerCase();
String lowercaseSearchWord = searchWord.toLowerCase();

position = 0;
count = 0;

while (position != -1) {
    position = lowercaseParagraph.indexOf(lowercaseSearchWord, position);

    if (position != -1) {
        count++;
        System.out.println("出现 " + count + " 位于位置：" + position);
        position += lowercaseSearchWord.length();
    }
}

System.out.println("\n找到的总出现次数 (不区分大小写): " + count);

编译并运行更新后的程序：

javac MultipleFinder.java
java MultipleFinder

输出现在将包括区分大小写和不区分大小写的搜索结果。

构建一个简单的文本分析器

在这一步中，我们将创建一个使用 indexOf() 方法的实用程序。我们将构建一个简单的文本分析器，它可以计算特定单词并识别它们在较大文本中的位置。

创建文本分析器

  1. 创建一个名为 TextAnalyzer.java 的新文件
  2. 输入以下代码：
import java.util.Scanner;

public class TextAnalyzer {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 示例文本以供分析
        String sampleText = "Java is one of the most popular programming languages. Java was developed " +
                          "by Sun Microsystems. Today, Java is used to develop mobile apps, web applications, " +
                          "desktop applications, games and much more. Java is known for its simplicity, " +
                          "object-oriented features, and platform independence.";

        System.out.println("文本分析器程序");
        System.out.println("=====================");
        System.out.println("\n要分析的文本：");
        System.out.println(sampleText);

        // 提示用户输入要搜索的单词
        System.out.print("\n输入要搜索的单词：");
        String searchWord = scanner.nextLine();

        // 调用方法来分析文本
        int occurrences = countOccurrences(sampleText, searchWord);

        // 显示结果
        System.out.println("\n分析结果：");
        System.out.println("----------------");
        System.out.println("搜索的单词：\"" + searchWord + "\"");
        System.out.println("出现次数：" + occurrences);

        // 如果找到该单词，则显示位置
        if (occurrences > 0) {
            System.out.println("\n\"" + searchWord + "\" 出现的位置：");
            findPositions(sampleText, searchWord);
        }

        // 计算该单词在文本中所占的百分比
        if (occurrences > 0) {
            // 计算该单词占文本的百分比
            double percentage = (double)(searchWord.length() * occurrences) / sampleText.length() * 100;
            System.out.printf("\n单词 \"%s\" 占总文本的 %.2f%%.\n",
                              searchWord, percentage);
        }

        scanner.close();
    }

    // 计算单词在文本中出现次数的方法
    public static int countOccurrences(String text, String word) {
        int count = 0;
        int position = 0;

        while (position != -1) {
            position = text.indexOf(word, position);

            if (position != -1) {
                count++;
                position += word.length();
            }
        }

        return count;
    }

    // 查找并打印单词所有位置的方法
    public static void findPositions(String text, String word) {
        int position = 0;
        int occurrence = 0;

        while (position != -1) {
            position = text.indexOf(word, position);

            if (position != -1) {
                occurrence++;
                System.out.println("  出现 " + occurrence + ": 位置 " + position +
                                  " (结束于位置 " + (position + word.length() - 1) + ")");

                // 显示单词周围的上下文
                int contextStart = Math.max(0, position - 10);
                int contextEnd = Math.min(text.length(), position + word.length() + 10);
                String context = text.substring(contextStart, contextEnd);

                // 在上下文中突出显示单词
                System.out.print("  上下文：");
                if (contextStart > 0) {
                    System.out.print("...");
                }

                System.out.print(context);

                if (contextEnd < text.length()) {
                    System.out.print("...");
                }
                System.out.println("\n");

                position += word.length();
            }
        }
    }
}

编译和运行文本分析器

现在让我们编译并运行我们的文本分析器：

  1. 在终端中，编译 Java 文件：

    javac TextAnalyzer.java

  2. 运行编译后的程序：

    java TextAnalyzer

  3. 当提示时，输入要搜索的单词，例如 Java

你应该看到类似于以下的输出：

文本分析器程序
=====================

要分析的文本:
Java is one of the most popular programming languages. Java was developed by Sun Microsystems. Today, Java is used to develop mobile apps, web applications, desktop applications, games and much more. Java is known for its simplicity, object-oriented features, and platform independence.

输入要搜索的单词: Java

分析结果:
----------------
搜索的单词: "Java"
出现次数: 4

"Java" 出现的位置:
  出现 1: 位置 0 (结束于位置 3)
  上下文: ...Java is one o...

  出现 2: 位置 48 (结束于位置 51)
  上下文: ...guages. Java was dev...

  出现 3: 位置 93 (结束于位置 96)
  上下文: ...Today, Java is used...

  出现 4: 位置 197 (结束于位置 200)
  上下文: ...more. Java is know...

单词 "Java" 占总文本的 1.67%.

理解文本分析器

我们的文本分析器执行以下操作：

  1. 它显示用于分析的示例文本
  2. 它要求用户输入要搜索的单词
  3. 它计算该单词在文本中出现的次数
  4. 它显示单词出现的位置
  5. 对于每次出现，它显示周围的上下文
  6. 它计算搜索词占总文本的百分比

此应用程序演示了 indexOf() 方法在文本分析中的实际应用。该程序可以扩展为包括更多功能，例如：

  • 不区分大小写的搜索
  • 仅查找完整的单词（而不是单词的一部分）
  • 一次分析多个单词
  • 生成关于文本的统计信息

尝试使用不同的搜索词再次运行该程序，看看它在各种输入下的表现。

总结

在本教程中，你已经学习了如何在 Java 中使用 indexOf() 方法来查找字符串中的单词。你已经掌握了：

  1. 使用 indexOf() 查找单词在字符串中第一次出现的位置
  2. 使用循环和 indexOf() 的第二种形式查找单词的所有出现
  3. 通过将字符串转换为小写来执行不区分大小写的搜索
  4. 构建一个实用的文本分析器应用程序，该应用程序演示了 indexOf() 方法的实际应用

这些字符串操作技能是 Java 编程的基础，并且在各种编程任务中都很有价值，包括数据处理、用户输入验证和文本分析。通过了解如何定位和处理字符串的特定部分，你可以构建更复杂和用户友好的应用程序。

在你继续你的 Java 之旅时，你可以通过探索其他 String 方法（如 substring()、replace() 和正则表达式）来扩展这些概念，以进行更高级的文本处理。

相关 Java 课程
Java 入门

Java 入门

java
Java 编程练习

Java 编程练习

java
批量插入数据到课程表

批量插入数据到课程表

java