Summary of Rust's Hash Maps

Introduction to Hash Maps

• Hash Map: A collection of key-value pairs where each key is unique.
• Purpose: Allows for fast data retrieval based on the key.

Key Concepts

• Keys and Values: Each entry in a hash map consists of a key (which is unique) and a value (which can be duplicated).
• Hashing: The process of converting a key into a hash value (a unique identifier) which determines where the value is stored in memory.
• Dynamic Size: Unlike arrays, hash maps can grow and shrink in size as needed.

Creating a Hash Map

To create a hash map, use the HashMap type from the standard library. Here’s an example:

use std::collections::HashMap;

let mut scores = HashMap::new();
scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

Accessing Values

You can retrieve the associated value using its key. For instance:

let blue_score = scores.get("Blue");

Iterating Over Hash Maps

You can loop through keys and values using a for loop:

for (key, value) in &scores {
    println!("{}: {}", key, value);
}

Ownership and Borrowing

Keys and values can be stored in the hash map by reference or by value. When using references, be mindful of lifetimes to avoid dangling references.

Hash Map Properties

• Performance: Generally provides O(1) average time complexity for insertions and lookups.
• Order: Does not maintain the order of the elements.

Conclusion

Hash maps are powerful tools for storing and retrieving data efficiently in Rust. They are ideal for scenarios where you need quick access to values based on unique keys.

Example of a Complete Hash Map Usage

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);

    // Accessing a value
    if let Some(score) = scores.get("Blue") {
        println!("Blue's score: {}", score);
    }

    // Iterating through the hash map
    for (key, value) in &scores {
        println!("{}: {}", key, value);
    }
}

By understanding these concepts and examples, beginners can effectively utilize hash maps in their Rust programs.