Add TreeMap module (cont'd)

Author: squidmin

src/main/java/collections/treemap/FetchLargestKey.java

@@ -1,2 +1,23 @@
-package collections.treemap;public class FetchLargestKey {
+package collections.treemap;
+
+import java.util.Map.Entry;
+import java.util.TreeMap;
+
+public class FetchLargestKey {
+    public static void main(String[] args) {
+        TreeMap<String, Integer> map = new TreeMap<>();
+        map.put("Oracle", 43);
+        map.put("Microsoft", 56);
+        map.put("Apple", 43);
+        map.put("Novartis", 87);
+
+        // Fetching the first entry in the Map.
+        Entry<String, Integer> firstEntry = map.firstEntry();
+
+        System.out.println("Smallest key: " + firstEntry.getKey() + ", Value: " + firstEntry.getValue());
+
+        // Fetching the last entry in the Map.
+        Entry<String, Integer> lastEntry = map.lastEntry();
+        System.out.println("Largest key: " + lastEntry.getKey() + ", Value: " + lastEntry.getValue());
+    }
 }

src/main/java/collections/treemap/README.md

@@ -77,7 +77,7 @@ public class TreeMapDemo {
         System.out.println("Elements are stored in random order: " + hashMap);
 
         // Creating a TreeMap using existing HashMap. This will store the elements in ascending order.
-        TreeMap<String, Integer> treeMap1 = new HashMap<>(hashMap);
+        TreeMap<String, Integer> treeMap1 = new TreeMap<>(hashMap);
         System.out.println("Elements are stored in ascending order:" + treeMap1);
 
         // Creating a TreeMap using existing TreeMap. This will store the elements in the same order as it was in the passed Map.

src/main/java/collections/treemap/RemoveElement.java

@@ -1,2 +1,17 @@
-package collections.treemap;public class RemoveElement {
+package collections.treemap;
+
+import java.util.TreeMap;
+
+public class RemoveElement {
+    public static void main(String[] args) {
+        TreeMap<String, Integer> map = new TreeMap<>();
+
+        map.put("Oracle", 43);
+        map.put("Microsoft", 56);
+        map.put("Apple", 43);
+        map.put("Novartis", 87);
+
+        System.out.println("Removing Oracle from Map. This will return the value corresponding to Oracle: " + map.remove("Oracle"));
+        System.out.println("Removing Google from Map. This will return null as Google is not present in the Map: " + map.remove("Google"));
+    }
 }

src/main/java/collections/treemap/ReplaceAfterCheckingPreviousValue.java

@@ -1,2 +1,22 @@
-package collections.treemap;public class ReplaceAfterCheckingPreviousValue {
+package collections.treemap;
+
+import java.util.TreeMap;
+
+public class ReplaceAfterCheckingPreviousValue {
+    public static void main(String[] args) {
+        TreeMap<String, Integer> map = new TreeMap<>();
+        map.put("Oracle", 43);
+        map.put("Microsoft", 56);
+        map.put("Apple", 43);
+        map.put("Novartis", 87);
+
+        System.out.println("Replacing the value of Oracle : " + map.replace("Oracle", 67));
+        System.out.println("Latest value of Oracle : " + map.get("Oracle"));
+
+        System.out.println("Replacing the value of Apple only if current value is 50 : " + map.replace("Apple", 50, 90));
+        System.out.println("Latest value of Oracle : " + map.get("Apple"));
+
+        System.out.println("Replacing the value of Apple only if current value is 76 : " + map.replace("Apple", 76, 90));
+        System.out.println("Latest value of Oracle : " + map.get("Apple"));
+    }
 }

src/main/java/collections/treemap/SortByValues.java

@@ -1,2 +1,31 @@
-package collections.treemap;public class SortByValues {
+package collections.treemap;
+
+import java.util.Comparator;
+import java.util.TreeMap;
+
+public class SortByValues {
+    public static TreeMap<String, Integer> sortByValues(TreeMap<String, Integer> map) {
+        Comparator<String> valueComparator = (k1, k2) -> {
+            int comp = map.get(k1).compareTo(map.get(k2));
+            if (comp == 0) { return 1; }
+            else { return comp; }
+        };
+
+        TreeMap<String, Integer> mapSortedByValues = new TreeMap<>(valueComparator);
+
+        mapSortedByValues.putAll(map);
+        return mapSortedByValues;
+    }
+
+    public static void main(String[] args) {
+        TreeMap<String, Integer> map = new TreeMap<>();
+        map.put("Oracle", 43);
+        map.put("Microsoft", 56);
+        map.put("Apple", 76);
+        map.put("Novartis", 87);
+        map.put("Google", 23);
+        map.put("Audi", 101);
+
+        System.out.println(sortByValues(map));
+    }
 }

src/main/java/collections/treemap/SortTreeMap.java

@@ -1,2 +1,22 @@
-package collections.treemap;public class SortTreeMap {
+package collections.treemap;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.TreeMap;
+
+public class SortTreeMap {
+    public static void main(String[] args) {
+        Map<Integer, String> employeeMap = new HashMap<>();
+        employeeMap.put(123, "Alex");
+        employeeMap.put(342, "Ryan");
+        employeeMap.put(143, "Joe");
+        employeeMap.put(234, "Allen");
+        employeeMap.put(432, "Roy");
+
+        System.out.println("Unsorted map " + employeeMap);
+
+        TreeMap<Integer, String> sortedMap = new TreeMap<>();
+        sortedMap.putAll(employeeMap);
+        System.out.println("Sorted map " + sortedMap);
+    }
 }

src/main/java/collections/treemap/SortedMapConstructorDemo.java

@@ -1,2 +1,34 @@
-package collections.treemap;public class SortedMapConstructorDemo {
+package collections.treemap;
+
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.TreeMap;
+
+public class SortedMapConstructorDemo {
+    public static void main(String[] args) {
+        // Creating a TreeMap which will store all the elements in reverse order.
+        TreeMap<String, Integer> reverseMap = new TreeMap<>(Comparator.reverseOrder());
+        reverseMap.put("Oracle", 43);
+        reverseMap.put("Microsoft", 56);
+        reverseMap.put("Apple", 43);
+        reverseMap.put("Novartis", 87);
+        System.out.println("Elements are stored in reverse order: " + reverseMap);
+
+        // Creating a HashMap which will store all the elements in random order.
+        Map<String, Integer> hashMap = new HashMap<>();
+        hashMap.put("Oracle", 43);
+        reverseMap.put("Microsoft", 56);
+        reverseMap.put("Apple", 43);
+        reverseMap.put("Novartis", 87);
+        System.out.println("Elements are stored in random order: " + hashMap);
+
+        // Creating a TreeMap using existing HashMap. This will store the elements in ascending order.
+        TreeMap<String, Integer> treeMap1 = new TreeMap<>(hashMap);
+        System.out.println("Elements are stored in ascending order:" + treeMap1);
+
+        // Creating a TreeMap using existing TreeMap. This will store the elements in the same order as it was in the passed Map.
+        TreeMap<String, Integer> treeMap2 = new TreeMap<>(reverseMap);
+        System.out.println("Elements are stored in descending order: " + treeMap2);
+    }
 }

src/main/java/collections/treemap/TreeMapInsertDemo.java

@@ -1,2 +1,24 @@
-package collections.treemap;public class TreeMapInsertDemo {
+package collections.treemap;
+
+import java.util.TreeMap;
+
+public class TreeMapInsertDemo {
+    public static void main(String[] args) {
+        TreeMap<String, Integer> map = new TreeMap<>();
+
+        map.put("Oracle", 43);
+        map.put("Microsoft", 56);
+        map.put("Apple", 43);
+        map.put("Novartis", 87);
+
+        System.out.println(map);
+
+        TreeMap<String, Integer> finalMap = new TreeMap<>();
+
+        map.put("Google", 65);
+        map.put("Audi", 32);
+        finalMap.putAll(map);
+
+        System.out.println(finalMap);
+    }
 }