Java 在不使用数组的情况下计算字符串中的唯一字

因此，我的任务是编写一个程序，在不使用数组的情况下，计算给定字符串中的单词数和唯一单词数。 我可以完成第一项任务，我想知道如何才能完成第二部分。 用于计算字符串中的字数

boolean increment = false;
    for (int i = 0; i < inputPhrase.length(); i++){
           if(validChar(inputPhrase.charAt(i))) //validChar(char c) is a simple method that returns a valid character{
                   increment = true;
           }
           else if(increment){
                   phraseWordCount ++;
                   increment = false;
           }
    }
    if(increment) phraseWordCount++; //in the case the last word is a valid character

起初我把这个忘了，只差一个字就走了

---

要计算独特的单词，我可以修改它吗

使用Collections API，您可以使用以下方法计算字数：

private int countWords(final String text) {
    Scanner scanner = new Scanner(text);
    Set<String> uniqueWords = new HashSet<String>();

    while (scanner.hasNext()) {
        uniqueWords.add(scanner.next());
    }

    scanner.close();

    return uniqueWords.size();
}

---

下面是如何在没有阵列的情况下执行此操作的建议：

1读取每个字符，直到找到一个空白，然后将该字符添加到第二个字符串中。 2如果发现空白，则将其或另一个标记添加到第二个字符串中以分隔单词。 从第二个字符串中读取每个单词，并将其与输入字符串中的当前单词进行比较

每次单词结束时，findUpTo都会在该单词开始之前检查输入中是否包含该单词。因此，如果将计算为一个唯一的三个字

/**
 * Created for http://stackoverflow.com/q/22981210/1266906
 */
public class UniqueWords {

    public static void main(String[] args) {
        String inputPhrase = "one two ones two three one";
        countWords(inputPhrase);
    }

    private static void countWords(String inputPhrase) {
        boolean increment = false;
        int wordStart = -1;
        int phraseWordCount = 0;
        int uniqueWordCount = 0;
        for (int i = 0; i < inputPhrase.length(); i++){
            if(validChar(inputPhrase.charAt(i))) { //validChar(char c) is a simple method that returns a valid character{
                increment = true;
                if(wordStart == -1) {
                    wordStart = i;
                }
            } else if(increment) {
                phraseWordCount++;
                final String lastWord = inputPhrase.substring(wordStart, i);
                boolean unique = findUpTo(lastWord, inputPhrase, wordStart);
                if(unique) {
                    uniqueWordCount++;
                }
                increment = false;
                wordStart = -1;
            }
        }
        if(increment) {
            phraseWordCount++; //in the case the last word is a valid character
            final String lastWord = inputPhrase.substring(wordStart, inputPhrase.length());
            boolean unique = findUpTo(lastWord, inputPhrase, wordStart);
            if(unique) {
                uniqueWordCount++;
            }
        }
        System.out.println("Words: "+phraseWordCount);
        System.out.println("Unique: "+uniqueWordCount);
    }

    private static boolean findUpTo(String needle, String haystack, int lastPos) {
        boolean previousValid = false;
        boolean unique = true;
        for(int j = 0; unique && j < lastPos - needle.length(); j++) {
            final boolean nextValid = validChar(haystack.charAt(j));
            if(!previousValid && nextValid) {
                // Word start
                previousValid = true;
                for (int k = 0; k < lastPos - j; k++) {
                    if(k == needle.length()) {
                        // We matched all characters. Only if the word isn't finished it is unique
                        unique = validChar(haystack.charAt(j+k));
                        break;
                    }
                    if (needle.charAt(k) != haystack.charAt(j+k)) {
                        break;
                    }
                }
            } else {
                previousValid = nextValid;
            }
        }
        return unique;
    }

    private static boolean validChar(char c) {
        return Character.isAlphabetic(c);
    }
}

---

是否允许您使用集合，例如Set？@ifLoop如果不允许他使用数组，他可能也不能使用集合。@Marounn您的评论的目的是什么？我很聪明，可以自己假设，但因为我没有远见，我不得不问他。你是一个有远见的人吗？你必须以某种方式注册你的字符串，所以我认为你正在寻找的是不可能的。除非您仅限于不使用数组，但能够使用其他存储类。。。但在这种情况下，你有答案。@ifLoop你为什么要攻击我？放松点，我的朋友。。放松点，微笑吧。。没必要那么咄咄逼人。你以前试过这个代码吗？try输入字符串为3个单词，2个唯一。。我不这么认为so@DanP. 我想我搞乱了内部for循环，我必须检查令牌而不是“”。修正了。但是还有其他的错误。。我会重做那个--我想可能是定义错误。是不是一个独特的词，因为它是重复的。。。但问题应该澄清。这太棒了！谢谢

public static void main(String[] args) {
    final String input = "This is a sentence that is containing three times the word is";
    final char   token = '#';

    String processedInput  = "";
    String currentWord     = "";
    int    wordCount       = 0;
    int    uniqueWordCount = 0;

    for (char c : input.toCharArray()) {
        if (c != ' ') {
            processedInput += c;
            currentWord    += c;
        } else {
            processedInput += token;
            wordCount++;

            String  existingWord      = "";
            int     occurences        = 0;

            for (char c1 : processedInput.toCharArray()) {
                if (c1 != token) {
                    existingWord += c1;
                } else {
                    if (existingWord.equals(currentWord)) {
                        occurences++;
                    }

                    existingWord = "";
                }
            }

            if (occurences <= 1) {
                System.out.printf("New word: %s\n", currentWord);
                uniqueWordCount++;
            }

            currentWord = "";
        }
    }
    wordCount++;


    System.out.printf("%d words total, %d unique\n", wordCount, uniqueWordCount);
}

New word: This
New word: is
New word: a
New word: sentence
New word: that
New word: containing
New word: three
New word: times
New word: the
New word: word
12 words total, 10 unique

/**
 * Created for http://stackoverflow.com/q/22981210/1266906
 */
public class UniqueWords {

    public static void main(String[] args) {
        String inputPhrase = "one two ones two three one";
        countWords(inputPhrase);
    }

    private static void countWords(String inputPhrase) {
        boolean increment = false;
        int wordStart = -1;
        int phraseWordCount = 0;
        int uniqueWordCount = 0;
        for (int i = 0; i < inputPhrase.length(); i++){
            if(validChar(inputPhrase.charAt(i))) { //validChar(char c) is a simple method that returns a valid character{
                increment = true;
                if(wordStart == -1) {
                    wordStart = i;
                }
            } else if(increment) {
                phraseWordCount++;
                final String lastWord = inputPhrase.substring(wordStart, i);
                boolean unique = findUpTo(lastWord, inputPhrase, wordStart);
                if(unique) {
                    uniqueWordCount++;
                }
                increment = false;
                wordStart = -1;
            }
        }
        if(increment) {
            phraseWordCount++; //in the case the last word is a valid character
            final String lastWord = inputPhrase.substring(wordStart, inputPhrase.length());
            boolean unique = findUpTo(lastWord, inputPhrase, wordStart);
            if(unique) {
                uniqueWordCount++;
            }
        }
        System.out.println("Words: "+phraseWordCount);
        System.out.println("Unique: "+uniqueWordCount);
    }

    private static boolean findUpTo(String needle, String haystack, int lastPos) {
        boolean previousValid = false;
        boolean unique = true;
        for(int j = 0; unique && j < lastPos - needle.length(); j++) {
            final boolean nextValid = validChar(haystack.charAt(j));
            if(!previousValid && nextValid) {
                // Word start
                previousValid = true;
                for (int k = 0; k < lastPos - j; k++) {
                    if(k == needle.length()) {
                        // We matched all characters. Only if the word isn't finished it is unique
                        unique = validChar(haystack.charAt(j+k));
                        break;
                    }
                    if (needle.charAt(k) != haystack.charAt(j+k)) {
                        break;
                    }
                }
            } else {
                previousValid = nextValid;
            }
        }
        return unique;
    }

    private static boolean validChar(char c) {
        return Character.isAlphabetic(c);
    }
}