Modul 6 — Collections

Der Vec ist Rusts Standardliste: wachsende Elemente gleichen Typs, am Stück auf dem Heap:

fn main() {
    let mut v = vec![3, 1, 4];
    v.push(1);
    v.push(5);

    println!("{} Elemente", v.len());
    println!("zweitens: {}", v[1]);
    println!("{v:?}");
}

vec![...] baut die Liste. Intern hält ein Vec ein Triple aus Zeiger, Länge und Kapazität; wächst er über die Kapazität, wird der Puffer größer kopiert — push bleibt amortisiert billig.

Sicher zugreifen: Index vs. get

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

    match v.get(10) {
        Some(x) => println!("gefunden: {x}"),
        None => println!("nicht da"),
    }
}

v[10] paniziert bei Überschreitung (Index out of bounds). v.get(10) gibt Option<&T> zurück — dieselbe Philosophie wie in Modul 5: Abwesenheit ist ein Wert, kein Absturz.

Iterieren: leihen oder nehmen?

fn main() {
    let v = vec![1, 2, 3];

    for x in &v {
        print!("{x} "); // leiht — v bleibt nutzbar
    }
    println!();

    let sum: i32 = v.iter().sum();
    println!("Summe: {sum}, v: {v:?}");
}

&v lehnt die Liste zum Lesen; v (ohne &) würde sie in die Schleife hineinbewegen. Und zum Filtern in place gibt es retain — statt während des Iterierens zu löschen (was der Borrow-Checker verboten):

fn main() {
    let mut v = vec![3, -1, 4, -5];
    v.retain(|&x| x >= 0);
    println!("{v:?}");
}

Übung: Vec sicher auswerten

Schlüssel auf Wert: HashMap<K, V> ist die Standard-Assoziativliste.

use std::collections::HashMap;

fn main() {
    let mut scores: HashMap<String, i32> = HashMap::new();
    scores.insert(String::from("anna"), 42);
    scores.insert(String::from("ben"), 17);

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

    scores.insert(String::from("anna"), 50); // überschreibt
    println!("{:?}", scores.get("anna"));
}

insert überschreibt existierende Werte und liefert den alten als Option zurück. get gibt Option<&V> — fehlen ist ein normaler Fall.

Das entry-Idiom: zählen in einem Lookup

Der Klassiker — Wortzähler ohne Doppel-Lookup:

use std::collections::HashMap;

fn word_counts(text: &str) -> HashMap<&str, u32> {
    let mut counts = HashMap::new();
    for word in text.split_whitespace() {
        *counts.entry(word).or_insert(0) += 1;
    }
    counts
}

fn main() {
    let counts = word_counts("rot grün rot blau grün rot");
    for (word, n) in &counts {
        println!("{word}: {n}");
    }
}

entry(word) holt oder erzeugt den Slot in einem Hash-Lookup, or_insert(0) impft fehlende Zähler mit 0 — und die zurückgegebene &mut u32 zählst du direkt hoch. Ohne entry bräuchtest du contains_key plus get plus insert: drei Lookups, wo einer reicht.

Übung: Wortzähler

Nicht jede Frage braucht einen Wert — manche braucht nur eine Zugehörigkeit: „Habe ich das schon gesehen?“ Dafür ist das HashSet da:

use std::collections::HashSet;

fn deduped(values: &[i32]) -> Vec<i32> {
    let unique: HashSet<i32> = values.iter().copied().collect();
    let mut result: Vec<i32> = unique.into_iter().collect();
    result.sort();
    result
}

fn main() {
    println!("{:?}", deduped(&[4, 2, 4, 1, 2, 9]));
}

Einfügen O(1), Enthaltensein O(1), keine Duplikate — ideal für Mengen, Blacklists, Already-Seen-Markierungen.

String als Schlüssel

Warum sind HashMap-Schlüssel oft String statt &str? Weil der besitzende String dem Map die Kontrolle über die Lebensdauer gibt — und Suchen funktionieren trotzdem mit Literalen:

use std::collections::HashMap;

fn main() {
    let mut cap: HashMap<String, String> = HashMap::new();
    cap.insert(String::from("de"), String::from("Hallo"));
    cap.insert(String::from("en"), String::from("Hello"));

    // &str-Lookup dank Borrow-Trait:
    println!("{:?}", cap.get("de"));
}

Regel: Anforderungen an Schlüssel sind Eq + Hash. Für sortierte Iteration und Range-Abfragen gibt es das BTreeMap — gleiche API, Baum statt Hash, dadurch immer in Schlüsselreihenfolge.

Übung: Duplikate raus

Das Abschlussprojekt von Modul 6 kombiniert HashMap, Vec, Sorting und das entry-Idiom zu einem Klassiker der Praktischen Informatik:

Modul-Checkpoint