Hash Table efficiency question

Question

Hi experts,
In my program, I want to read in a lot of string and store the occurance of each string. I found that hash table is the best and most efficient option, but the problem is that, hash table only store one item.
So, I either have to:
1) store an array object into each hash table entries. ie String[String][Occurance]
2) create two hash table based on the hash code of the string.
For 2) I am planning to store all distinct String into one hashtable using the string as the hashcode, then create another hashtable to store the occurance using the String as the hashcode.
My question is that:
1)which implementation is more efficient? Constantly creating String array for each entry or create two hashtables?
2) Is the second implementation possible? Would the hashcode be mapped to different cell in the hashtable even the two hashtable are using the same hashcode and the same size?
Thank you very much for your help.
Kevin

Answer 1

I am wondering what it is you are trying to do, but I am assuming you are trying to find the number of occurrences for a particular word, and then determining which word has the highest value or the lowest value? You can retrieve the initial String value by using the keys() method of the hashtable. You can use it to traverse the entire table and compare the counts there.
If you really wanna store another reference for that string, create a simple object
public final class WordCount {
   * The Word being counted.
   * @since 1.1
  private String _word;
   * Count for the Number of Words.
   * @since 1.1
  private int _count;
   * Creates a new instance of the Word Count Object.
   * @param word The Word being counted.
   * @since 1.1
  public WordCount(final String word) {
    super();
    _word = word;
    _count = 0;
   * Call this method to increment the Count for the Word.
   * @since 1.1
  public void increment() {
    _count++;
   * Retrieves the word being counted.
   * @return Word being counted.
   * @since 1.1
  public String getWord() {
    return _word;
   * Return the Count for the Word.
   * @return Non-negative count for the Word.
   * @since 1.1
  public int getCount() {
    return _count;
}Then your method can be as follows
* Counts the Number of Occurrences of Words within the String
* @param someString The String to be counted for
* @param pattern Pattern to be used to split the String
* @since 1.1
public static final WordCount[] countWords(final String someString, final String pattern) {
  StringTokenizer st = new StringTokenizer(someString, pattern);
  HashMap wordCountMap = new HashMap();
  while (st.hasMoreTokens()) {
    String token = st.nextToken();
    if (wordCountMap.containsKey(token)) {
      ((WordCount) wordCountMap.get(token)).increment();
    } else {
      WordCount count = new WordCount(token);
      count.increment();
      wordCountMap.put(token, count);
  Collection values = wordCountMap.values();
  return (WordCount[]) values.toArray(new WordCount[values.size()]);
}Now you can create your own comparator classes to sort the entire array of Word Count Objects. I hope that helps
Regards
Jega