Collections in Rust

# CHAPTER 14

Collections in Rust #

1. Chapter Introduction #

2. Learning Objectives #

• Create, update, and iterate over Vectors (Vec<T>).

• Deeply understand how String works under the hood (UTF-8 bytes vs chars).

• Create, insert, and safely retrieve data from a HashMap.

3. Vectors (Vec<T>) #

Creating and Updating a Vector

fn main() {
    // 1. Using the vec! macro (most common)
    let mut v1 = vec![1, 2, 3];

    // 2. Creating an empty Vector
    let mut v2: Vec<i32> = Vec::new();

    // Adding elements
    v2.push(5);
    v2.push(6);
    v2.push(7);
}

Reading from a Vector There are two ways to reference a value: via index, or via the .get() method.

fn main() {
    let v = vec![10, 20, 30, 40, 50];

    // Method 1: Indexing (Will PANIC and crash if out of bounds!)
    let third: &i32 = &v[2];
    println!("The third element is {}", third);

    // Method 2: .get() (Returns an Option<&T>. Safe from crashing!)
    match v.get(2) {
        Some(third) => println!("The third element is {}", third),
        None => println!("There is no third element."),
    }
}

4. Strings (The UTF-8 Complexity) #

Because of UTF-8 (where an English letter takes 1 byte, but a Cyrillic letter takes 2 bytes, and an Emoji takes 4 bytes), Rust does NOT allow you to index into a String like an array (my_string[0]). Doing so could accidentally slice an emoji in half and crash the program!

Creating and Updating Strings

fn main() {
    let mut s = String::from("foo");
    
    // Append a string slice
    s.push_str("bar"); 
    
    // Append a single character
    s.push('!'); 
    
    println!("{}", s); // foobar!
}

Iterating over Strings Safely If you want to look at the individual human-readable characters, you must explicitly use the .chars() method.

for c in "नमस्ते".chars() {
    println!("{}", c);
}

5. HashMaps #

You must bring it into scope using use std::collections::HashMap;.

Creating and Inserting Data

use std::collections::HashMap;

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

    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);

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

    // Only insert IF the key doesn't already exist!
    scores.entry(String::from("Red")).or_insert(50);
}

Retrieving Data Because a key might not exist in the HashMap, .get() returns an Option<&V>.

let team_name = String::from("Blue");
// .copied() converts Option<&i32> to Option<i32>
// .unwrap_or(0) returns 0 if the key is missing
let score = scores.get(&team_name).copied().unwrap_or(0);

println!("Blue Team Score: {}", score);

6. Mini Project: Word Counter #

use std::collections::HashMap;

fn main() {
    let text = "hello world wonderful world";
    let mut map = HashMap::new();

    // text.split_whitespace() creates an iterator over the words
    for word in text.split_whitespace() {
        // .entry() looks for the word.
        // .or_insert(0) creates the key with a value of 0 if it doesn't exist, and returns a MUTABLE REFERENCE to the value.
        let count = map.entry(word).or_insert(0);
        *count += 1; // Dereference the pointer and increment the value!
    }

    println!("{:?}", map); 
    // Output: {"world": 2, "hello": 1, "wonderful": 1}
}

7. Common Mistakes #

• Indexing Strings: Writing let char = mystring[0];. Rust aggressively forbids this to prevent UTF-8 corruption.

11. Interview Questions #

• Q: Explain why Rust does not allow integer indexing into Strings. Give an example of how UTF-8 encoding justifies this design choice.

• Q: Contrast the memory behavior of arrays [i32; 5] vs Vectors Vec<i32>.

12. FAQs #

• Are HashMaps ordered? No. HashMaps do not preserve the order of insertion. If you iterate over a HashMap, the keys will print in a random order.

13. Summary #

14. Next Chapter Recommendation #