Exploring Maps and HashMap in Java | CodeSignal Learn

Exploring Maps and HashMap in Java | CodeSignal Learn

Exploring Maps and HashMap in Java

Welcome to our Java data structures revision! Today, we will delve deeply into Java Maps . Much like a bookshelf, Maps allow you to quickly select the book (value) you desire by reading its label (key). They are vital in Java for quickly accessing values using keys and for efficiently inserting and deleting keys. So, let's explore Java Maps for a clearer understanding of these concepts.

Introduction to Java Maps and Operations

Before diving into real-world applications, it’s essential to grasp the fundamentals of Java Maps, a crucial data structure for storing data as key-value pairs. Understanding how to define and perform basic operations on them prepares us for more complex implementations. In Java, keys in a Map are unique, and you can have many different types as keys like Strings or Integers; however, if mutable objects are used as keys, their behavior can be unexpected. In most cases, developers prefer using HashMap<K, V> which allows fast lookups. Javaimport java.util.HashMap; import java.util.Map; public class Solution { public static void main(String[] args) { // Defining a HashMap Map<String, Integer> ageMap = new HashMap<>(); // Adding entries ageMap.put("Alice", 25); ageMap.put("Bob", 30); System.out.println("After adding: "); for (Map.Entry<String, Integer> entry : ageMap.entrySet()) { System.out.println(entry.getKey() + ": " + entry.getValue()); } // Updating entries ageMap.put("Alice", 26); // Updates Alice's age System.out.println("\nAfter updating: "); for (Map.Entry<String, Integer> entry : ageMap.entrySet()) { System.out.println(entry.getKey() + ": " + entry.getValue()); } // Retrieving values int ageOfAlice = ageMap.containsKey("Alice") ? ageMap.get("Alice") : -1; System.out.println("\nAlice's Age: " + ageOfAlice); // Removing entries ageMap.remove("Bob"); System.out.println("\nAfter removing Bob: "); for (Map.Entry<String, Integer> entry : ageMap.entrySet()) { System.out.println(entry.getKey() + ": " + entry.getValue()); } // Counting entries int entryCount = ageMap.size(); System.out.println("\nNumber of Entries: " + entryCount); } } Defining a Map: Use HashMap<K, V> where K is the type for keys and V is the type for values. Adding: Initial addition of entries, printed after insertion. Updating: Demonstrates updating the existing entry by reassigning Alice's age. Retrieving: Uses containsKey to check existence and retrieve values. Removing: Uses the remove method to delete entries. Counting: Uses the size method to get the number of entries. Now that you're familiar with these operations, let's apply them in a PhoneBook class.

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Implementing a PhoneBook with Java Maps

Imagine storing your friend's contact info in such a way that allows you to search for your friend's name (the key) and instantly find their phone number (the value). import java.util.HashMap; import java.util.Map; class PhoneBook {private Map<String, String> contacts; public PhoneBook() {// Initialize the HashMap contacts = new HashMap<>();} public void addContact(String name, String phoneNumber) {// Add or update a contact contacts.put(name, phoneNumber);} public String getPhoneNumber(String name) {// Retrieve a phone number or return "Not Found" return contacts.containsKey(name) ? contacts.get(name) : "Not Found";}} public class Solution {public static void main(String[] args) {// Create a PhoneBook instance PhoneBook phoneBook = new PhoneBook(); // Add contacts phoneBook.addContact("Alice", "123-456-7890"); phoneBook.addContact("Bob", "234-567-8901"); // Get and display phone numbers System.out.println(phoneBook.getPhoneNumber("Alice")); // Output: "123-456-7890" System.out.println(phoneBook.getPhoneNumber("Bobby")); // Output: "Not Found"}} In the above code, we create a PhoneBook class that uses a HashMap to store contacts. As you can see, Maps simplify the processes of adding, modifying, and accessing information with unique keys.

Operations in Maps

Looping Through Maps

Java provides an elegant way to loop through Maps using enhanced for-loops. We can iterate through keys, values, or both simultaneously using the keySet(), values(), and entrySet() methods. Keys : To loop through all the keys in the Map, you can use the keySet method. Values : To loop through all the values in the Map, you can use the values method. Entries : To loop through all key-value pairs in the Map, you can use the entrySet method. Let's explore this in our TaskManager example: import java.util.HashMap; import java.util.Map; class TaskManager {private Map<String, String> tasks; public TaskManager() {tasks = new HashMap<>();} public void addTask(String taskName, String status) {tasks.put(taskName, status);} public void printAllTaskKeys() {for (String taskName : tasks.keySet()) {System.out.println(taskName);}} public void printAllTaskValues() {for (String status : tasks.values()) {System.out.println(status);}} public void printAllEntries() {for (Map.Entry<String, String> entry : tasks.entrySet()) {System.out.println(entry.getKey() + ": " + entry.getValue());}}} public class Solution {public static void main(String[] args) {TaskManager myTasks = new TaskManager(); myTasks.addTask("Buy Milk", "Pending"); myTasks.addTask("Pay Bills", "Completed"); myTasks.printAllTaskKeys(); /* Output: Buy Milk Pay Bills */ myTasks.printAllTaskValues(); /* Output: Pending Completed */ myTasks.printAllEntries(); /* Output: Buy Milk: Pending Pay Bills: Completed */}} In this example, we use enhanced for-loops to iterate over a map's keys, values, and entries using the keySet, values, and entrySet methods, allowing us to easily print all tasks in our task manager along with their statuses. Note: The order of the output can differ, as we are using a HashMap, which does not maintain insertion order. If maintaining insertion order is important, consider using a LinkedHashMap instead.

Nesting with Maps

Nesting in Maps involves storing Maps within another Map. It's useful when associating multiple pieces of information with a key. Let's see how this works in a StudentDatabase example. import java.util.HashMap; import java.util.Map; class StudentDatabase {private Map<String, Map<String, String>> students; public StudentDatabase() {students = new HashMap<>();} public void addStudent(String name, Map<String, String> subjects) {students.put(name, subjects);} public String getMark(String name, String subject) {Map<String, String> subjects = students.get(name); if (subjects != null) {return subjects.getOrDefault(subject, "N/A");} return "N/A";} public void printDatabase() {for (Map.Entry<String, Map<String, String>> student : students.entrySet()) {System.out.println("Student: " + student.getKey()); for (Map.Entry<String, String> subject : student.getValue().entrySet()) {System.out.println(" Subject: " + subject.getKey() + ", Grade: " + subject.getValue());}}}} public class Solution {public static void main(String[] args) {StudentDatabase studentDb = new StudentDatabase(); Map<String, String> aliceSubjects = new HashMap<>(); aliceSubjects.put("Math", "A"); aliceSubjects.put("English", "B"); studentDb.addStudent("Alice", aliceSubjects); System.out.println(studentDb.getMark("Alice", "English")); // Output: "B" System.out.println(studentDb.getMark("Alice", "History")); // Output: "N/A" studentDb.printDatabase(); /* Output: Student: Alice Subject: Math, Grade: A Subject: English, Grade: B */}}

Hands-on Example

Let's shift our focus to a more interactive and familiar scenario: managing a shopping cart in an online store. This hands-on example will demonstrate how Maps can be used to map product names to their quantities in a shopping cart. You will learn how to add products, update quantities, and retrieve the total number of items in the cart. Here’s how you can implement and manipulate a shopping cart using a Java Map: import java.util.HashMap; import java.util.Map; class ShoppingCart {private Map<String, Integer> cart; public ShoppingCart() {cart = new HashMap<>();} public void addProduct(String productName, int quantity) {cart.put(productName, cart.getOrDefault(productName, 0) + quantity);} public void removeProduct(String productName) {if (cart.containsKey(productName)) {cart.remove(productName);} else {System.out.println(productName + " not found in your cart.");}} public void showCart() {if (cart.isEmpty()) {System.out.println("Your shopping cart is empty.");} else {for (Map.Entry<String, Integer> entry : cart.entrySet()) {System.out.println(entry.getKey() + ": " + entry.getValue());}}}} public class Solution {public static void main(String[] args) {ShoppingCart myCart = new ShoppingCart(); myCart.addProduct("Apples", 5); myCart.addProduct("Bananas", 2); myCart.addProduct("Apples", 3); myCart.showCart(); /* Output: Apples: 8 Bananas: 2 */ myCart.removeProduct("Bananas"); myCart.showCart(); /* Output: Apples: 8 */}} This example showcases the practical application of Maps to manage a dynamic dataset, such as an online shopping cart. By using product names as keys and their quantities as values, we achieve efficient and flexible data manipulation. This exercise provides a solid foundation for understanding how to handle complex data structures in real-world Java applications.

Java

import java.util.HashMap;
import java.util.Map;

class PhoneBook {
    private Map<String, String> contacts;

    public PhoneBook() {
        // Initialize the HashMap
        contacts = new HashMap<>();
    }

    public void addContact(String name, String phoneNumber) {
        // Add or update a contact
        contacts.put(name, phoneNumber);
    }

    public String getPhoneNumber(String name) {
        // Retrieve a phone number or return "Not Found"
        return contacts.containsKey(name) ? contacts.get(name) : "Not Found";
    }
}

public class Solution {
    public static void main(String[] args) {
        // Create a PhoneBook instance
        PhoneBook phoneBook = new PhoneBook();

        // Add contacts
        phoneBook.addContact("Alice", "123-456-7890");
        phoneBook.addContact("Bob", "234-567-8901");

        // Get and display phone numbers
        System.out.println(phoneBook.getPhoneNumber("Alice")); // Output: "123-456-7890"
        System.out.println(phoneBook.getPhoneNumber("Bobby")); // Output: "Not Found"
    }
}

Java

import java.util.HashMap;
import java.util.Map;

class TaskManager {
    private Map<String, String> tasks;

    public TaskManager() {
        // Initialize with an empty HashMap
        tasks = new HashMap<>();
    }

    public void addUpdateTask(String taskName, String status) {
        // Add a new task or update an existing task
        tasks.put(taskName, status);
    }

    public String getTaskStatus(String taskName) {
        // Retrieve task status or return "Not Found"
        return tasks.getOrDefault(taskName, "Not Found");
    }

    public void deleteTask(String taskName) {
        // Removes a task using its name
        if (tasks.containsKey(taskName)) {
            tasks.remove(taskName);
        } else {
            System.out.println("Task '" + taskName + "' not found.");
        }
    }

    public int getTaskCount() {
        // Returns the number of tasks in the TaskManager
        return tasks.size();
    }
}

public class Solution {
    public static void main(String[] args) {
        // Create a TaskManager instance
        TaskManager myTasks = new TaskManager();

        // Add tasks and update them
        myTasks.addUpdateTask("Buy Milk", "Pending");
        System.out.println(myTasks.getTaskStatus("Buy Milk"));  // Output: Pending

        myTasks.addUpdateTask("Buy Milk", "Completed");
        System.out.println(myTasks.getTaskStatus("Buy Milk"));  // Output: Completed

        // Delete a task
        myTasks.deleteTask("Buy Milk");
        System.out.println(myTasks.getTaskStatus("Buy Milk"));  // Output: Not Found

        // Add another task and get the count
        myTasks.addUpdateTask("Clean House", "In Progress");
        System.out.println(myTasks.getTaskCount());  // Output: 1
    }
}

Java

import java.util.HashMap;
import java.util.Map;

class TaskManager {
    private Map<String, String> tasks;

    public TaskManager() {
        tasks = new HashMap<>();
    }

    public void addTask(String taskName, String status) {
        tasks.put(taskName, status);
    }

    public void printAllTaskKeys() {
        for (String taskName : tasks.keySet()) {
            System.out.println(taskName);
        }
    }

    public void printAllTaskValues() {
        for (String status : tasks.values()) {
            System.out.println(status);
        }
    }

    public void printAllEntries() {
        for (Map.Entry<String, String> entry : tasks.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

public class Solution {
    public static void main(String[] args) {
        TaskManager myTasks = new TaskManager();
        myTasks.addTask("Buy Milk", "Pending");
        myTasks.addTask("Pay Bills", "Completed");

        myTasks.printAllTaskKeys();
        /* Output:
        Buy Milk
        Pay Bills
        */

        myTasks.printAllTaskValues();
        /* Output:
        Pending
        Completed
        */

        myTasks.printAllEntries();
        /* Output:
        Buy Milk: Pending
        Pay Bills: Completed
        */
    }
}

Java

import java.util.HashMap;
import java.util.Map;

class StudentDatabase {
    private Map<String, Map<String, String>> students;

    public StudentDatabase() {
        students = new HashMap<>();
    }

    public void addStudent(String name, Map<String, String> subjects) {
        students.put(name, subjects);
    }

    public String getMark(String name, String subject) {
        Map<String, String> subjects = students.get(name);
        if (subjects != null) {
            return subjects.getOrDefault(subject, "N/A");
        }
        return "N/A";
    }

    public void printDatabase() {
        for (Map.Entry<String, Map<String, String>> student : students.entrySet()) {
            System.out.println("Student: " + student.getKey());
            for (Map.Entry<String, String> subject : student.getValue().entrySet()) {
                System.out.println("    Subject: " + subject.getKey() + ", Grade: " + subject.getValue());
            }
        }
    }
}

public class Solution {
    public static void main(String[] args) {
        StudentDatabase studentDb = new StudentDatabase();
        Map<String, String> aliceSubjects = new HashMap<>();
        aliceSubjects.put("Math", "A");
        aliceSubjects.put("English", "B");
        studentDb.addStudent("Alice", aliceSubjects);

        System.out.println(studentDb.getMark("Alice", "English")); // Output: "B"
        System.out.println(studentDb.getMark("Alice", "History")); // Output: "N/A"
        studentDb.printDatabase();
        /* Output:
        Student: Alice
            Subject: Math, Grade: A
            Subject: English, Grade: B
        */
    }
}

Java

import java.util.HashMap;
import java.util.Map;

class ShoppingCart {
    private Map<String, Integer> cart;

    public ShoppingCart() {
        cart = new HashMap<>();
    }

    public void addProduct(String productName, int quantity) {
        cart.put(productName, cart.getOrDefault(productName, 0) + quantity);
    }

    public void removeProduct(String productName) {
        if (cart.containsKey(productName)) {
            cart.remove(productName);
        } else {
            System.out.println(productName + " not found in your cart.");
        }
    }

    public void showCart() {
        if (cart.isEmpty()) {
            System.out.println("Your shopping cart is empty.");
        } else {
            for (Map.Entry<String, Integer> entry : cart.entrySet()) {
                System.out.println(entry.getKey() + ": " + entry.getValue());
            }
        }
    }
}

public class Solution {
    public static void main(String[] args) {
        ShoppingCart myCart = new ShoppingCart();

        myCart.addProduct("Apples", 5);
        myCart.addProduct("Bananas", 2);
        myCart.addProduct("Apples", 3);

        myCart.showCart();
        /* Output:
        Apples: 8
        Bananas: 2
        */

        myCart.removeProduct("Bananas");
        myCart.showCart();
        /* Output:
        Apples: 8
        */
    }
}