Rust Interview Questions

A HashMap in Rust is a collection type that stores key-value pairs. It is part of the standard library and is useful for situations where you need to associate a key with a value and quickly retrieve values based on their keys. The HashMap type is provided by the std::collections module.

Creating and Using a HashMap

Here's a basic example of how to create and use a HashMap in Rust:

use std::collections::HashMap;

fn main() {
    // Create a new HashMap
    let mut scores = HashMap::new();

    // Insert key-value pairs
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);

    // Accessing values
    let team_name = String::from("Blue");
    match scores.get(&team_name) {
        Some(score) => println!("Score for {}: {}", team_name, score),
        None => println!("No score found for {}", team_name),
    }

    // Iterating over key-value pairs
    for (key, value) in &scores {
        println!("{}: {}", key, value);
    }

    // Updating a value
    scores.insert(String::from("Blue"), 25);

    // Entry API to update or insert if not present
    scores.entry(String::from("Green")).or_insert(30);

    println!("{:?}", scores);
}

Key Points about HashMap

1. Creation:

   • You can create a HashMap using HashMap::new().

2. Insertion:

   • Use the insert method to add key-value pairs to the map.

3. Accessing Values:

   • Use the get method to access values by their keys. This returns an Option because the key might not exist.

4. Iteration:

   • You can iterate over the key-value pairs using a for loop.

5. Updating Values:

   • Inserting a key that already exists in the map will overwrite the existing value.
   • The entry API allows you to check if a key exists and insert a value if it does not.

6. Removing Entries:

   • Use the remove method to delete a key-value pair from the map.

Example of More Advanced Usage

use std::collections::HashMap;

fn main() {
    let mut book_reviews = HashMap::new();

    // Insert some initial reviews
    book_reviews.insert("Adventures of Huckleberry Finn", "My favorite book.");
    book_reviews.insert("Grimms' Fairy Tales", "Masterpiece.");
    book_reviews.insert("Pride and Prejudice", "Very enjoyable.");
    book_reviews.insert("The Adventures of Sherlock Holmes", "A classic.");

    // Check for a specific review
    if let Some(review) = book_reviews.get("Pride and Prejudice") {
        println!("Review for 'Pride and Prejudice': {}", review);
    }

    // Modify a review
    book_reviews.insert("Pride and Prejudice", "A timeless classic.");
    println!("Updated review for 'Pride and Prejudice': {}", book_reviews.get("Pride and Prejudice").unwrap());

    // Remove a review
    book_reviews.remove("Adventures of Huckleberry Finn");

    // Iterate over all reviews
    for (book, review) in &book_reviews {
        println!("{}: {}", book, review);
    }
}

Summary

• Creation: HashMap::new()
• Insertion: .insert(key, value)
• Accessing: .get(&key) returns Option<&V>
• Updating: .insert(key, new_value) or .entry(key).or_insert(default_value)
• Removing: .remove(&key)
• Iteration: for (key, value) in &hashmap {}

A HashMap is a versatile and powerful data structure in Rust, providing efficient key-value storage and retrieval. By understanding these basic operations, you can effectively use HashMap in your Rust programs.