1. Introduction
Handling key-value-based data is a common requirement in various Java applications. Often, data arrives as Strings or String arrays, and it becomes essential to convert them into Maps for efficient processing. In the same context, Maps provide an easy way to access and manipulate data with key-value pairs, making them a powerful data structure for such scenarios.
In this article, we’ll explore different techniques to convert Strings and String arrays into Maps. We’ll also discuss how to handle duplicate keys when converting String arrays to Maps with Lists of values. Additionally, to ensure the correctness of our implementations.
2. Converting a String to Map
When we have a String with key-value pairs, we can convert it into a Map. The key-value pairs in the String must be separated by a delimiter, which could be any character, such as a comma, semicolon, or an equal sign.
Let’s see the following example:
public Map<String, String> convertStringToMap(String data) {
Map<String, String> map = new HashMap<>();
StringTokenizer tokenizer = new StringTokenizer(data, " ");
while (tokenizer.hasMoreTokens()) {
String token = tokenizer.nextToken();
String[] keyValue = token.split("=");
map.put(keyValue[0], keyValue[1]);
}
return map;
}
In this method, we use StringTokenizer() to split the String by the delimiter (comma in this case) and then use split(“=”) to extract the key and value. The resulting key-value pairs are added to the Map. Note that we trim the tokens to remove any leading or trailing whitespace.
Now, we’ll test the convertStringToMap() method, which takes a String containing key-value pairs and converts it into a Map as follows:
@Test
public void given_StringWithKeyValuePairs_whenUsing_convertStringToMap_thenMapCreated() {
String data = "name=John age=30 city=NewYork";
Map<String, String> expectedMap = new HashMap<>();
expectedMap.put("name", "John");
expectedMap.put("age", "30");
expectedMap.put("city", "NewYork");
Map<String, String> resultMap = convertStringToMap(data);
assertEquals(expectedMap, resultMap);
}
This test method first defines a sample input data, which is a space-separated string with key-value pairs. It then creates an expectedMap that represents the expected output after conversion.
The test proceeds by calling the convertStringToMap(data) method to obtain the actual result in the resultMap. Finally, the assertEquals() method compares the expectedMap with the resultMap to ensure that the conversion is performed correctly and the output Map matches the expected one.
3. Converting an Array String to Map
If we have an array of Strings, where each element represents a key-value pair, we can convert it into a Map:
public Map<String, String> convertStringArrayToMap(String[] data) {
Map<String, String> map = new HashMap<>();
for (String keyValue : data) {
String[] parts = keyValue.split("=");
map.put(parts[0], parts[1]);
}
return map;
}
In this method, we iterate through the String array and split each element into key and value. Next, the resulting key-value pairs are added to the Map.
The following test method is used to validate the convertStringArrayToMap() method:
@Test
public void given_StringArrayWithKeyValuePairs_whenUsing_convertStringArrayToMap_thenMapCreated() {
String[] data = {"name=John", "age=30", "city=NewYork"};
Map<String, String> expectedMap = new HashMap<>();
expectedMap.put("name", "John");
expectedMap.put("age", "30");
expectedMap.put("city", "NewYork");
Map<String, String> resultMap = convertStringArrayToMap(data);
assertEquals(expectedMap, resultMap);
}
The test method prepares a sample input by creating an array of Strings containing key-value pairs. Then, it generates an expectedMap to represent the desired output after the conversion.
Additionally, it calls the convertStringArrayToMap(data) method to get the actual result stored in the resultMap. Finally, the test uses assertEquals() to ensure that the conversion is correct and that the output Map matches the expected one.
4. Handling Duplicate Keys
In some cases, the String array may contain duplicate keys, and we might need to store multiple values associated with each key in the Map. To achieve this, we can use a Map with Lists of values as follows:
public Map<String, List<String>> convertStringArrayToMapWithDuplicates(String[] data) {
Map<String, List<String>> map = new HashMap<>();
for (String keyValue : data) {
String[] parts = keyValue.split("=");
String key = parts[0];
String value = parts[1];
if (map.containsKey(key)) {
List<String> valuesList = map.get(key);
valuesList.add(value);
} else {
List<String> valuesList = new ArrayList<>();
valuesList.add(value);
map.put(key, valuesList);
}
}
return map;
}
In this method, we check if the key already exists in the Map. If it does, we retrieve the existing List of values and append the new value to it. Otherwise, we create a new entry in the Map with a new List containing the value.
The following test method is designed to test the convertStringArrayToMapWithDuplicates():
@Test
public void given_StringArrayWithKeyValuePairsWithDuplicates_whenUsing_convertStringArrayToMapWithDuplicates_thenMapCreatedWithLists() {
String[] data = {"name=John", "age=30", "city=NewYork", "age=31"};
Map<String, List<String>> expectedMap = new HashMap<>();
expectedMap.put("name", Collections.singletonList("John"));
expectedMap.put("age", Arrays.asList("30", "31"));
expectedMap.put("city", Collections.singletonList("NewYork"));
Map<String, List<String>> resultMap = convertStringArrayToMapWithDuplicates(data);
assertEquals(expectedMap, resultMap);
}
The test method defines a sample input data, which contains some duplicate keys. It then creates an expectedMap that represents the expected output after conversion. The expectedMap includes Lists of values for keys duplicated in the input data.
The test proceeds by calling the convertStringArrayToMapWithDuplicates(data) method to obtain the actual result in the resultMap. Finally, the assertEquals() method is used to compare the expectedMap with the resultMap to ensure that the conversion is performed correctly and that the output Map with Lists of values matches the expected one.
5. Conclusion
In this article, we have explored different techniques for converting Strings and String arrays into Maps in Java. We covered basic conversions, handling duplicate keys, and provided JUnit test examples to ensure the correctness of the implementations.
By understanding these conversion techniques, we can efficiently process key-value-based data in our Java applications. Remember to consider the specific requirements of our project and choose the appropriate conversion method accordingly.
As always, the complete code samples for this article can be found over on GitHub.
