Java 作业问题的有效算法

我需要分析满足以下问题的文本：

生成一个输出，显示每个单词在文本中出现的次数。报告应首先按字长排序，然后按自然排序

我在下面给出的解决方案中被扣分。有更好的解决方案吗？我没有使用地图或任何收藏品，因为我们被告知不使用收藏品的人将获得额外的积分

我的波乔

/**
 * An instance of this object represents the string that occurs in a sentence
 * and the number of times it occurs in a single string.
 */
public class Word implements Comparable<Word> {
  private final String word;
  private int counter = 1;

  public Word(String word) {
    this.word = word;
  }

  public void incrementCounter() {
   this.counter ++;
  }

  public String getWord() {
    return word;
  }

  public int getCounter() {
    return counter;
  }

  /**
   * Overrides the default hashcode function.
   */
  @Override
  public int hashCode() {
    int hashCode = 103034;
    hashCode += this.word != null ? this.word.hashCode() ^ 3 : 0;
    hashCode += this.counter ^ 2;
    return hashCode;
  }

 /**
  * Overrides the default equals function. 
  */
 @Override
 public boolean equals(Object obj) {
   if (obj == null) {
     return false;
   }
   if (this == obj) {
     return true;
   }
   if (!(obj instanceof Word)) {
     return false;
   }
   Word otherWord = (Word) obj;
   if (this.word != null && this.word.equals(otherWord.getWord())) {
     return true;
   }
   return false;
 }

  @Override
  public String toString() {
    final StringBuilder sb = new StringBuilder();
    sb.append("Word");
    sb.append("{word='").append(word).append('\'');
    sb.append(", counter=").append(counter);
    sb.append('}');
    return sb.toString();
  }


/**
 * The implementation checks for the order of comparison.
 * The implementation first compares by presence of word string.
 *
 * @param w Word to be compared
 * @return calculated order of comparison.
 */
@Override
public int compareTo(Word w) {
  if (w == null) {
    return -1;
  }
  if (this.word == null && w.getWord() != null) {
    return 1;
  }
  if (this.word != null && w.getWord() == null) {
    return -1;
  }
  return StringUtils.compareString(this.word, w.getWord());
 } 
}

---

主要方法：

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;

/**
 * Finds the number of occurrences of word a in given string. The implementation expects
 * the input to be passed adsingle string argument.
 */
 public class StringWordOccurences {

  /**
   * Finds the number of occurrences of a word in a string. The implementation relies
   * on the following assumptions.
   *
   * <p>The word is passed as separate strings as in {@code "Hello" "World"} instead of 
   * a single string  {@code "Hello World"}.
   *
   * @param args Arguments to be sorted by first word length and then by string.
   */
  public static void main(String[] args) {
    if (args == null || args.length == 0) {
      System.out.println("There were no words. The count is 0");
      return;
    }

    // Find the number of unique words and put them in an array.
    Comparator<Word> wordComparator = new WordComparator();
    Arrays.sort(args, new Comparator<String>() {
      @Override
      public int compare(String first, String second) {
         return StringUtils.compareString(first, second);
      }
    });

    Word [] words = new Word[args.length];
    int numberOfUniqueWords = 0;
    for (String wordAsString : args) {
      Word word = new Word(wordAsString);
      int index = Arrays.binarySearch(words, word, wordComparator);
      if (index > -1) {
        words[index].incrementCounter();
      } else {
        words[numberOfUniqueWords ++] = word;
      }
     }
     Word [] filteredWords = Arrays.copyOf(words, numberOfUniqueWords);
     // The display output.
     for (Word word : filteredWords) {
       System.out.println(word);
      }
    }
}

导入java.util.array；
导入java.util.Collections；
导入java.util.Comparator；
/**
*查找给定字符串中出现的单词数。实施预期
*要传递给单个字符串参数的输入。
*/
公共类事件{
/**
*查找字符串中单词的出现次数。实现依赖于
*基于以下假设。
*
*单词作为单独的字符串传递，如在{@code“Hello”“World”}中，而不是
*单个字符串{@code“Hello World”}。
*
*@param args参数将按第一个单词长度排序，然后按字符串排序。
*/
公共静态void main（字符串[]args）{
if（args==null | | args.length==0）{
System.out.println（“没有单词，计数为0”）；
返回；
}
//找到唯一单词的数量并将其放入数组中。
Comparator wordComparator=新的wordComparator（）；
sort（args，新的Comparator（）{
@凌驾
公共整数比较（字符串第一，字符串第二）{
返回StringUtils.compareString（第一，第二）；
}
});
单词[]单词=新词[args.length]；
int numberOfUniqueWords=0；
for（字符串字字符串：args）{
单词=新词（单词串）；
int index=Arrays.binarySearch（words、word、wordComparator）；
如果（索引>-1）{
words[index].incrementCounter（）；
}否则{
单词[numberOfUniqueWords++]=单词；
}
}
Word[]filteredWords=Arrays.copyOf（words，numberOfUniqueWords）；
//显示输出。
for（单词：filteredWords）{
System.out.println（word）；
}
}
}

在按所需顺序对单词进行排序后，不需要进行二进制搜索，因为相同的单词将彼此相邻。把所有的单词都复习一遍，并把每一个单词与前一个单词进行比较。如果它们相等，则递增计数器。如果它们不相等，您可以立即打印完成的上一个单词的结果（无需将结果存储在数组中）。你也不需要Word类，你可以用字符串来实现它。

我能想到的几点，但显然这些都是猜测

你有3个地方有相似的逻辑来做单词比较

放弃Arrays.sort、Arrays.binarySearch和Arrays.copyOf。自己搜索-可能更简单

实际上，您可以在减少到唯一值后进行排序

---

你知道为什么你是停靠点吗？@nattyddubbs不幸的是没有。好吧，你确实导入了java.util.Collections，尽管你没有使用它……我认为这应该在coderview而不是stackoverflow上进行。我不知道codereview.stackexchange。我应该把这个问题移到那里去，还是暂时留在这里？谢谢你的建议。我用你的方式实现了它，它很有效。太晚了，作业已经通过了。这里有一个片段：@Kartik但现在接受/投票回答还不算晚：）

public class StringUtils {

  // Not to be instantiated.
  private StringUtils() {}

  /**
   * Compares the string first by word length and then by string.
   *
   * @param first First string to be compared.
   * @param second Second string to be compared
   * @return integer representing the output of comparison.
   */
   public static int compareString(String first, String second) {
     if (first == second) {
       return 0;
     }
     if (first == null && second != null) {
        return 1;
     }
     if (first != null && second == null) {
       return -1;
     }
     int wordLengthDifference = first.length() - second.length();
     if (wordLengthDifference == 0) {
       return first.compareTo(second);
     }
     return wordLengthDifference;
  }
}

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;

/**
 * Finds the number of occurrences of word a in given string. The implementation expects
 * the input to be passed adsingle string argument.
 */
 public class StringWordOccurences {

  /**
   * Finds the number of occurrences of a word in a string. The implementation relies
   * on the following assumptions.
   *
   * <p>The word is passed as separate strings as in {@code "Hello" "World"} instead of 
   * a single string  {@code "Hello World"}.
   *
   * @param args Arguments to be sorted by first word length and then by string.
   */
  public static void main(String[] args) {
    if (args == null || args.length == 0) {
      System.out.println("There were no words. The count is 0");
      return;
    }

    // Find the number of unique words and put them in an array.
    Comparator<Word> wordComparator = new WordComparator();
    Arrays.sort(args, new Comparator<String>() {
      @Override
      public int compare(String first, String second) {
         return StringUtils.compareString(first, second);
      }
    });

    Word [] words = new Word[args.length];
    int numberOfUniqueWords = 0;
    for (String wordAsString : args) {
      Word word = new Word(wordAsString);
      int index = Arrays.binarySearch(words, word, wordComparator);
      if (index > -1) {
        words[index].incrementCounter();
      } else {
        words[numberOfUniqueWords ++] = word;
      }
     }
     Word [] filteredWords = Arrays.copyOf(words, numberOfUniqueWords);
     // The display output.
     for (Word word : filteredWords) {
       System.out.println(word);
      }
    }
}