Anagrams.java

Below is the syntax highlighted version of Anagrams.java.

/***********************************************************************
  * Donna Gabai, dgabai, P01
  * Practice exam 3 Fall 2012
  * 
  * Anagrams class to maintain a symbol table of anagrams
  * (key is alphabetized string of letters, value is Queue
  * of words entered with those letters)
  * 
  * Dependencies: ST.java, Queue.java, StringSort.java
  * 
  *********************************************************************/

public class Anagrams {
    // instance variables
    private ST<String, Queue<String>> st;  // alphabetized strings and queue
    // for each of their anagrams
    private int keyCount;                  // number of distinct keys
    private int wordCount;                 // number of distinct words
    
    // constructor - does nothing but initialize symbol table
    public Anagrams() {
        st = new ST<String, Queue<String>>();
        keyCount = 0;
        wordCount = 0;
    }
    
    // distinct keys seen
    public int numKeys() {
        return keyCount;
    }
    
    // distinct words seen
    public int numWords() {
        return wordCount;
    }
    
    // add a new word if distinct, create new key if needed
    public void add(String word) {
        // alphabetize string
        String alpha = StringSort.sort(word);
        
        // no key for it yet?
        if (!st.contains(alpha)) {
            Queue<String> wordQ = new Queue<String>();
            wordQ.enqueue(word);
            st.put(alpha, wordQ);
            keyCount++;
            wordCount++;
            return;
        }
        
        // already seen this key
        Queue<String> wordQ = st.get(alpha);
        for (String s : wordQ) {
            // word already seen?  nothing to do
            if (s.equals(word)) return;
        }
        // new word
        wordQ.enqueue(word);
        st.put(alpha, wordQ);
        wordCount++;
    }
    
    // return a set of all anagrams of w that we have seen
    public String[] getAnagrams(String w) {
        // is alphabetized w a key?
        String alpha = StringSort.sort(w);
        if (st.contains(alpha)) {
            Queue<String> wordQ = st.get(alpha);
            int size = wordQ.size();
            // transfer its queue to an array
            String[] a = new String[size];
            int i = 0;
            for (String s : wordQ) {
                a[i] = s;
                i++;
            }
            return a;
        }
        
        // w not a key, return 0-element String array
        String[] a = new String[0];
        return a;
    }
    
    // return a queue of all sets of anagrams with more than n words
    public Queue<String[]> getAnagrams(int n) {
        Queue<String[]> anagramQ = new Queue<String[]>();
        // look for sets > n and put them in the queue.
        for (String alpha : st) {
            String[] wordArray = getAnagrams(alpha);
            if (wordArray.length > n)
                anagramQ.enqueue(wordArray);
        }
        return anagramQ;
    }
    
    // return a queue of all sets of anagrams in our symbol table
    public Queue<String[]> getAnagrams() {
        return getAnagrams(0);
    }
    
    // test main
    public static void main(String[] args) {
        Anagrams tester = new Anagrams();
        tester.add("first");
        tester.add("Frist");
        StdOut.println("How many unique keys: " + tester.numKeys());
        StdOut.println("How many unique words: " + tester.numWords());
    }
}