LinkedList and LinkedHashMap

Rajeev Kumar Singh · Rajeev Kumar Singh · commit d6cd8808be53 · 2018-04-27T10:53:40.000+05:30
diff --git a/Readme.md b/Readme.md
@@ -2,10 +2,14 @@
 
 1. [Java ArrayList Tutorial with Examples](https://www.callicoder.com/java-arraylist/)
 
-2. [Java HashMap Tutorial with Examples](https://www.callicoder.com/java-hashmap/)
+2. [Java LinkedList Tutorial with Examples](https://www.callicoder.com/java-linkedlist/)
 
-3. [Java HashSet Tutorial with Examples](https://www.callicoder.com/java-hashset/)
+3. [Java HashMap Tutorial with Examples](https://www.callicoder.com/java-hashmap/)
 
-4. [Java TreeMap Tutorial with Examples](https://www.callicoder.com/java-treemap/)
+4. [Java LinkedHashMap Tutorial with Examples](https://www.callicoder.com/java-linkedhashmap/)
 
-5. [Java TreeSet Tutorial with Examples](https://www.callicoder.com/java-treeset/)
+5. [Java TreeMap Tutorial with Examples](https://www.callicoder.com/java-treemap/)
+
+6. [Java HashSet Tutorial with Examples](https://www.callicoder.com/java-hashset/)
+
+7. [Java TreeSet Tutorial with Examples](https://www.callicoder.com/java-treeset/)
diff --git a/java-arraylist-examples/src/ArrayListSortExample.java b/java-arraylist-examples/src/ArrayListSortExample.java
@@ -20,7 +20,7 @@ public int compare(String name1, String name2) {
             }
         });
 
-        // The above `sort()` method call can also be written simply using lambda expressions
+        // The above `sort()` method call can also be written simply using lambda expression
         names.sort((name1, name2) -> name1.compareTo(name2));
 
         // Following is an even more concise solution
diff --git a/java-arraylist-examples/src/RemoveElementsFromArrayListExample.java b/java-arraylist-examples/src/RemoveElementsFromArrayListExample.java
@@ -19,11 +19,12 @@ public static void main(String[] args) {
         programmingLanguages.remove(5);
         System.out.println("After remove(5): " + programmingLanguages);
 
-        // Remove the element "Kotlin" (The remove() method returns false if the element does not exist in the ArrayList)
+        // Remove the first occurrence of the given element from the ArrayList
+        // (The remove() method returns false if the element does not exist in the ArrayList)
         boolean isRemoved = programmingLanguages.remove("Kotlin");
         System.out.println("After remove(\"Kotlin\"): " + programmingLanguages);
 
-        // Remove all the elements belonging to the collection scriptingLanguages
+        // Remove all the elements that exist in a given collection
         List<String> scriptingLanguages = new ArrayList<>();
         scriptingLanguages.add("Python");
         scriptingLanguages.add("Ruby");
diff --git a/java-arraylist-examples/src/SearchElementsInArrayListExample.java b/java-arraylist-examples/src/SearchElementsInArrayListExample.java
@@ -15,7 +15,7 @@ public static void main(String[] args) {
         // Check if an ArrayList contains a given element
         System.out.println("Does names array contain \"Bob\"? : " + names.contains("Bob"));
 
-        // Find the index of first occurrence of an element in an ArrayList
+        // Find the index of the first occurrence of an element in an ArrayList
         System.out.println("indexOf \"Steve\": " + names.indexOf("Steve"));
         System.out.println("indexOf \"Mark\": " + names.indexOf("Mark"));
 
diff --git a/java-arraylist-examples/src/SynchronizedArrayListExample.java b/java-arraylist-examples/src/SynchronizedArrayListExample.java
@@ -15,7 +15,7 @@ public static void main(String[] args) throws InterruptedException {
         // Create a thread pool of size 10
         ExecutorService executorService = Executors.newFixedThreadPool(10);
 
-        // Create a Runnable task that increments the each element of the ArrayList by one
+        // Create a Runnable task that increments each element of the ArrayList by one
         Runnable task = () -> {
             incrementArrayList(safeArrayList);
         };
diff --git a/java-arraylist-examples/src/UnsafeArrayListExample.java b/java-arraylist-examples/src/UnsafeArrayListExample.java
@@ -14,7 +14,7 @@ public static void main(String[] args) throws InterruptedException {
         // Create a thread pool of size 10
         ExecutorService executorService = Executors.newFixedThreadPool(10);
 
-        // Create a Runnable task that increments the each element of the ArrayList by one
+        // Create a Runnable task that increments each element of the ArrayList by one
         Runnable task = () -> {
             incrementArrayList(unsafeArrayList);
         };
diff --git a/java-hashmap-examples/src/AccessKeysFromHashMapExample.java b/java-hashmap-examples/src/AccessKeysFromHashMapExample.java
@@ -5,13 +5,15 @@ public class AccessKeysFromHashMapExample {
     public static void main(String[] args) {
         Map<String, String> userCityMapping = new HashMap<>();
 
-        // Check if HashMap is empty
+        // Check if a HashMap is empty
         System.out.println("is userCityMapping empty? : " + userCityMapping.isEmpty());
 
         userCityMapping.put("John", "New York");
         userCityMapping.put("Rajeev", "Bengaluru");
         userCityMapping.put("Steve", "London");
 
+        System.out.println("userCityMapping HashMap : " + userCityMapping);
+
         // Find the size of a HashMap
         System.out.println("We have the city information of " + userCityMapping.size() + " users");
 
@@ -25,9 +27,17 @@ public static void main(String[] args) {
             System.out.println("City details not found for user " + userName);
         }
 
+        // Check if a value exists in a HashMap
+        if(userCityMapping.containsValue("New York")) {
+            System.out.println("There is a user in the userCityMapping who lives in New York");
+        } else {
+            System.out.println("There is not user in the userCityMapping who lives in New York");
+        }
+
+
         // Modify the value assigned to an existing key
         userCityMapping.put(userName, "California");
-        System.out.println(userName + " moved to a new city " + userCityMapping.get(userName));
+        System.out.println(userName + " moved to a new city " + userCityMapping.get(userName) + ", New userCityMapping : " + userCityMapping);
 
         // The get() method returns `null` if the specified key was not found in the HashMap
         System.out.println("Lisa's city : " + userCityMapping.get("Lisa"));
diff --git a/java-hashmap-examples/src/CreateHashMapExample.java b/java-hashmap-examples/src/CreateHashMapExample.java
@@ -11,6 +11,9 @@ public static void main(String[] args) {
         numberMapping.put("Two", 2);
         numberMapping.put("Three", 3);
 
+        // Add a new key-value pair only if the key does not exist in the HashMap, or is mapped to `null`
+        numberMapping.putIfAbsent("Four", 4);
+
         System.out.println(numberMapping);
     }
 }
diff --git a/java-hashmap-examples/src/HashMapEntryKeySetValuesExample.java b/java-hashmap-examples/src/HashMapEntryKeySetValuesExample.java
@@ -15,14 +15,14 @@ public static void main(String[] args) {
 
         // HashMap's entry set
         Set<Map.Entry<String, String>> countryISOCodeEntries = countryISOCodeMapping.entrySet();
-        System.out.println(countryISOCodeEntries);
+        System.out.println("countryISOCode entries : " + countryISOCodeEntries);
 
         // HashMap's key set
         Set<String> countries = countryISOCodeMapping.keySet();
-        System.out.println("Countries : " + countries);
+        System.out.println("countries : " + countries);
 
         // HashMap's values
         Collection<String> isoCodes = countryISOCodeMapping.values();
-        System.out.println("ISO Codes : " + isoCodes);
+        System.out.println("isoCodes : " + isoCodes);
     }
 }
diff --git a/java-hashmap-examples/src/RemoveKeysFromHashMapExample.java b/java-hashmap-examples/src/RemoveKeysFromHashMapExample.java
@@ -10,16 +10,18 @@ public static void main(String[] args) {
 
         System.out.println("Husband-Wife Mapping : " + husbandWifeMapping);
 
-        // Unfortunately, Chris got divorced. Let's remove him from the mapping
+        // Remove a key from the HashMap
+        // Ex - Unfortunately, Chris got divorced. Let's remove him from the mapping
         String husband = "Chris";
         String wife = husbandWifeMapping.remove(husband);
 
         System.out.println("Couple (" + husband + " => " + wife + ") got divorced");
         System.out.println("New Mapping : " + husbandWifeMapping);
 
-        // Divorce "Jack" only if He is married to "Linda"
+        // Remove a key from the HashMap only if it is mapped to the given value
+        // Ex - Divorce "Jack" only if He is married to "Linda"
         boolean isRemoved = husbandWifeMapping.remove("Jack", "Linda");
-        System.out.println("Did Jack got removed from the mapping? : " + isRemoved);
+        System.out.println("Did Jack get removed from the mapping? : " + isRemoved);
 
         // remove() returns null if the mapping was not found for the supplied key
         wife = husbandWifeMapping.remove("David");
diff --git a/java-linkedhashmap-examples/src/AccessEntriesFromLinkedHashMapExample.java b/java-linkedhashmap-examples/src/AccessEntriesFromLinkedHashMapExample.java
@@ -0,0 +1,36 @@
+import java.util.LinkedHashMap;
+
+public class AccessEntriesFromLinkedHashMapExample {
+    public static void main(String[] args) {
+        LinkedHashMap<Integer, String> customerIdNameMapping = new LinkedHashMap<>();
+
+        customerIdNameMapping.put(1001, "Jack");
+        customerIdNameMapping.put(1002, "David");
+        customerIdNameMapping.put(1003, "Steve");
+        customerIdNameMapping.put(1004, "Alice");
+        customerIdNameMapping.put(1005, "Marie");
+
+        System.out.println("customerIdNameMapping : " + customerIdNameMapping);
+
+        // Check if a key exists in the LinkedHashMap
+        Integer id = 1005;
+        if(customerIdNameMapping.containsKey(id)) {
+            System.out.println("Found the customer with id " + id + " : " + customerIdNameMapping.get(id));
+        } else {
+            System.out.println("Customer with id " + id + " does not exist");
+        }
+
+        // Check if a value exists in the LinkedHashMap
+        String name = "David";
+        if(customerIdNameMapping.containsValue(name)) {
+            System.out.println("A customer named " + name + " exist in the map");
+        } else {
+            System.out.println("No customer found with name " + name + " in the map");
+        }
+
+        // Change the value associated with an existing key
+        id = 1004;
+        customerIdNameMapping.put(id, "Bob");
+        System.out.println("Changed the name of customer with id " + id + ", New mapping : " + customerIdNameMapping);
+    }
+}
diff --git a/java-linkedhashmap-examples/src/CreateLinkedHashMapExample.java b/java-linkedhashmap-examples/src/CreateLinkedHashMapExample.java
@@ -0,0 +1,20 @@
+import java.util.LinkedHashMap;
+
+public class CreateLinkedHashMapExample {
+    public static void main(String[] args) {
+        // Creating a LinkedHashMap
+        LinkedHashMap<String, Integer> wordNumberMapping = new LinkedHashMap<>();
+
+        // Adding new key-value pairs to the LinkedHashMap
+        wordNumberMapping.put("one", 1);
+        wordNumberMapping.put("two", 2);
+        wordNumberMapping.put("three", 3);
+        wordNumberMapping.put("four", 4);
+
+        // Add a new key-value pair only if the key does not exist in the LinkedHashMap, or is mapped to `null`
+        wordNumberMapping.putIfAbsent("five", 5);
+
+
+        System.out.println(wordNumberMapping);
+    }
+}
diff --git a/java-linkedhashmap-examples/src/IterateOverLinkedHashMapExample.java b/java-linkedhashmap-examples/src/IterateOverLinkedHashMapExample.java
@@ -0,0 +1,38 @@
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class IterateOverLinkedHashMapExample {
+    public static void main(String[] args) {
+        LinkedHashMap<String, String> userCityMapping = new LinkedHashMap<>();
+
+        userCityMapping.put("Rajeev", "Bengaluru");
+        userCityMapping.put("Chris", "London");
+        userCityMapping.put("David", "Paris");
+        userCityMapping.put("Jesse", "California");
+
+        System.out.println("=== Iterating over a LinkedHashMap using Java 8 forEach loop ===");
+        userCityMapping.forEach((user, city) -> {
+            System.out.println(user + " => " + city);
+        });
+
+
+        System.out.println("\n=== Iterating over the LinkedHashMap's entrySet using Java 8 forEach loop ===");
+        userCityMapping.entrySet().forEach(entry -> {
+            System.out.println(entry.getKey() + " => " + entry.getValue());
+        });
+
+        System.out.println("\n=== Iterating over the entrySet of a LinkedHashMap using iterator() ===");
+        Iterator<Map.Entry<String, String>> userCityMappingIterator = userCityMapping.entrySet().iterator();
+        while (userCityMappingIterator.hasNext()) {
+            Map.Entry<String, String> entry = userCityMappingIterator.next();
+            System.out.println(entry.getKey() + " => " + entry.getValue());
+        }
+
+        System.out.println("\n=== Iterating over the entrySet of a LinkedHashMap using iterator() and forEachRemaining ===");
+        userCityMappingIterator = userCityMapping.entrySet().iterator();
+        userCityMappingIterator.forEachRemaining(entry -> {
+            System.out.println(entry.getKey() + " => " + entry.getValue());
+        });
+    }
+}
diff --git a/java-linkedhashmap-examples/src/RemoveEntriesFromLinkedHashMapExample.java b/java-linkedhashmap-examples/src/RemoveEntriesFromLinkedHashMapExample.java
@@ -0,0 +1,22 @@
+import java.util.LinkedHashMap;
+
+public class RemoveEntriesFromLinkedHashMapExample {
+    public static void main(String[] args) {
+        LinkedHashMap<String, String> husbandWifeMapping = new LinkedHashMap<>();
+
+        husbandWifeMapping.put("Rajeev", "Jennifer");
+        husbandWifeMapping.put("John", "Maria");
+        husbandWifeMapping.put("Chris", "Lisa");
+        husbandWifeMapping.put("Steve", "Susan");
+
+        System.out.println("husbandWifeMapping : " + husbandWifeMapping);
+
+        // Remove the entry with the given key from the LinkedHashMap
+        String wife = husbandWifeMapping.remove("John");
+        System.out.println("Removed John and his wife " + wife + " from the mapping. New husbandWifeMapping : " + husbandWifeMapping);
+
+        // Remove the entry with the given key from the LinkedHashMap only if the key is mapped to the given value
+        boolean isRemoved = husbandWifeMapping.remove("John", "Susan");
+        System.out.println("Did John get removed from the mapping? : " + isRemoved);
+    }
+}
diff --git a/java-linkedlist-examples/src/CreateLinkedListExample.java b/java-linkedlist-examples/src/CreateLinkedListExample.java
@@ -0,0 +1,38 @@
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+public class CreateLinkedListExample {
+    public static void main(String[] args) {
+        // Creating a LinkedList
+        LinkedList<String> friends = new LinkedList<>();
+
+        // Adding new elements to the end of the LinkedList using add() method.
+        friends.add("Rajeev");
+        friends.add("John");
+        friends.add("David");
+        friends.add("Chris");
+
+        System.out.println("Initial LinkedList : " + friends);
+
+        // Adding an element at the specified position in the LinkedList
+        friends.add(3, "Lisa");
+        System.out.println("After add(3, \"Lisa\") : " + friends);
+
+        // Adding an element at the beginning of the LinkedList
+        friends.addFirst("Steve");
+        System.out.println("After addFirst(\"Steve\") : " + friends);
+
+        // Adding an element at the end of the LinkedList (This method is equivalent to the add() method)
+        friends.addLast("Jennifer");
+        System.out.println("After addLast(\"Jennifer\") : " + friends);
+
+        // Adding all the elements from an existing collection to the end of the LinkedList
+        List<String> familyFriends = new ArrayList<>();
+        familyFriends.add("Jesse");
+        familyFriends.add("Walt");
+
+        friends.addAll(familyFriends);
+        System.out.println("After addAll(familyFriends) : " + friends);
+    }
+}
diff --git a/java-linkedlist-examples/src/IterateOverLinkedListExample.java b/java-linkedlist-examples/src/IterateOverLinkedListExample.java
@@ -0,0 +1,55 @@
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.ListIterator;
+
+public class IterateOverLinkedListExample {
+    public static void main(String[] args) {
+        LinkedList<String> humanSpecies = new LinkedList<>();
+
+        humanSpecies.add("Homo Sapiens");
+        humanSpecies.add("Homo Neanderthalensis");
+        humanSpecies.add("Homo Erectus");
+        humanSpecies.add("Home Habilis");
+
+        System.out.println("=== Iterate over a LinkedList using Java 8 forEach loop ===");
+        humanSpecies.forEach(name -> {
+            System.out.println(name);
+        });
+
+
+        System.out.println("\n=== Iterate over a LinkedList using iterator() ===");
+        Iterator<String> humanSpeciesIterator = humanSpecies.iterator();
+        while (humanSpeciesIterator.hasNext()) {
+            String speciesName = humanSpeciesIterator.next();
+            System.out.println(speciesName);
+        }
+
+        System.out.println("\n=== Iterate over a LinkedList using iterator() and Java 8 forEachRemaining() method ===");
+        humanSpeciesIterator = humanSpecies.iterator();
+        humanSpeciesIterator.forEachRemaining(speciesName -> {
+            System.out.println(speciesName);
+        });
+
+        System.out.println("\n=== Iterate over a LinkedList using descendingIterator() ===");
+        Iterator<String> descendingHumanSpeciesIterator = humanSpecies.descendingIterator();
+        while (descendingHumanSpeciesIterator.hasNext()) {
+            String speciesName = descendingHumanSpeciesIterator.next();
+            System.out.println(speciesName);
+        }
+
+
+        System.out.println("\n=== Iterate over a LinkedList using listIterator() ===");
+        // ListIterator can be used to iterate over the LinkedList in both forward and backward directions
+        // In this example, we start from the end of the list and traverse backwards
+        ListIterator<String> humanSpeciesListIterator = humanSpecies.listIterator(humanSpecies.size());
+        while (humanSpeciesListIterator.hasPrevious()) {
+            String speciesName = humanSpeciesListIterator.previous();
+            System.out.println(speciesName);
+        }
+
+        System.out.println("\n=== Iterate over a LinkedList using simple for-each loop ===");
+        for(String speciesName: humanSpecies) {
+            System.out.println(speciesName);
+        }
+    }
+}
diff --git a/java-linkedlist-examples/src/RemoveElementsFromLinkedListExample.java b/java-linkedlist-examples/src/RemoveElementsFromLinkedListExample.java
diff --git a/java-linkedlist-examples/src/RetrieveLinkedListElementsExample.java b/java-linkedlist-examples/src/RetrieveLinkedListElementsExample.java
diff --git a/java-linkedlist-examples/src/SearchLinkedListExample.java b/java-linkedlist-examples/src/SearchLinkedListExample.java
diff --git a/java-treemap-examples/src/RemoveEntriesFromTreeMapExample.java b/java-treemap-examples/src/RemoveEntriesFromTreeMapExample.java

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ public int compare(String name1, String name2) {`
`20`	`20`	`}`
`21`	`21`	`});`
`22`	`22`
`23`		- // The above `sort()` method call can also be written simply using lambda expressions
	`23`	+ // The above `sort()` method call can also be written simply using lambda expression
`24`	`24`	`names.sort((name1, name2) -> name1.compareTo(name2));`
`25`	`25`
`26`	`26`	`// Following is an even more concise solution`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,9 @@ public static void main(String[] args) {`
`11`	`11`	`numberMapping.put("Two", 2);`
`12`	`12`	`numberMapping.put("Three", 3);`
`13`	`13`
	`14`	+ // Add a new key-value pair only if the key does not exist in the HashMap, or is mapped to `null`
	`15`	`+ numberMapping.putIfAbsent("Four", 4);`
	`16`	`+`
`14`	`17`	`System.out.println(numberMapping);`
`15`	`18`	`}`
`16`	`19`	`}`