Java重复词处理：检测、删除与格式化教程

本教程专注于Java中处理文本重复词的实用技巧，旨在帮助开发者高效地检测、移除句子中的连续重复词，并以规范的格式输出结果，符合百度SEO标准。文章深入剖析了在循环中直接输出可能导致的陷阱，强调分离处理逻辑与输出逻辑的重要性。核心策略是利用StringBuilder或ArrayList等数据结构累积处理结果，并通过状态管理来确保输出的准确性和清晰性。教程提供了详细的代码示例，展示了如何使用`split("\\s+")`处理多个连续空格，以及如何通过`equalsIgnoreCase()`进行大小写不敏感的比较。此外，还对比了StringBuilder和ArrayList在性能和适用性上的差异，并给出了处理边界条件、大小写敏感性、标点符号等方面的注意事项与最佳实践，助力开发者编写出更健壮、更专业的Java文本处理程序。

本教程旨在解决Java中识别并移除句子中连续重复词的问题，并以指定格式输出处理结果。我们将探讨如何避免在循环中直接打印，转而利用StringBuilder等数据结构高效构建修正后的字符串，并通过比较原始与修正后的句子来判断是否存在重复，最终实现清晰、专业的输出。

问题解析：循环中的输出陷阱

在处理文本或任何数据集合时，开发者常遇到的一个挑战是如何在循环迭代过程中，根据累积的结果或最终状态进行统一的输出。原始代码尝试在检测到重复词时立即打印提示信息，这导致了两个主要问题：

1. 重复打印提示： 如果在内层循环中发现重复并打印“有重复”或“无重复”，那么每次循环迭代都可能触发打印，导致输出混乱且不符合预期。
2. 不准确的判断： 在循环中，我们可能无法得知整个处理过程是否已经结束，或者是否还有其他重复词。例如，在第一个重复词被处理后，就立即打印“有重复”，这可能与最终的整体判断不符，并且无法在所有处理完成后再统一输出修正后的句子。

核心需求是：程序需要先完整地分析整个句子，识别所有连续重复的词，构建一个修正后的句子，然后根据原始句子与修正后句子的对比结果，一次性地输出带有特定格式的提示信息。

核心策略：结果累积与状态管理

解决上述问题的关键在于将“处理逻辑”与“输出逻辑”进行分离。我们不应在处理数据的循环中直接进行最终的输出，而是应该：

1. 累积处理结果： 在循环过程中，将符合条件的、经过处理的有效数据片段（例如，非重复的单词）收集起来，存储到一个合适的数据结构中。
2. 管理处理状态： 使用一个布尔标志（如repetitionsFound）来记录在整个处理过程中是否检测到了任何需要报告的事件（例如，是否存在重复词）。
3. 统一输出： 在所有数据处理完毕后，根据累积的结果和管理的状态，进行一次性、格式化的输出。

这种模式确保了输出的准确性和清晰性，避免了在中间步骤产生不必要的干扰。

方法一：使用StringBuilder高效构建修正句子

StringBuilder是Java中用于构建和修改字符串的推荐类，尤其在需要进行大量字符串拼接操作时，其性能远优于直接使用String的+运算符。

算法设计

1. 拆分句子： 将输入的句子通过空格拆分为单词数组。
2. 遍历与判断： 遍历单词数组。对于每个单词，判断它是否与其紧邻的下一个单词相同。
   • 如果当前单词是句子中的最后一个词，或者当前词与下一个词不相同，则说明当前词是有效的，应将其添加到StringBuilder中。
   • 如果当前词与下一个词相同（即发现连续重复），则应该跳过下一个词（因为它是重复的），同时设置一个标志位表明已发现重复。
3. 构建修正句子： 将非重复的单词逐个添加到StringBuilder中，并在单词之间添加空格。
4. 最终判断与输出： 遍历结束后，将StringBuilder转换为最终的修正字符串。通过比较原始句子与修正后的句子，或检查标志位，来确定是否需要打印“有重复”的提示，并最终输出修正后的句子。

示例代码

以下是一个实现了上述逻辑的Java类：

import java.util.Objects; // For Objects.equals() which handles nulls gracefully

public class SentenceProcessor {
    private String originalSentence;

    public SentenceProcessor(String sentence) {
        // 对输入句子进行非空检查和trim处理，提高健壮性
        this.originalSentence = Objects.requireNonNull(sentence, "Sentence cannot be null").trim();
    }

    /**
     * 处理句子，移除连续重复的单词，并按照指定格式输出结果。
     * @return 修正后的句子字符串。
     */
    public String processAndOutput() {
        // 如果原始句子为空，直接返回空字符串并输出无重复信息
        if (originalSentence.isEmpty()) {
            System.out.println("There are no wrong repetitions");
            return "";
        }

        // 将句子拆分为单词数组
        // 使用正则表达式 "\\s+" 可以处理多个连续空格的情况
        String[] words = originalSentence.split("\\s+");
        StringBuilder correctedSentenceBuilder = new StringBuilder();
        boolean repetitionsFound = false; // 标志位，用于记录是否发现连续重复词

        // 遍历单词数组
        for (int i = 0; i < words.length; i++) {
            String currentWord = words[i];

            // 判断是否为最后一个单词，或当前词与下一个词不连续重复
            // 如果是最后一个词，或者当前词与下一个词不相等，则当前词是有效的
            if (i == words.length - 1 || !currentWord.equalsIgnoreCase(words[i + 1])) {
                correctedSentenceBuilder.append(currentWord);
                // 如果不是最后一个有效词，则在其后添加空格
                if (i < words.length - 1) {
                    // 检查下一个词是否会被跳过，如果下一个词会被跳过，则不加空格
                    // 否则，正常添加空格
                    if (i + 1 < words.length && currentWord.equalsIgnoreCase(words[i + 1])) {
                        // 如果下一个词是重复的，并且会被跳过，这里不加空格，因为我们i会跳过它
                        // 但为了避免在builder末尾留下多余空格，统一在最后trim
                    } else {
                        correctedSentenceBuilder.append(" ");
                    }
                }
            } else {
                // 发现连续重复词：当前词与下一个词相同
                repetitionsFound = true; // 设置标志位
                i++; // 跳过下一个重复的词
            }
        }

        // 将StringBuilder转换为最终的修正句子，并去除可能存在的末尾空格
        String correctedSentence = correctedSentenceBuilder.toString().trim();

        // 根据repetitionsFound标志位决定输出信息
        if (repetitionsFound) {
            System.out.println("The sentence includes wrong repetitions.");
            System.out.println("The sentence should be: " + correctedSentence);
        } else {
            System.out.println("There are no wrong repetitions");
        }

        return correctedSentence; // 返回修正后的句子
    }

    // 示例用法
    public static void main(String[] args) {
        System.out.println("--- Test Case 1 ---");
        SentenceProcessor processor1 = new SentenceProcessor("The operator did not not skip his meal");
        processor1.processAndOutput();
        // Expected Output:
        // The sentence includes wrong repetitions.
        // The sentence should be: The operator did not skip his meal

        System.out.println("\n--- Test Case 2 ---");
        SentenceProcessor processor2 = new SentenceProcessor("Happy people live longer");
        processor2.processAndOutput();
        // Expected Output:
        // There are no wrong repetitions

        System.out.println("\n--- Test Case 3 ---");
        SentenceProcessor processor3 = new SentenceProcessor("This is an invalid invalid sentence that that needs corrected");
        processor3.processAndOutput();
        // Expected Output:
        // The sentence includes wrong repetitions.
        // The sentence should be: This is an invalid sentence that needs corrected

        System.out.println("\n--- Test Case 4 (Empty/Single word) ---");
        SentenceProcessor processor4 = new SentenceProcessor("");
        processor4.processAndOutput(); // Handles empty string
        SentenceProcessor processor5 = new SentenceProcessor("Hello");
        processor5.processAndOutput(); // Handles single word

        System.out.println("\n--- Test Case 5 (Case Insensitive) ---");
        SentenceProcessor processor6 = new SentenceProcessor("Hello hello World");
        processor6.processAndOutput(); // Handles case-insensitive check
    }
}

代码解析

1. originalSentence.split("\\s+"): 使用正则表达式"\\s+"来拆分句子，这比简单的" "更健壮，可以处理多个连续空格的情况。
2. StringBuilder correctedSentenceBuilder: 用于动态构建修正后的句子，避免了频繁创建String对象。
3. boolean repetitionsFound: 这是一个关键的状态标志。它在循环开始时初始化为false，一旦发现任何连续重复词，就将其设置为true。这样，在循环结束后，我们只需检查这个标志即可知道是否有重复。
4. for (int i = 0; i < words.length; i++): 遍历单词数组。
5. currentWord.equalsIgnoreCase(words[i + 1]): 使用equalsIgnoreCase进行大小写不敏感的比较，这通常更符合用户对“重复词”的理解。如果需要大小写敏感，则使用equals。
6. if (i == words.length - 1 || !currentWord.equalsIgnoreCase(words[i + 1])): 这是核心逻辑。它判断当前词是否应该被添加到correctedSentenceBuilder中。
   • i == words.length - 1: 如果是最后一个词，它不可能有后续的重复词，所以总是有效的。
   • !currentWord.equalsIgnoreCase(words[i + 1]): 如果当前词与下一个词不相同，那么当前词是有效的。
7. correctedSentenceBuilder.append(" ");: 在添加每个有效词后，如果不是最后一个词，则添加一个空格。
8. else { repetitionsFound = true; i++; }: 如果发现连续重复（即当前词与下一个词相同），则将repetitionsFound设置为true，并通过i++跳过下一个重复词，从而有效地“移除”它。
9. correctedSentenceBuilder.toString().trim(): 在循环结束后，将StringBuilder的内容转换为String，并使用trim()方法去除可能存在的末尾空格。
10. 最终输出逻辑: 根据repetitionsFound的值，打印相应的提示信息和修正后的句子。

方法二：使用ArrayList存储单词

除了StringBuilder，我们也可以使用ArrayList来存储非重复的单词，最后再将列表中的单词拼接成一个字符串。

示例代码片段

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

public class SentenceProcessorWithList {
    private String originalSentence;

    public SentenceProcessorWithList(String sentence) {
        this.originalSentence = Objects.requireNonNull(sentence, "Sentence cannot be null").trim();
    }

    public String processAndOutput() {
        if (originalSentence.isEmpty()) {
            System.out.println("There are no wrong repetitions");
            return "";
        }

        String[] words = originalSentence.split("\\s+");
        List<String> validWords = new ArrayList<>(); // 使用ArrayList存储有效单词
        boolean repetitionsFound = false;

        for (int i = 0; i < words.length; i++) {
            String currentWord = words[i];
            // 同样判断是否为最后一个单词，或当前词与下一个词不连续重复
            if (i == words.length - 1 || !currentWord.equalsIgnoreCase(words[i + 1])) {
                validWords.add(currentWord); // 添加到列表中
            } else {
                repetitionsFound = true;
                i++; // 跳过下一个重复的词
            }
        }

        // 使用String.join()将列表中的单词拼接成一个字符串
        String correctedSentence = String.join(" ", validWords);

        if (repetitionsFound) {
            System.out.println("The sentence includes wrong repetitions.");
            System.out.println("The sentence should be: " + correctedSentence);
        } else {
            System.out.println("There are no wrong repetitions");
        }

        return correctedSentence;
    }

    public static void main(String[] args) {
        System.out.println("--- Test Case (ArrayList) ---");
        SentenceProcessorWithList processor = new SentenceProcessorWithList("The operator did not not skip his meal");
        processor.processAndOutput();
    }
}

优缺点对比

• StringBuilder：
  • 优点： 在处理大量字符串拼接时通常性能更优，因为它直接操作字符数组。
  • 缺点： 逻辑相对紧凑，如果需要对中间的单词列表进行额外操作，可能不如ArrayList直观。
• ArrayList：
  • 优点： 存储单词列表更直观，方便进行后续的列表操作（如排序、过滤等），最后通过String.join()拼接非常简洁。
  • 缺点： 在极端大量的单词拼接场景下，String.join()内部可能仍涉及多次字符串创建，性能略低于StringBuilder（但对于一般句子长度，差异可忽略）。

两种方法都能有效解决问题，开发者可以根据个人偏好和具体场景选择。对于本例，两者都非常适用。

注意事项与最佳实践

1. 边界条件处理：
   • 空句子或只含空格的句子： 在代码开头进行检查，避免split()产生空数组或不期望的结果。
   • 单词句子： 确保循环逻辑能正确处理只有一个词的句子，它不应被标记为有重复。
   • 句子末尾重复词： i == words.length - 1的判断确保了最后一个词的正确处理。
2. 大小写敏感性： 根据需求选择equals()（大小写敏感）或equalsIgnoreCase()（大小写不敏感）。本教程示例采用了equalsIgnoreCase()，通常更符合自然语言处理的预期。
3. 标点符号处理： 示例代码使用split("\\s+")按空格拆分。如果句子包含标点符号（如"meal."），这些标点会附着在单词上。更复杂的场景可能需要使用正则表达式预处理句子以去除标点，或使用更精细的分词器。
4. 分离职责： 将核心的“检测和构建修正句子”逻辑与“输出结果”逻辑分离开来。processAndOutput()方法既处理又输出，但在实际应用中，通常会有一个方法负责返回修正后的句子（如getCorrectedSentence()），另一个方法负责根据结果进行输出。
5. 健壮性： 对输入参数进行非空检查，避免NullPointerException。

总结

本教程详细探讨了在Java中处理文本连续重复词的问题，并提供了一种高效且结构清晰的解决方案。核心思想在于将数据处理过程中的中间结果累积起来，并通过一个状态标志来记录关键事件，最终在所有处理完成后进行一次性、格式化的输出。通过使用StringBuilder或ArrayList，我们能够有效地构建修正后的字符串，同时避免了在循环中直接打印导致的混乱。掌握这种“结果累积与状态管理”的模式，对于解决各类涉及循环处理和统一输出的编程问题都具有重要的指导意义。

本篇关于《Java重复词处理：检测、删除与格式化教程》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！