Mastering Rust Collections: Vectors, Hash Maps & Strings Explained

Amza

Amza

— 3 min read

Rust offers a variety of powerful collection types to help you manage and organize data efficiently. Whether you’re building a game, processing data, or developing a web server, knowing how to use vectors, hash maps, and strings will be essential. These are the core building blocks for managing collections in Rust, each suited for different scenarios.

In this article, we’ll dive into each of these collection types with practical, hands-on examples. You’ll learn how to use them step-by-step, understand their strengths, and get familiar with the syntax and operations you can perform on them.

Let’s get started!

Step-by-Step Code Build

We’ll start by creating a minimal Rust project that showcases vectors, hash maps, and strings in action. Here’s the plan:

  1. Create a simple vector to hold numbers and perform basic operations like adding and accessing elements.
  2. Create a hash map to store key-value pairs, perform insertions and lookups.
  3. Work with strings, manipulating text data by appending and modifying strings.

1. Working with Vectors

Vectors in Rust are ordered collections that can grow or shrink in size. They are perfect when you need a list-like structure where elements can be accessed by their index.

Let’s start by creating a simple vector that holds numbers.

fn main() {
    // Creating a new vector to store integers
    let mut numbers: Vec<i32> = Vec::new();

    // Adding elements to the vector
    numbers.push(10);
    numbers.push(20);
    numbers.push(30);

    // Accessing elements by index
    println!("First number: {}", numbers[0]); // Output: First number: 10

    // Iterating over the vector
    for number in &numbers {
        println!("{}", number);
    }
}

Explanation:

  • Vec::new() creates an empty vector of type i32 (integer).
  • push() adds elements to the vector.
  • You access elements using indices, just like in other languages.
  • The for loop iterates over the vector, borrowing the data with &numbers to avoid ownership issues.

Challenge:

  • Modify the code to include more numbers and print the sum of all the elements.

2. Working with Hash Maps

A hash map in Rust is a collection that stores key-value pairs. It’s useful when you need to associate values with unique keys and look them up efficiently.

Let’s create a simple hash map to store people’s names and their ages:

use std::collections::HashMap;

fn main() {
    // Creating a new hash map
    let mut ages = HashMap::new();

    // Inserting key-value pairs
    ages.insert("Alice", 30);
    ages.insert("Bob", 25);
    ages.insert("Charlie", 35);

    // Accessing values by key
    match ages.get("Alice") {
        Some(&age) => println!("Alice is {} years old", age), // Output: Alice is 30 years old
        None => println!("No data found for Alice"),
    }

    // Iterating over the hash map
    for (name, age) in &ages {
        println!("{} is {} years old", name, age);
    }
}

Explanation:

  • HashMap::new() creates an empty hash map.
  • insert() adds key-value pairs, where "Alice" is the key and 30 is the value.
  • get() looks up a value by its key, returning an Option, which is why we use match to handle both the Some and None cases.
  • The for loop allows iteration over key-value pairs.

Challenge:

  • Add a new entry to the hash map for a new person, and then update an existing person’s age.

3. Working with Strings

Strings in Rust are UTF-8 encoded, and you can easily manipulate them using a variety of methods. You can concatenate, modify, and slice strings in Rust.

Here’s a basic example that demonstrates working with strings:

fn main() {
    // Creating a new string
    let mut greeting = String::from("Hello");

    // Appending text to the string
    greeting.push_str(", World!");

    // Print the final string
    println!("{}", greeting); // Output: Hello, World!

    // Slicing the string (get substring)
    let hello_part = &greeting[0..5]; // "Hello"
    println!("{}", hello_part);

    // Convert to uppercase
    println!("{}", greeting.to_uppercase()); // Output: HELLO, WORLD!
}

Explanation:

  • String::from() creates a mutable string.
  • push_str() appends text to the string.
  • Rust strings support slicing, where &greeting[0..5] extracts the first five characters.
  • to_uppercase() converts the string to uppercase.

Challenge:

  • Append your own name to the string and convert the whole string to lowercase.

Concepts and Explanations

  • Vectors: A vector is a dynamic, growable list. It's efficient for storing a sequence of values when the number of elements may vary. Vectors are very common for tasks like storing results of a computation or iterating over a list of items.

  • Hash Maps: A hash map provides an efficient way to store data where you can quickly look up a value based on a unique key. It’s useful for cases like storing user settings, building indexes, or any other situation where you need to map a unique identifier to a value.

  • Strings: In Rust, strings are a bit more complex than in some languages because they can store Unicode text and must account for the different byte representations of characters. Rust provides a String type, which is mutable, and a &str type, which is an immutable reference to a string slice.

Recap and Conclusion

In this article, we covered three fundamental Rust collections:

  1. Vectors: A dynamic, ordered list for storing values.
  2. Hash Maps: A collection of key-value pairs that allows fast lookups.
  3. Strings: A UTF-8 encoded collection for manipulating text.

You learned how to create, modify, and iterate through these collections. With these tools, you can handle a variety of data management tasks in Rust efficiently.

Next Steps:

  • Explore more operations with vectors (e.g., pop(), remove()) and hash maps (e.g., entry()).
  • Look into other Rust collections like HashSet for unique items or BTreeMap for ordered key-value pairs.

Happy coding, and keep experimenting with these collections!

Read more