Question

Answer the following Java Collection/Map Question:

The antonym map is a map that associating a word (the key) to its antonym. Suppose the antonym map wasn't necessarily symmetric: it might have an entry that maps the key "short" to "tall", but not have an entry that maps the key "tall" to "short": there is no key "tall" in the map. Yet, the antonym relationship certainly is symmetic: if the opposite of "short" is "tall", the opposite of "tall" is "short". Write a code fragment that attempts to find the antonym directly in this map by using it as a key, but if it is not there, attempts to find it as a value, then add it back as a key for a new entry.

For sake of simplicity, we suppose that each word has only one antonym.

Example of an antonym map                             

Big --> Small
Alive --> Dead
Clever --> Stupid

“Stupid” is the value associated to the key “Clever”, the antonym of “Clever”. To retrieve the antonym of “Stupid” which it doesn’t exist in the map, you should add it as a key and the original key becomes the value.                                   

Big --> Small
Alive --> Dead
Clever --> Stupid
Stupid --> Clever

Answer 1

PFB requested code with appropriate comments:

=================

import java.util.concurrent.ConcurrentHashMap;
import java.util.Iterator;
import java.util.Map;

public class Main
{
// Map to store antonyms
static Map<String, String> antonymMap;
   public static void main(String[] args) {
   antonymMap = new ConcurrentHashMap<String, String>();
       loadMap();
       findAntonym("Stupid");
   }
  
   // Loads the antonymMap with antonyms
   public static Map<String, String> loadMap() {
       antonymMap.put("Big", "Small");
       antonymMap.put("Alive", "Dead");
       antonymMap.put("Clever", "Stupid");
       return antonymMap;
   }
  
   // finds the antonym of the word provided
   public static void findAntonym(String str) {
   // check if given word is a key in the map
   if (antonymMap.containsKey(str)) {
   System.out.println("Antomym of " + str + " is " + antonymMap.get(str));
   }
   // check if given word is a value in the map
   else if (antonymMap.containsValue(str)) {
   Iterator<Map.Entry<String, String>> iterator = antonymMap.entrySet().iterator();
   // iterate over the map and get the key for which value is the word we are looking for
while (iterator.hasNext())
{
Map.Entry<String, String> entry = iterator.next();
if (str.equals(entry.getValue())) {
   System.out.println("Antomym of " + str + " is : " + entry.getKey());
   antonymMap.put(str, entry.getKey());
   System.out.println("updated antonym map :: " + antonymMap);
   break;
   }
}
   } else {
   System.out.println("Antonym of " + str + " is not found in the map");
   }
   }
}