Question

Can someone help me with this code, I not really understanding how to do this?

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

/**
* @version Spring 2019
* @author Kyle
*/
public class MapProblems {

/**
* Modify and return the given map as follows: if the key "a" has a value, set the key "b" to
* have that value, and set the key "a" to have the value "". Basically "b" is confiscating the
* value and replacing it with the empty string.
*
* @param map to be edited
* @return map
*/
public Map<String, String> confiscate(Map<String, String> map) {
if (map.containsKey("a") && map.containsValue("a")) {

}
}

/**
* Modify and return the given map as follows: if the key "duck" has a value, set the key
* "goose" to have that same value. In all cases remove the key "swan", the rest of the map
* should not change.
*
* @param map to be edited
* @return map
*/
public Map<String, String> mapBird1(Map<String, String> map) {
throw new UnsupportedOperationException("Not supported yet");
}

/**
* Given a map of bird keys and topping values, modify and return the map as follows: if the key
* "turkey" has a value, set that as the value for the key "chicken". If the key "vulture" has a
* value, set that as the value for the key "buzzard".
*
* @param map to be edited
* @return map
*/
public Map<String, String> mapBird2(Map<String, String> map) {
throw new UnsupportedOperationException("Not supported yet");
}

/**
* Given an array of strings, return a Map<String, Integer> with a key for each different
* string, with the value the number of times that string appears in the array.
*
* @param strings array
* @return map
*/
public Map<String, Integer> wordCount(ArrayList<String> strings) {
throw new UnsupportedOperationException("Not supported yet");
}

/**
* Given an ArrayList of Strings, create a new map that creates a key for each String by
* multiplying it's length by 7. If a key is already being used do not add the new value.
*
* @param str ArrayList of Strings
* @return new Map
*/
public Map<Integer, String> intMap(ArrayList<String> str) {
throw new UnsupportedOperationException("Not supported yet");
}

/**
* Caiomhe has tons of Student Records that need to be organized. She wants you to put all these
* Records into a Map. The StudentRecord class already has a hashCode method that should be used
* to create keys. Store all the StudentRecord objects in a new map and then return it.
*
* @param students ArrayList of StudentRecord objects
* @return map
*/
public Map<Integer, StudentRecord> recordMap(ArrayList<StudentRecord> students) {
throw new UnsupportedOperationException("Not supported yet");
}
}

Answer 1

Map:

Map is a collection in java where it contains (key, value) pairs.

Few methods of Map used in the code:

1. get: Get method returns a value corresponding to a key in the map. If no entry exists with the provided key, it returns null. Example: Assume a map with <String, Integer> key, value pairs. To get value of key "a" in a map, then map.get("a") returns the Integer corresponding to "a" or returns null if no entry exists in map with key "a"
2. put: Put method sets a value to a key. If key does not exist in map previously then it creates a new entry with key and value provided, If the map contains an entry for key then the value corresponding to key will be updated. Example: Assume a map with <String, Integer> key, value pairs. Then map.put("a", 1), creates a new entry if the map as it do not contain any value for "a", updates the value of "a" if map already contains some integer corresponding to "a"
3. containsKey: ContainsKey method returns true if the map contains the key, or else returns false.
4. containsValue: ContainsValue checks whether the value provided is mapped to one or more keys. Returns true if already mapped to one or more keys, else returns false.
5. remove: map.remove("a") removes any entry corresponding to the key "a".

Program:

Note: Program is explained using comments in the code.

import java.util.ArrayList; import java.util.HashMap; import java.util.Map; public class MapProblems { /** * Modify and return the given map as follows: if the key "a" has a value, set the key "b" to * have that value, and set the key "a" to have the value "". Basically "b" is confiscating the * value and replacing it with the empty string. * @param map to be edited * @return map public Map<String, String> confiscate(Map<String, String> map) { // First find whether map conatins key "a" // Then the second condition is to verify that the value corresponding to "a" // is not null. // Assuming the statement if the key "a" has a value means key "a" has some value (not null) if (map.containsKey("a") && map.get("a") != null) {/ // b confiscating value of a map.put("b", map.get("a")); // updating value of a to" map.put("a", ""); return map; /** * Modify and return the given map as follows: if the key "duck" has a value, set the key * "goose" to have that same value. In all cases remove the key "swan", the rest of the map * should not change. * @param map to be edited * @return map public Map<String, String> mapBird1(Map<String, String> map) {

// Check if map contains a value for duck if(map.containsKey("duck") && map.get("duck") != null) { // Copy the value of duck to goose map.put("goose", map.get("duck")); // Remove the key swan map.remove("swan"); return map; * Given a map of bird keys and topping values, modify and return the map as follows: if the key * "turkey" has a value, set that as the value for the key "chicken". If the key "vulture" has a * value, set that as the value for the key "buzzard". * @param map to be edited * @return map */ public Map<String, String> mapBird2(Map<String, String> map) { //Check if turkey has a value if(map.containskey("turkey") && map.get("turkey") != null) { // set the value of turkey for chicken map.put("chicken", map.get("turkey")); // check if vulture has a value in map if(map.containsKey("vulture") && map.get("vulture") != null) { // set the value of vulture to buzzard map.put("buzzard", map.get("vulture")); return map; * Given an array of strings, return a Map<String, Integer> with a key for each different * string, with the value the number of times that string appears in the array. @param strings array

* @return map * public Map<String, Integer> wordcount(ArrayList<String> strings) { //create a new hash map to store the count of each word HashMap<String, Integer> map = new HashMap<>(); //iterate over the list using a for-each loop for(String key : strings) { //get the value for key Integer count = map.get(key); //if count is null then set count to o as key is not present in the map if(count == null) count = 0; // put the value of key as count+1 map.put(key, count+1); return map; * Given an ArrayList of Strings, create a new map that creates a key for each string by * multiplying it's length by 7. If a key is already being used do not add the new value. * @param str ArrayList of Strings * @return new Map public Map<Integer, String> intMap(ArrayList<String> str) { //Create a hash map to store the specified map above HashMap<Integer, String> map = new HashMap<>(); //iterate over the list using for each loop for(String string : str) { //Check if the map contains 7 times length of stirng as key // If key is not present set the string as value to key // skip if 7 times lenght is already present in the map as key

if(!map.containskey(7 * string.length()) { map.put(7 * string. length(), string); return map; * Caiomhe has tons of Student Records that need to be organized. She wants you to put all these * Records into a Map. The StudentRecord class already has a hashCode method that should be used * to create keys. Store all the studentRecord objects in a new map and then return it. * @param students ArrayList of StudentRecord objects * @return map public Map<Integer, StudentRecord> recordMap(ArrayList<StudentRecord students) { //Create a map to store hashCode StudentRecord mapping HashMap<Integer, StudentRecord> map = new HashMap<>(); //Iterate over StudentRecord list for(StudentRecord studentRecord : students) { //Add entry for each studentRecord to map with hashCode as key map.put(studentRecord.hashCode(), studentRecord); return map; //Main method public static void main(String[] ar) { MapProblems mapProblems = new MapProblems(); //test confiscate Map<String, String> map = new HashMap<>(); map.put("a", "Hello"); System.out.println("Before confiscate: "+ map; map = mapProblems.confiscate (map); System.out.println("After confiscate: "# map);

//test mapBird1 map = new HashMap<>(); map.put("duck", "I am a duck"); map.put("swan", "I will get killed"); System.out.println("\nBefore mapBirdi: "+ map); map = mapProblems.mapBird1(map); System.out.println("After mapBirdi: "+ map); //test mapBird2 map = new HashMap<>(); map.put("turkey", "This is a turkey"); map.put("vulture", "I will get killed"); System.out.println("\nBefore mapBird2: "+ map); map = mapProblems.mapBirdz (map); System.out.println("After mapBird2: "+ map); //test wordcount ArrayList<String> words = new ArrayList<String>(); words.add("Apple"); words.add("Ball"); words.add("Cat"); words.add("Apple"); words.add("Ball"); words.add("Apple"); words.add("Ball"); words.add("Ball"); words.add("Cat"); Map<String, Integer> wordCountsMap = mapProblems.wordCount(words); System.out.println("\nWord counts: "+ wordCountsMap); //test intMap words = new ArrayList<String>(); words.add("Apple"); words.add("Ball"); words.add("Cat"); Map<Integer, String> intMapoutput = mapProblems. intMap(words); System.out.println("\nInt map method output: " + intMapoutput);

//Unable to test recordMap method as StudentRecord definition is not provided

Code:

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

public class MapProblems {

   /**
   * Modify and return the given map as follows: if the key "a" has a value, set the key "b" to
   * have that value, and set the key "a" to have the value "". Basically "b" is confiscating the
   * value and replacing it with the empty string.
   *
   * @param map to be edited
   * @return map
   */
   public Map<String, String> confiscate(Map<String, String> map) {
       // First find whether map conatins key "a"
       // Then the second condition is to verify that the value corresponding to "a"
       // is not null.
       // Assuming the statement if the key "a" has a value means key "a" has some value(not null)
       if (map.containsKey("a") && map.get("a") != null) {
           // b confiscating value of a
           map.put("b", map.get("a"));
           // updating value of a to ""
           map.put("a", "");
       }
       return map;
   }

   /**
   * Modify and return the given map as follows: if the key "duck" has a value, set the key
   * "goose" to have that same value. In all cases remove the key "swan", the rest of the map
   * should not change.
   *
   * @param map to be edited
   * @return map
   */
   public Map<String, String> mapBird1(Map<String, String> map) {
       // Check if map contains a value for duck
       if(map.containsKey("duck") && map.get("duck") != null){
           // Copy the value of duck to goose
           map.put("goose", map.get("duck"));
       }
       // Remove the key swan
       map.remove("swan");
       return map;
   }

   /**
   * Given a map of bird keys and topping values, modify and return the map as follows: if the key
   * "turkey" has a value, set that as the value for the key "chicken". If the key "vulture" has a
   * value, set that as the value for the key "buzzard".
   *
   * @param map to be edited
   * @return map
   */
   public Map<String, String> mapBird2(Map<String, String> map) {
       //Check if turkey has a value
       if(map.containsKey("turkey") && map.get("turkey") != null){
           // set the value of turkey for chicken
           map.put("chicken", map.get("turkey"));
       }
       // check if vulture has a value in map
       if(map.containsKey("vulture") && map.get("vulture") != null){
           // set the value of vulture to buzzard
           map.put("buzzard", map.get("vulture"));
       }
       return map;
   }

   /**
   * Given an array of strings, return a Map<String, Integer> with a key for each different
   * string, with the value the number of times that string appears in the array.
   *
   * @param strings array
   * @return map
   */
   public Map<String, Integer> wordCount(ArrayList<String> strings) {
       //create a new hash map to store the count of each word
       HashMap<String, Integer> map = new HashMap<>();
      
       //iterate over the list using a for-each loop
       for(String key : strings){
           //get the value for key
           Integer count = map.get(key);
          
           //if count is null then set count to 0 as key is not present in the map
           if(count == null)
               count = 0;
              
           // put the value of key as count+1
           map.put(key, count+1);
       }
       return map;
   }

   /**
   * Given an ArrayList of Strings, create a new map that creates a key for each String by
   * multiplying it's length by 7. If a key is already being used do not add the new value.
   *
   * @param str ArrayList of Strings
   * @return new Map
   */
   public Map<Integer, String> intMap(ArrayList<String> str) {
       //Create a hash map to store the specified map above
       HashMap<Integer, String> map = new HashMap<>();
      
       //iterate over the list using for-each loop
       for(String string : str){
           //Check if the map contains 7 times length of stirng as key
           // If key is not present set the string as value to key
           // Skip if 7 times lenght is already present in the map as key
           if(!map.containsKey(7 * string.length())){
               map.put(7 * string.length(), string);
           }
       }
       return map;
   }

   /**
   * Caiomhe has tons of Student Records that need to be organized. She wants you to put all these
   * Records into a Map. The StudentRecord class already has a hashCode method that should be used
   * to create keys. Store all the StudentRecord objects in a new map and then return it.
   *
   * @param students ArrayList of StudentRecord objects
   * @return map
   */
   public Map<Integer, StudentRecord> recordMap(ArrayList<StudentRecord> students) {
       //Create a map to store hashCode StudentRecord mapping
       HashMap<Integer, StudentRecord> map = new HashMap<>();
      
       //Iterate over StudentRecord list
       for(StudentRecord studentRecord : students){
           //Add entry for each studentRecord to map with hashCode as key
           map.put(studentRecord.hashCode(), studentRecord);
       }
       return map;
   }
  
   //Main method
   public static void main(String[] ar){
       MapProblems mapProblems = new MapProblems();
      
       //test confiscate
       Map<String, String> map = new HashMap<>();
       map.put("a", "Hello");
       System.out.println("Before confiscate: "+ map);
       map = mapProblems.confiscate(map);
       System.out.println("After confiscate: "+ map);
      
       //test mapBird1
       map = new HashMap<>();
       map.put("duck", "I am a duck");
       map.put("swan", "I will get killed");
       System.out.println("\nBefore mapBird1: "+ map);
       map = mapProblems.mapBird1(map);
       System.out.println("After mapBird1: "+ map);
      
       //test mapBird2
       map = new HashMap<>();
       map.put("turkey", "This is a turkey");
       map.put("vulture", "I will get killed");
       System.out.println("\nBefore mapBird2: "+ map);
       map = mapProblems.mapBird2(map);
       System.out.println("After mapBird2: "+ map);
      
       //test wordCount
       ArrayList<String> words = new ArrayList<String>();
       words.add("Apple");
       words.add("Ball");
       words.add("Cat");
       words.add("Apple");
       words.add("Ball");
       words.add("Apple");
       words.add("Ball");
       words.add("Ball");
       words.add("Cat");
       Map<String, Integer> wordCountsMap = mapProblems.wordCount(words);
       System.out.println("\nWord Counts: "+ wordCountsMap);
      
       //test intMap
       words = new ArrayList<String>();
       words.add("Apple");
       words.add("Ball");
       words.add("Cat");
       Map<Integer, String> intMapOutput = mapProblems.intMap(words);
       System.out.println("\nInt map method output: "+ intMapOutput);
      
       //Unable to test recordMap method as StudentRecord definition is not provided
   }
}

Output:

Added a main method in the above code to test the methods in MapProblems class.

File Edit View Search Terminal Help Before confiscate: {a=Hello} After confiscate: {a=, b=Hello} Before mapBirdl: {duck=I am a duck, swan=I will get killed} After mapBird1: {duck=I am a duck, goose=I am a duck} Before mapBird2: {turkey=This is a turkey, vulture I will get killed} After mapBird2: {chicken=This is a turkey, turkey=This is a turkey, buzzard=I will get killed, vulture=1 will get killed} Word Counts: {Ball=4, Apple=3, Cat=2} Int map method output: {35=Apple, 21=Cat, 28=Ball}, '(program exited with code: 0 Press return to continue

import java.util.ArrayList; import java.util.HashMap; import java.util.Map; public class MapProblems { /** * Modify and return the given map as follows: if the key "a" has a value, set the key "b" to * have that value, and set the key "a" to have the value "". Basically "b" is confiscating the * value and replacing it with the empty string. * @param map to be edited * @return map public Map<String, String> confiscate(Map<String, String> map) { // First find whether map conatins key "a" // Then the second condition is to verify that the value corresponding to "a" // is not null. // Assuming the statement if the key "a" has a value means key "a" has some value (not null) if (map.containsKey("a") && map.get("a") != null) {/ // b confiscating value of a map.put("b", map.get("a")); // updating value of a to" map.put("a", ""); return map; /** * Modify and return the given map as follows: if the key "duck" has a value, set the key * "goose" to have that same value. In all cases remove the key "swan", the rest of the map * should not change. * @param map to be edited * @return map public Map<String, String> mapBird1(Map<String, String> map) {

We were unable to transcribe this image

* @return map * public Map<String, Integer> wordcount(ArrayList<String> strings) { //create a new hash map to store the count of each word HashMap<String, Integer> map = new HashMap<>(); //iterate over the list using a for-each loop for(String key : strings) { //get the value for key Integer count = map.get(key); //if count is null then set count to o as key is not present in the map if(count == null) count = 0; // put the value of key as count+1 map.put(key, count+1); return map; * Given an ArrayList of Strings, create a new map that creates a key for each string by * multiplying it's length by 7. If a key is already being used do not add the new value. * @param str ArrayList of Strings * @return new Map public Map<Integer, String> intMap(ArrayList<String> str) { //Create a hash map to store the specified map above HashMap<Integer, String> map = new HashMap<>(); //iterate over the list using for each loop for(String string : str) { //Check if the map contains 7 times length of stirng as key // If key is not present set the string as value to key // skip if 7 times lenght is already present in the map as key

if(!map.containskey(7 * string.length()) { map.put(7 * string. length(), string); return map; * Caiomhe has tons of Student Records that need to be organized. She wants you to put all these * Records into a Map. The StudentRecord class already has a hashCode method that should be used * to create keys. Store all the studentRecord objects in a new map and then return it. * @param students ArrayList of StudentRecord objects * @return map public Map<Integer, StudentRecord> recordMap(ArrayList<StudentRecord students) { //Create a map to store hashCode StudentRecord mapping HashMap<Integer, StudentRecord> map = new HashMap<>(); //Iterate over StudentRecord list for(StudentRecord studentRecord : students) { //Add entry for each studentRecord to map with hashCode as key map.put(studentRecord.hashCode(), studentRecord); return map; //Main method public static void main(String[] ar) { MapProblems mapProblems = new MapProblems(); //test confiscate Map<String, String> map = new HashMap<>(); map.put("a", "Hello"); System.out.println("Before confiscate: "+ map; map = mapProblems.confiscate (map); System.out.println("After confiscate: "# map);

//test mapBird1 map = new HashMap<>(); map.put("duck", "I am a duck"); map.put("swan", "I will get killed"); System.out.println("\nBefore mapBirdi: "+ map); map = mapProblems.mapBird1(map); System.out.println("After mapBirdi: "+ map); //test mapBird2 map = new HashMap<>(); map.put("turkey", "This is a turkey"); map.put("vulture", "I will get killed"); System.out.println("\nBefore mapBird2: "+ map); map = mapProblems.mapBirdz (map); System.out.println("After mapBird2: "+ map); //test wordcount ArrayList<String> words = new ArrayList<String>(); words.add("Apple"); words.add("Ball"); words.add("Cat"); words.add("Apple"); words.add("Ball"); words.add("Apple"); words.add("Ball"); words.add("Ball"); words.add("Cat"); Map<String, Integer> wordCountsMap = mapProblems.wordCount(words); System.out.println("\nWord counts: "+ wordCountsMap); //test intMap words = new ArrayList<String>(); words.add("Apple"); words.add("Ball"); words.add("Cat"); Map<Integer, String> intMapoutput = mapProblems. intMap(words); System.out.println("\nInt map method output: " + intMapoutput);

//Unable to test recordMap method as StudentRecord definition is not provided

We were unable to transcribe this image

We were unable to transcribe this image

We were unable to transcribe this image

We were unable to transcribe this image

if(!map.containskey(7 * string.length()) { map.put(7 * string. length(), string); return map; * Caiomhe has tons of Student Records that need to be organized. She wants you to put all these * Records into a Map. The StudentRecord class already has a hashCode method that should be used * to create keys. Store all the studentRecord objects in a new map and then return it. * @param students ArrayList of StudentRecord objects * @return map public Map<Integer, StudentRecord> recordMap(ArrayList<StudentRecord students) { //Create a map to store hashCode StudentRecord mapping HashMap<Integer, StudentRecord> map = new HashMap<>(); //Iterate over StudentRecord list for(StudentRecord studentRecord : students) { //Add entry for each studentRecord to map with hashCode as key map.put(studentRecord.hashCode(), studentRecord); return map; //Main method public static void main(String[] ar) { MapProblems mapProblems = new MapProblems(); //test confiscate Map<String, String> map = new HashMap<>(); map.put("a", "Hello"); System.out.println("Before confiscate: "+ map; map = mapProblems.confiscate (map); System.out.println("After confiscate: "# map);

We were unable to transcribe this image

//Unable to test recordMap method as StudentRecord definition is not provided

File Edit View Search Terminal Help Before confiscate: {a=Hello} After confiscate: {a=, b=Hello} Before mapBirdl: {duck=I am a duck, swan=I will get killed} After mapBird1: {duck=I am a duck, goose=I am a duck} Before mapBird2: {turkey=This is a turkey, vulture I will get killed} After mapBird2: {chicken=This is a turkey, turkey=This is a turkey, buzzard=I will get killed, vulture=1 will get killed} Word Counts: {Ball=4, Apple=3, Cat=2} Int map method output: {35=Apple, 21=Cat, 28=Ball}, '(program exited with code: 0 Press return to continue