Converting Integer-String HashMap to String-Array-Integer HashMap in Java

In Java, we generally use HashMap to store key-value pairs. Sometimes we need to change the structure of the Map as per requirement. One of the common tasks is to convert a HashMap that has Integer as keys and String as values into another HashMap that uses a String as the key and an array of string as the value.

Suppose, we have the following Map:

In the above example both key 1 and key 3 have the same value "Pen". Now, we want to reverse the map so that "Pen" becomes the key and the values of this are the original keys stored as strings in an array. So, the result should look like:

To perform this, we can use a loop to go through the original Map and collect the key for each value and then convert those keys into a string array.

Algorithm

1. Create an empty HashMap<Integer, String> called originalMap.
2. Insert key-value pairs into originalMap, where:
   • The key is an integer.
   • The value is a string containing space-separated words.
3. Create an empty HashMap<List<String>, Integer> called convertedMap.
4. For each entry (key, value) in originalMap, do:
   • Store the key in a variable id.
   • Store the value in a variable.
   • Split the string value by spaces into an array of words.
   • Convert the array to a List<String> called wordList.
5. e. Insert the wordList as key and id as value into convertedMap.
6. 5. Print the contents of convertedMap, where each key is a list of words and each value is the corresponding integer key from originalMap.

Example: Converting Integer String HashMap to String Array Integer HashMap

Output:

Converted HashMap<List<String>, Integer>:
[pen, pencil] => 101
[eraser, sharpener] => 102
[scale] => 103

Explanation

The above Java program converts a HashMap with Integer keys and String values into a new map where the keys are List<String> and the values are integers. It starts by mapping item IDs and their names (as strings).

Then, it loops through each entry, splits the string value into individual words and stores them as a list. This list becomes the key in the new map and the original ID becomes the value. At the end of the program, it prints the new map and shows how each list of words is now linked to its corresponding ID. This helps in organizing data based on word groups instead of plain strings.

Advantages

• Easy Value-Based Grouping: We can find all the keys that share the same value by grouping them together.
• Improved Data Organization: When the values get repeated the new structure makes the data more structured and easier to manage.
• Simplifies Reverse Lookups: The value becomes the main reference point itself so there is no need to search for a specific key map to a specific value.
• Better Readability: It is better to read and analyze by grouping related keys under the same.
• Flexible for Searching: The structure allows easy filtering such as showing all keys linked to a certain word.

Disadvantages

• Increased Complexity: It becomes difficult for the developers to figure out how data is stored and retrieved after converting the new structure string - an Array of Integers becomes harder to understand and maintain.
• Extra Memory Usage: It needs extra spaces for storing values in an array or list than storing a single value. Even if only one integer is linked to a string we still need to wrap it in an array or list which wastes spaces.
• Data Duplication Risk: There is a risk of duplicating the data as multiple integers can map to the same string so there is a chance that duplicates can appear accidentally inside the arrays. It becomes an extra task to maintain the uniqueness of integers.
• Loss of Direct Mapping: Earlier, we can check directly which string belongs to which integer but after conversion firstly we need to find the string key and then check the list of integers which is less built-in.
• Harder Debugging and Maintenance: Debugging is easy in a simple map when an error occurs but with nested structures such as (string -> array -> integers) it becomes difficult and time-consuming to find mistakes.

Conclusion

In reference to the above concept changing an integer-string HashMap into a String-Array-Integer HashMap are very helpful when we need to group all the keys that have the same value. When the same value appears many times it helps in reversing lookups and makes the data more organized.

Also, this conversion brings some problems such as uses of extra memory, slower performance and more complexity. The original HashMap is the better choice if we need a one-to-one mapping. But it is important when we group the values the converted structure works well and makes the data easy to manage and analyze.