Merge pull request #11799 from palani-a/BAEL-5348

BAEL-5348: Invert a Map in Java + tests

java-collections-maps-3/src/main/java/com/baeldung/map/invert/InvertHashMapExample.java

@@ -0,0 +1,59 @@
+package com.baeldung.map.invert;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.stream.Collectors;
+
+public class InvertHashMapExample {
+
+    public static void main(String[] args) {
+
+        Map<String, Integer> map = new HashMap<>();
+        map.put("first", 1);
+        map.put("second", 2);
+        System.out.println(map);
+
+        invertMapUsingForLoop(map);
+        invertMapUsingStreams(map);
+        invertMapUsingMapper(map);
+
+        map.put("two", 2);
+        invertMapUsingGroupingBy(map);
+    }
+
+    public static <V, K> Map<V, K> invertMapUsingForLoop(Map<K, V> map) {
+        Map<V, K> inversedMap = new HashMap<V, K>();
+        for (Entry<K, V> entry : map.entrySet()) {
+            inversedMap.put(entry.getValue(), entry.getKey());
+        }
+        System.out.println(inversedMap);
+        return inversedMap;
+    }
+
+    public static <V, K> Map<V, K> invertMapUsingStreams(Map<K, V> map) {
+        Map<V, K> inversedMap = map.entrySet()
+            .stream()
+            .collect(Collectors.toMap(Entry::getValue, Entry::getKey));
+        System.out.println(inversedMap);
+        return inversedMap;
+    }
+
+    public static <K, V> Map<V, K> invertMapUsingMapper(Map<K, V> sourceMap) {
+        Map<V, K> inversedMap = sourceMap.entrySet()
+            .stream()
+            .collect(Collectors.toMap(Entry::getValue, Entry::getKey, (oldValue, newValue) -> oldValue));
+        System.out.println(inversedMap);
+        return inversedMap;
+    }
+
+    public static <V, K> Map<V, List<K>> invertMapUsingGroupingBy(Map<K, V> map) {
+        Map<V, List<K>> inversedMap = map.entrySet()
+            .stream()
+            .collect(Collectors.groupingBy(Map.Entry::getValue, Collectors.mapping(Map.Entry::getKey, Collectors.toList())));
+        System.out.println(inversedMap);
+        return inversedMap;
+    }
+
+}

java-collections-maps-3/src/test/java/com/baeldung/map/invert/InvertHashMapUnitTest.java

@@ -0,0 +1,72 @@
+package com.baeldung.map.invert;
+
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+public class InvertHashMapUnitTest {
+
+    Map<String, Integer> sourceMap;
+
+    @BeforeEach
+    void setup() {
+        sourceMap = new HashMap<>();
+        sourceMap.put("Sunday", 0);
+        sourceMap.put("Monday", 1);
+        sourceMap.put("Tuesday", 2);
+        sourceMap.put("Wednesday", 3);
+        sourceMap.put("Thursday", 4);
+        sourceMap.put("Friday", 5);
+        sourceMap.put("Saturday", 6);
+    }
+
+    @Test
+    void givenSourceMap_whenUsingForLoop_returnsInvertedMap() {
+        Map<Integer, String> inversedMap = InvertHashMapExample.invertMapUsingForLoop(sourceMap);
+        
+        assertNotNull(inversedMap);
+        assertEquals(sourceMap.size(), inversedMap.size());
+        assertEquals("Monday", inversedMap.get(1));
+    }
+
+    @Test
+    void givenSourceMap_whenUsingStreams_returnsInvertedMap() {
+        Map<Integer, String> inversedMap = InvertHashMapExample.invertMapUsingStreams(sourceMap);
+        
+        assertNotNull(inversedMap);
+        assertEquals(sourceMap.size(), inversedMap.size());
+        assertEquals("Monday", inversedMap.get(1));
+    }
+
+    @Test
+    void givenSourceMap_whenUsingMapper_returnsInvertedMap() {
+        Map<Integer, String> inversedMap = InvertHashMapExample.invertMapUsingMapper(sourceMap);
+        
+        assertNotNull(inversedMap);
+        assertEquals(sourceMap.size(), inversedMap.size());
+        assertEquals("Monday", inversedMap.get(1));
+    }
+
+    @Test
+    void givenSourceMapWithDuplicateValues_whenUsingGroupBy_returnsInvertedMap() {
+        sourceMap.put("MONDAY", 1);
+        Map<Integer, List<String>> inversedMap = InvertHashMapExample.invertMapUsingGroupingBy(sourceMap);
+        
+        assertNotNull(inversedMap);
+        assertNotEquals(sourceMap.size(), inversedMap.size()); // duplicate keys are merged now
+        assertEquals(2, inversedMap.get(1).size());
+        assertTrue(inversedMap.get(1).contains("Monday"));
+        assertTrue(inversedMap.get(1).contains("MONDAY"));
+    }
+
+}