Rust Strings, Vectors and Hash Maps

Rust String, Vec and HashMap hold data that can grow at runtime. This lesson extends our Raspberry Pi fixtures to a collection of readings and labelled values, while keeping ownership, missing data and UTF-8 boundaries explicit.

Prerequisites and outcome

Complete enums, match and patterns. You will distinguish owned String from borrowed str, use a vector rather than a fixed-size array, and perform map lookups without assuming an entry exists.

These collection types are standard-library APIs, not new syntax for defining types. Type parameters such as Vec<i32> name the element type; HashMap<String, i32> names the key and value types. Generics receive their own lesson later. Vec and String are in the prelude; HashMap needs an explicit import.

Run a collection report

cargo new pi_collections
cd pi_collections

Replace src/main.rs with:

use std::collections::HashMap;

fn update_reading(readings: &mut Vec<i32>, millidegrees: i32) {
    readings.push(millidegrees);
}

fn main() {
    let mut label = String::from("Pi");
    label.push_str(" 4B");

    let mut readings: Vec<i32> = vec![46_700, 60_000];
    update_reading(&mut readings, 63_200);
    println!("{label}: {} readings", readings.len());
    println!("first={:?}", readings.first());
    println!("out-of-range={:?}", readings.get(99));

    let mut latest: HashMap<String, i32> = HashMap::new();
    let previous = latest.insert(label, readings[0]);
    // label has moved into the map. It is not used as an owned String again.
    println!("previous={previous:?}");

    // Choose an explicit reporting order, not the map's iteration order.
    for name in ["Pi 4B", "Pi 5"] {
        match latest.get(name) {
            Some(value) => println!("{name}={value}"),
            None => println!("{name}=missing"),
        }
    }

    let text = "π";
    println!(
        "Unicode fixture: bytes={}, scalars={}",
        text.len(),
        text.chars().count()
    );
}

#[cfg(test)]
mod tests {
    use super::{HashMap, update_reading};

    #[test]
    fn vector_grows_and_supports_checked_access() {
        let mut readings = Vec::new();
        assert_eq!(readings.first(), None);
        update_reading(&mut readings, 46_700);
        assert_eq!(readings.get(0), Some(&46_700));
        assert_eq!(readings.get(1), None);
    }

    #[test]
    fn borrowed_map_lookup_distinguishes_missing_from_zero() {
        let mut latest = HashMap::new();
        latest.insert(String::from("Pi"), 0);
        assert_eq!(latest.get("Pi"), Some(&0));
        assert_eq!(latest.get("absent"), None);
    }

    #[test]
    fn replacing_a_key_returns_the_previous_value() {
        let mut latest = HashMap::new();
        assert_eq!(latest.insert(String::from("Pi"), 46_700), None);
        assert_eq!(latest.insert(String::from("Pi"), 48_200), Some(46_700));
        assert_eq!(latest.len(), 1);
        assert_eq!(latest.remove("Pi"), Some(48_200));
    }

    #[test]
    fn unicode_text_has_valid_byte_boundaries() {
        let text = "π";
        assert_eq!(text.len(), 2);
        assert_eq!(text.chars().count(), 1);
        assert_eq!(text.get(..1), None);
        assert_eq!(text.get(..2), Some("π"));
    }

    #[test]
    fn combining_sequence_is_not_one_scalar() {
        let text = "e\u{301}";
        assert_eq!(text.chars().count(), 2);
        assert_eq!(text.len(), 3);
    }

    #[test]
    fn similar_display_does_not_normalise_map_keys() {
        let mut names = HashMap::new();
        names.insert(String::from("é"), 1);
        names.insert(String::from("e\u{301}"), 2);
        assert_eq!(names.len(), 2);
        assert_ne!("é", "e\u{301}");
    }

    #[test]
    fn entry_initialises_once_and_returns_mutable_access() {
        let mut counts = HashMap::new();
        *counts.entry(String::from("Pi")).or_insert(0) += 1;
        *counts.entry(String::from("Pi")).or_insert(99) += 1;
        assert_eq!(counts.get("Pi"), Some(&2));
    }

    #[test]
    #[should_panic]
    fn direct_vector_index_can_panic() {
        let readings = vec![46_700];
        let _missing = readings[99];
    }
}

cargo run --quiet
cargo test
cargo fmt --check

Expected output:

Pi 4B: 3 readings
first=Some(46700)
out-of-range=None
previous=None
Pi 4B=46700
Pi 5=missing
Unicode fixture: bytes=2, scalars=1

Some and None are variants of the standard-library Option enum. Here we inspect them with Debug formatting or match; lesson 9 develops absence and error handling in detail. Some(&0) in the map test is different from None: a real zero is present.

Vec owns elements; slices borrow them

An array's length is part of its type. A Vec keeps a runtime length and can add or remove elements. vec![...] is a macro for constructing a vector; Vec::new() starts empty. push requires mutable access. With non-Copy elements, insertion can move ownership into the vector.

len() counts initialized elements; capacity() describes how many elements the current allocation can hold without reallocation. Growing beyond capacity can change the backing allocation. Do not keep a reference to an element while pushing into that same vector and expect borrow checking to permit it.

Use &Vec<T> or, more generally for read-only element access, a slice &[T]. Our helper needs &mut Vec<i32> specifically because a mutable slice cannot grow its backing collection. Iterating over &readings borrows elements; consuming readings by value in a loop transfers access to owned elements and consumes the vector.

readings[index] panics when the runtime index is invalid. get(index) returns an Option and lets the caller decide what absence means. The expected-panic test demonstrates the difference, not an error-handling strategy for production. See vectors and the Vec API.

String owns UTF-8 text; str is a text view

String is growable owned UTF-8 text, while &str borrows a view. push_str appends borrowed text without taking ownership of that source. push appends a char. Calling as_str() borrows a String as text; to_owned() on a str creates owned text. A string literal already provides a borrowed view and does not need to become a String just for inspection.

Length and indexing are byte-based. chars() iterates Unicode scalar values, not user-perceived characters. The combining-sequence test shows that one displayed character may comprise two scalars. Grapheme segmentation is a separate operation that the standard chars iterator does not provide.

String does not support an integer index as “the character at this position”. Valid byte-range slicing must align with UTF-8 boundaries. get(..1) on π returns None instead of panicking, unlike direct slicing in the previous lesson. Neither byte counts nor scalar counts are a universal display-width measurement.

For concatenation, left + &right consumes the left String, while format!("{left}{right}") borrows arguments and produces new owned text. Pick an operation for its ownership contract, not because all concatenation spellings look interchangeable. See strings and the String API.

HashMap associates keys with values

HashMap owns the keys and values inserted by value. Our String label moves into the map, but the i32 reading copies. A String-keyed map can be looked up with a borrowed str, so finding "Pi 4B" does not require allocating a new String key.

get returns a borrowed value if present. insert returns an owned previous value when replacing the same key; remove returns the removed value. Their Option results make absence explicit. To initialise or update an entry in one operation, the entry API provides operations such as entry(key).or_insert(default), returning mutable access to the stored value. Its key is owned, unlike a borrowed get lookup.

Iteration order is not a stable reporting contract. We intentionally report a known sequence of names instead of printing the map directly. A different data structure, BTreeMap, provides key-ordered iteration when that ordering is part of the requirement.

Read hash maps and the HashMap API. We postpone trait requirements for custom keys until traits and generics.

Deliberately failing reference across growth

Use a separate scratch project for this complete example:

fn main() {
    let mut readings = vec![46_700, 60_000];
    let first = &readings[0];
    readings.push(63_200);
    println!("{first}"); // Shared access overlaps the mutable push.
}

Expect E0502 from cargo check. Using the reference before pushing ends that particular overlapping use; alternatively, copy an i32 value when you actually need an independent value. A String element would require a different ownership decision. Reserved capacity alone is not permission to retain a conflicting reference across push.

Exercises and checks

1. Replace &readings[0] in the failure example with readings[0]: it is now a copied i32, so the program can print it after push. Expect 46700.
2. Add latest.insert(String::from("Pi 4B"), 0) before reporting: expect a present zero rather than a missing entry. The map replacement test covers the underlying rule.
3. Compare "é" with "e\u{301}": different byte/scalar sequences can have similar visual appearance. Do not assume Rust automatically normalises them or treats them as equal keys.
4. Try using label after inserting it into latest: expect a moved-value compile error. Restore the program, or borrow a key from the map when inspection is what you need.

Verification and next step

On October 10, 2026, this lesson was verified on a Raspberry Pi 4B with 64-bit user space, kernel 6.18.50+rpt-rpi-v8, Rust and Cargo 1.99.0, and edition 2024. Cargo check, all 8 tests, formatting and debug/release output comparisons passed. The copied-element and present-zero exercises produced the expected output; reference-across-push and moved-label examples were rejected with E0502 and E0382. No hardware access, map-order assumption or performance result is involved.

Continue with Option, Result and error handling, including the Part I checkpoint.

Previous: enums and patterns · Course overview