基于嵌套循环统计唯一单词：自定义Java字符串单词解析开发需求

嘿，我给你写了一个完全符合要求的Java类，全程手动实现单词解析逻辑，没有用到任何Java库自带的拆分工具，还包含了嵌套循环统计唯一单词的部分，一起来看看：

public class WordParser {
    private final String input;
    private final String[] words;

    // 构造方法：接收输入语句并完成单词解析
    public WordParser(String input) {
        this.input = input;
        this.words = parseWords(input);
    }

    // 核心解析方法：手动遍历字符拆分单词
    private String[] parseWords(String input) {
        // 先统计单词数量，方便初始化数组
        int wordCount = countWords(input);
        String[] result = new String[wordCount];
        int currentWordIndex = 0;
        StringBuilder currentWord = new StringBuilder();

        for (int i = 0; i < input.length(); i++) {
            char c = input.charAt(i);
            // 判断当前字符是否是分隔符（空格、逗号、句号）
            if (c == ' ' || c == ',' || c == '.') {
                // 如果当前已经在构建单词，就把它存入数组
                if (currentWord.length() > 0) {
                    result[currentWordIndex++] = currentWord.toString();
                    currentWord.setLength(0); // 重置StringBuilder
                }
            } else {
                currentWord.append(c);
            }
        }

        // 处理最后一个单词（如果输入不以分隔符结尾）
        if (currentWord.length() > 0) {
            result[currentWordIndex] = currentWord.toString();
        }

        return result;
    }

    // 辅助方法：统计输入中的单词数量
    private int countWords(String input) {
        int count = 0;
        boolean inWord = false;

        for (int i = 0; i < input.length(); i++) {
            char c = input.charAt(i);
            if (c == ' ' || c == ',' || c == '.') {
                inWord = false;
            } else if (!inWord) {
                inWord = true;
                count++;
            }
        }

        return count;
    }

    // 公共方法：获取所有解析出的单词
    public String[] getAllWords() {
        // 返回副本，避免外部修改内部数组
        return words.clone();
    }

    // 公共方法：获取单词总数
    public int getTotalWordCount() {
        return words.length;
    }

    // 公共方法：使用嵌套循环统计唯一单词数量
    public int getUniqueWordCount() {
        if (words.length == 0) {
            return 0;
        }

        int uniqueCount = 0;
        // 外层循环遍历每个单词
        for (int i = 0; i < words.length; i++) {
            boolean isUnique = true;
            // 内层循环检查当前单词之前是否出现过
            for (int j = 0; j < i; j++) {
                if (words[i].equals(words[j])) {
                    isUnique = false;
                    break;
                }
            }
            if (isUnique) {
                uniqueCount++;
            }
        }

        return uniqueCount;
    }

    // 要求的public static void方法：演示类的使用
    public static void main(String[] args) {
        String sampleSentence = "Hello, world. This is a test. Hello again, world.";
        WordParser parser = new WordParser(sampleSentence);

        System.out.println("原语句：" + sampleSentence);
        System.out.println("所有单词：");
        for (String word : parser.getAllWords()) {
            System.out.println("- " + word);
        }
        System.out.println("单词总数：" + parser.getTotalWordCount());
        System.out.println("唯一单词数量：" + parser.getUniqueWordCount());
    }
}

代码细节说明： #

• 构造方法：接收输入语句后，立刻调用parseWords完成解析，把结果存在内部数组里，保证后续方法可以直接使用解析好的数据。
• 手动解析逻辑：全程通过遍历每个字符判断是否是分隔符，完全避开了String.split()这类库工具，自己实现了单词拆分的核心逻辑。
• 嵌套循环统计唯一单词：getUniqueWordCount用两层循环实现，外层遍历每个单词，内层检查该单词在之前的位置是否出现过，完全符合你要求的嵌套循环统计方式。
• 公共值方法：包含了获取所有单词、单词总数、唯一单词数这几个常用的方法，满足需求。
• public static void方法：main方法作为示例，演示了整个类的使用流程，你可以直接运行它看到效果。

运行main方法会输出：

原语句：Hello, world. This is a test. Hello again, world.
所有单词：
- Hello
- world
- This
- is
- a
- test
- Hello
- again
- world
单词总数：9
唯一单词数量：7

内容的提问来源于stack exchange，提问作者Derek Williams