Question

These are all different questions, please answer them separately and label each question

1. Write a static method named conflicts that takes two Maps using Strings as keys and Integers as values. The method should return a Set of Strings. The Set returned by conflicts should be a list of all of the keys that are in conflict between the two Maps. A conflict occurs when two keys point to a different value in the two different maps. (For example, map1 might have the key "Apple" pointing to the Integer 12 and map2 might have the key "Apple"pointing to the Integer 15 - the key "Apple" would need to be added to the Set of conflicts returned by the method).
2. Write a static method named mergeMaps that takes two Maps using Strings as keys and Integers as values. The method should return a Map that uses Strings as keys and Integers as values. If the two maps passed in as parameters have no conflicts, the method should return a new Map that contains everything that is in either Map. If the two maps have a conflict, the method should return a null value. (You may reuse the method conflicts that you wrote for problem 1 for this method if you wish).
3. Write a static method named mergeMapsToMultiMap that takes two Maps using Strings as keys and Integers as values. The method should return a map that uses Strings as keys and has a LinkedList of Integers as a value (aka a MulitMap). The contents of the LinkedList should be the values pointed at by the keys in either input Map. For example, if map1 has the key "Apple" pointing at the Integer 12 and map2 has the key "Apple" pointing to the Integer 15, then the map returned by the method should have the key "Apple" pointing to a LinkedList containing the values [12,15]. (The order that the elements are added to this list does not matter). If a key is in only one Map, then its value should point to a LinkedList containing only that single value.
4. Suppose the following elements were added to a PriorityQueue in this order. In what order would they be removed from the queue? ["baseball", "apple", "mango", "football", "kiwi", "basketball"] (RECALL: How does compareTo() work for String values?)

Answer 1

Please find your answers below and let me know if you have any doubts or if you need anything to change. If you are satisfied with the solution, please rate the answer. If not, PLEASE let me know before you rate, I’ll help you fix whatever issues. Thanks

//method to find the conflicts of two maps

public static Set<String> conflicts(Map<String, Integer> map1,

            Map<String, Integer> map2) {

      // creating a set to store the result

      Set<String> result = new TreeSet<String>();

      // looping through each key in map1

      for (String key : map1.keySet()) {

            // if map2 contains the same key but the value associated with it is

            // different, adding key to result

            if (map2.containsKey(key) && !(map2.get(key).equals(map1.get(key)))) {

                  result.add(key);

            }

      }

      return result;

}

// method to merge two maps

public static Map<String, Integer> mergeMaps(Map<String, Integer> map1,

            Map<String, Integer> map2) {

      // if there are conflicts (at least one), returning null

      if (conflicts(map1, map2).size() > 0) {

            return null;

      } else {

            // otherwise creating a map

            Map<String, Integer> result = new TreeMap<String, Integer>();

            // adding all elements of map1 and map2 unchanged

            result.putAll(map1);

            result.putAll(map2);

            // returning the merged map

            return result;

      }

}

// method to merge two maps into a multimap

public static Map<String, LinkedList<Integer>> mergeMapsToMultiMap(

            Map<String, Integer> map1, Map<String, Integer> map2) {

      // creating a multi map with key=String, value= LinkedList of integers

      Map<String, LinkedList<Integer>> result = new TreeMap<String, LinkedList<Integer>>();

      // looping through each key in map1

      for (String key : map1.keySet()) {

            // creating a linked list, adding the value associated with current

            // key, adding key and list to the multi map

            LinkedList<Integer> list = new LinkedList<Integer>();

            list.add(map1.get(key));

            result.put(key, list);

      }

      // looping through each key in map2

      for (String key : map2.keySet()) {

            // if result already contains the key, adding the value to the

            // linked list associated with given key

            if (result.containsKey(key)) {

                  result.get(key).add(map2.get(key));

            } else {

                  // otherwise creating a linked list, adding the value associated

                  // with current key, adding key and list to the multi map

                  LinkedList<Integer> list = new LinkedList<Integer>();

                  list.add(map2.get(key));

                  result.put(key, list);

            }

      }

      return result;

}

Last question: Suppose the following elements were added to a PriorityQueue in this order. In what order would they be removed from the queue? ["baseball", "apple", "mango", "football", "kiwi", "basketball"]

Answer: The elements will be removed in the order: apple, baseball, basketball, football, kiwi, mango. This is because the PriorityQueue class removes the minimum value stored in it each time the remove method is called. Here minimum value means the lowest value found using compareTo() implementation of the elements. By default, String class implements compareTo method to compare Strings based on the alphabetical (lexicographic) order. So elements will be removed in alphabetical order.