Working with Collections in Rust: 3 Practical Examples

Introduction to Collections in Rust

In Rust, collections are data structures that can store multiple values. Common types of collections include vectors, hash maps, and hash sets. Working with these collections is essential for efficient data manipulation and retrieval. This article provides three practical examples of working with collections in Rust, showcasing their typical use cases and functionalities.

Example 1: Using a Vector to Store a List of Integers

In this example, we’ll create a vector to store a list of integers, demonstrating how to add, access, and iterate over the elements. Vectors are dynamic arrays that can grow in size and provide random access to their elements.

Vectors are useful when you need to maintain an ordered collection of items and frequently add or remove elements.

fn main() {
    let mut numbers: Vec<i32> = Vec::new();  // Create a new empty vector
    numbers.push(1);  // Add elements to the vector
    numbers.push(2);
    numbers.push(3);

    // Accessing elements using indexing
    for i in 0..numbers.len() {
        println!("Element at index {}: {}", i, numbers[i]);
    }

    // Iterate over elements using a for loop
    for &number in &numbers {
        println!("Number: {}", number);
    }
}

Notes:

• You can initialize a vector with predefined values using vec![1, 2, 3].
• Vectors can store any data type, but you need to specify the type when declaring the vector.

Example 2: Using a HashMap for Key-Value Pairs

In this example, we’ll use a HashMap to store a collection of user names and their corresponding ages. HashMaps are efficient for lookups based on unique keys and are ideal when you need to associate values with keys.

This is useful in scenarios such as maintaining a user database or storing configuration settings.

use std::collections::HashMap;

fn main() {
    let mut user_ages: HashMap<String, i32> = HashMap::new();  // Create a new HashMap

    // Inserting key-value pairs into the HashMap
    user_ages.insert(String::from("Alice"), 30);
    user_ages.insert(String::from("Bob"), 25);
    user_ages.insert(String::from("Charlie"), 35);

    // Accessing values using keys
    if let Some(&age) = user_ages.get("Alice") {
        println!("Alice's age: {}", age);
    }

    // Iterate over key-value pairs
    for (name, age) in &user_ages {
        println!("{} is {} years old", name, age);
    }
}

Notes:

• The HashMap provides average O(1) complexity for lookups, insertions, and deletions.
• You can use different types for keys and values, but the key must implement the Hash and Eq traits.

Example 3: Using a HashSet to Store Unique Values

In this example, we will demonstrate how to use a HashSet to maintain a collection of unique values. HashSets are useful when you need to ensure that no duplicate items are stored in your collection.

This can be particularly beneficial for scenarios like tracking unique user IDs or collecting unique tags.

use std::collections::HashSet;

fn main() {
    let mut unique_ids: HashSet<i32> = HashSet::new();  // Create a new HashSet

    // Adding elements to the HashSet
    unique_ids.insert(1);
    unique_ids.insert(2);
    unique_ids.insert(3);
    unique_ids.insert(2);  // Duplicate, will not be added

    // Check if a value exists
    if unique_ids.contains(&2) {
        println!("Set contains the ID 2");
    }

    // Iterate over elements in the HashSet
    for id in &unique_ids {
        println!("Unique ID: {}", id);
    }
}

Notes:

• HashSets also provide average O(1) complexity for insertions and lookups.
• They do not maintain any order of elements, so the iteration order may differ.

These examples illustrate the versatility and efficiency of collections in Rust, making it easier to manage data in various applications.