Rust's standard collections. Vec<T> is the most common. HashMap requires keys to implement Hash + Eq. All operations return Option or Result — never panic on absent keys.
Docs: doc.rust-lang.org
| Name | Signature | Description |
|---|---|---|
| Vec::new | fn new() -> Vec<T> | Create empty growable array |
| vec![] | macro vec![1, 2, 3] → Vec<T> | Create Vec from literals |
| v.push | fn push(&mut self, value: T) | Append element to end |
| v.pop | fn pop(&mut self) -> Option<T> | Remove and return last element |
| v.len | fn len(&self) -> usize | Number of elements |
| v.is_empty | fn is_empty(&self) -> bool | True if zero elements |
| v.get | fn get(&self, index: usize) -> Option<&T> | Get element by index (safe) |
| v.iter | fn iter(&self) -> Iter<'_, T> | Iterator over references |
| v.iter_mut | fn iter_mut(&mut self) -> IterMut<'_, T> | Iterator over mutable references |
| v.retain | fn retain(&mut self, f: impl FnMut(&T)->bool) | Keep elements satisfying predicate |
| v.sort | fn sort(&mut self) where T: Ord | Sort in place (stable) |
| v.sort_by | fn sort_by(&mut self, compare: impl FnMut(&T,&T)->Ordering) | Sort with comparator |
| v.sort_by_key | fn sort_by_key<K: Ord>(&mut self, f: impl FnMut(&T)->K) | Sort by key function |
| v.dedup | fn dedup(&mut self) where T: PartialEq | Remove consecutive duplicates |
| v.extend | fn extend(&mut self, iter: impl IntoIterator<Item=T>) | Append all items from iterator |
| v.drain | fn drain(&mut self, range: R) -> Drain<'_,T> | Remove and return elements in range |
| v.truncate | fn truncate(&mut self, len: usize) | Truncate to first len elements |
| v.windows | fn windows(&self, size: usize) -> Windows<'_,T> | Sliding window iterator |
| v.chunks | fn chunks(&self, size: usize) -> Chunks<'_,T> | Non-overlapping chunk iterator |
| HashMap::new | fn new() -> HashMap<K,V> | Create empty hash map |
| map.insert | fn insert(&mut self, k: K, v: V) -> Option<V> | Insert; return old value if key existed |
| map.get | fn get(&self, k: &Q) -> Option<&V> | Get reference to value |
| map.get_mut | fn get_mut(&mut self, k: &Q) -> Option<&mut V> | Get mutable reference to value |
| map.contains_key | fn contains_key(&self, k: &Q) -> bool | True if key exists |
| map.remove | fn remove(&mut self, k: &Q) -> Option<V> | Remove and return value |
| map.entry | fn entry(&mut self, key: K) -> Entry<'_,K,V> | Ergonomic insert-or-modify |
| entry.or_insert | fn or_insert(self, default: V) -> &mut V | Insert default if absent; return &mut |
| entry.or_default | fn or_default(self) -> &mut V where V: Default | Insert Default::default() if absent |
| map.iter | fn iter(&self) -> Iter<'_,K,V> | Iterator over (&K, &V) pairs |
| BTreeMap | struct BTreeMap<K,V> | Sorted map — keys must implement Ord |
| HashSet | struct HashSet<T> | Unordered set — O(1) insert/contains |
| set.insert | fn insert(&mut self, value: T) -> bool | Insert value; return false if already present |
| set.contains | fn contains(&self, value: &Q) -> bool | True if set contains value |
| set.union | fn union(&self, other: &HashSet<T>) -> Union | Iterator over all values in either set |
| set.intersection | fn intersection(&self, other: &HashSet<T>) -> Intersection | Iterator over common values |
| set.difference | fn difference(&self, other: &HashSet<T>) -> Difference | Values in self but not other |
| VecDeque | struct VecDeque<T> | Double-ended queue — O(1) push/pop both ends |
| vd.push_back | fn push_back(&mut self, value: T) | Append to back |
| vd.push_front | fn push_front(&mut self, value: T) | Prepend to front |
| vd.pop_front | fn pop_front(&mut self) -> Option<T> | Remove from front |
Save as main.rs in a Cargo project and run with cargo run.
use std::collections::{HashMap, BTreeMap, HashSet, VecDeque};
fn main() {
// --- Vec ---
let mut v: Vec<i32> = (1..=9).collect();
v.retain(|&x| x % 2 != 0);
println!("Odd: {:?}", v);
v.sort_by(|a,b| b.cmp(a));
println!("Sorted desc: {:?}", v);
// Windows (sliding)
let sums: Vec<i32> = v.windows(3).map(|w| w.iter().sum()).collect();
println!("Window sums: {:?}", sums);
// --- HashMap: word frequency ---
let text = "go rust java go python rust go java rust";
let mut freq: HashMap<&str, u32> = HashMap::new();
for word in text.split_whitespace() {
*freq.entry(word).or_insert(0) += 1;
}
let mut sorted: Vec<_> = freq.iter().collect();
sorted.sort_by(|a,b| b.1.cmp(a.1));
for (word, count) in &sorted {
println!(" {:10} {}", word, count);
}
// --- BTreeMap (sorted) ---
let mut scores: BTreeMap<&str, u32> = BTreeMap::new();
scores.insert("Alice", 95); scores.insert("Bob", 87); scores.insert("Carol", 92);
for (name, score) in &scores { println!("{}: {}", name, score); }
// --- HashSet ---
let a: HashSet<i32> = [1,2,3,4,5].iter().cloned().collect();
let b: HashSet<i32> = [3,4,5,6,7].iter().cloned().collect();
let mut inter: Vec<_> = a.intersection(&b).collect(); inter.sort();
println!("Intersection: {:?}", inter);
// --- VecDeque ---
let mut dq: VecDeque<&str> = VecDeque::new();
dq.push_back("first"); dq.push_back("second"); dq.push_front("zeroth");
while let Some(item) = dq.pop_front() { println!("Dequeued: {}", item); }
}
// cargo run