Java: Collections Exercise 4 - Word Translator (Generics)

Name ____________________________________

For the purposes of this exercise, the only data structures that need to be considered are: array, ArrayList, LinkedList, HashSet, TreeSet, HashMap, and TreeMap. For passing over the elements of a data structure, consider only Iterator and for loop.

Situation: An online dictionary is needed. The user will enter a word and the program will produce a list of "translations". The program begins by reading a file of definitions, which give the different possible translations of a word. For example, a simple text file might have the following structure for showing the English translation of German words.

absatteln=unsattle
Absatz=heel
Absatz=paragraph
Absatz=ledge
Absatz=sales

Problems

1. Declare and initialize a variable, m_dictionary, which will hold each source word (German in the example above) and the collection of translations (English).
2. Write a method, public void AddWord(String word, String definition), which associates the definition with the word. It will add definition to the collection of existing definitions for this word (or create the first entry if there isn't one).
3. Write a method, public Iterator<String> iterator(String word), which returns an iterator over all definitions for the given word. It returns null if there are no definitions.

Answer

  1 
  2 
  3 
  4 
  5 
  6 
  7 
  8 
  9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
 26 
 27 
 28 
 29 
 30 
 31 
 32 
 33 
 34 
 35 
 36 

    Map<String, ArrayList<String>> m_dictionary = new HashMap<String, ArrayList<String>>();
    
    /** Adds a new definition for a word. 
     *  If this is the first time the word is being defined, 
     *     it is entered into a map as the key, and an ArrayList is entered
     *     as the value.
     *  If the word already has a definition, it adds this new definition
     *     to the existing ArrayList of definitions.
     *@param word Word in the dictionary.
     *@param definition A definition for word.
     */
    public void AddWord(String word, String definition) {
        //... Get the existing list of definitions for this word.
        ArrayList<String> defs = m_dictionary.get(word);
        
        //... If there wasn't already an entry for it, create one.
        if (defs == null) {
            defs = new ArrayList<String>();
            m_dictionary.put(word, defs);
        }
        //... Add the target word to the list of target words.
        defs.add(definition);
    }
    
    /** Returns an iterator which will go over the collection of definitions
     *  for the given word.
     *@param word The word whose definitions are being requested.
     *@return An iterator over all defintions associated with <i>word</i>.
     *        If the word is not in the dictionary, null will be returned.
     */
    public Iterator<String> iterator(String word) {
        ArrayList<String> defs = m_dictionary.get(word);
        if (defs == null) return null;
        
        return defs.iterator();
    }

Related Tags for Collections Exercise 4 - Word Translator (Generics):
c,  design,  string,  file,  list,  text,  data,  dictionary,  strings,  diff,  io,  struct,  multiple,  user,  word,  ip,  translation,  structure,  definition,  read,  line,  online,  oo,  simple,  like,  show,  if,  tex,  for,  example,  unc,  english,  program,  to,  ini,  dict,  ram,  reading,  fast,  exam,  store,  pos,  ast,  ssi,  ws,  sh,  words,  ext,  e,  il,  sign,  it,  des,  multi,  not,  li,  init,  use,  ul,  im,  man,  ce,  enter,  in,  no,  rm,  different,  german,  as,  m,  nt,  tr,  os,  os,  ad,  es,  all,  me,  how,  pro,  tor,  xa,  which,  xamp,  uat,  s,  rman,  tip,  ssa,  so,  ee,  gin,  ess,  at,  oss,  k,  is,  ha,  ll,  iv,  note,  mpl,  follow,  ea,  du,  definitions,  and,  ar,  cc,  str,  rds,  sa,  sim,  xt,  tz,  wing,  z,  sla,  s,  s,  ri,  ring,  rd,  ren,  th,  sho,  av,  begin,  st,  access,  ab,  ati,  hat,  fe,  esi,  fin,  esi,  ipl,  ple,  pl,  prod,  pr,  mi,  nd,  on,  om,  ogr,  ol,  o,  nl