Difference between revisions of "Rust-Programming-Language/C2/Collections/English"

Learning Objectives

• Collections and
• Types of Collections

System Requirements

• To record this tutorial I’m using the following setup.

Code Files

• The following code file is required to practise this tutorial.
• This file is provided in the Code Files link of this tutorial page.

Collections

• Collections are data structures that hold multiple values together
• They are used to store, retrieve, and manipulate groups of related values efficiently.
• Rust's collection types are available in the std::collections module

Types of Collections

• Vectors are dynamic arrays that can grow or shrink in size as needed.

• Hash Map is a key-value pair storage for fast lookups by key
• HashSet is a collection of unique items with no duplicates

> cargo new collections

In the menu bar, File >> Open folder >>

Desktop >> MyRustProject >> collections

Type the command cargo new collections and press Enter.

Open the created project as shown.

let mut fruits = vec!["Apple"];

fruits.push("Banana");

fruits.push("Cherry");

// Accessing elements safely

println!("{:?}", fruits.get(1)); // Some("Banana")

println!("{:?}", fruits.get(5)); // None

// Removing last element

fruits.pop();

println!("{:?}", fruits); // ["Apple", "Banana"]

// Checking if empty

println!("{}", fruits.is_empty());

// Checking length

println!("Number of fruits: {}", fruits.len());

}

We declare a mutable vector called fruits and it is initialized with "Apple".

push() method is a method to add elements to the end of the vector.

We add banana and cherry to the second and third position using the push method.

We use the get() method which returns an Option enum.

fruits.get(1) method accesses the element at index 1 and prints Some(“Banana”) method.

fruits.get(5) method is an invalid index and so it prints None.

.pop() method removes the last element from the vector.

In our case, "Cherry" is the last item and it gets removed.

.is_empty() checks if the vector has zero elements.

.len() returns the number of elements present in the vector.

Save the program.

is_empty() method returns false since the vector is not empty.

The vector has 2 elements and so the len method prints,

Number of fruits as 2.

fn main() {

let mut capitals = HashMap::new();

// Insert key-value pairs

capitals.insert("India", "New Delhi");

capitals.insert("USA", "Washington D.C.");

// Accessing elements

println!("{:?}", capitals.get("India"));  // Some("New Delhi")

println!("{:?}", capitals.get("France")); // None

// Removing an entry

capitals.remove("USA");

// Checking if key exists

if capitals.contains_key("India") {

println!("Found India's capital!");

}

In Rust, HashMap is not available by default.

We need to import it from the std::collections module to use it.

We create a new, empty, and mutable HashMap called capitals.

insert() method allows us to store a key with its value.

The keys are the country names and the values are their capitals.

Similar to Vector, we use the .get() method, to retrieve the value for a given key.

If the key exists, it returns Some(value).

If the key does not exist, it returns None.

The remove() method deletes the entry with the given key.

It removes "USA" and its capital "Washington D.C." from the HashMap.

The contains_key() method checks if a specific key is present inside the HashMap.

The len() method gives the total number of key-value pairs present inside the HashMap.

Save the program.

Hashset

• It is a collection of unique values.
• It does not store duplicate entries, that is no two identical items can exist in it.
• It is unordered — The elements do not have a guaranteed order inside the set.

Copy paste the code from the Code file.

fn main() {

let mut names = HashSet::new();

// Inserting elements

names.insert("Jack");

names.insert("Joe");

names.insert("Jill");

names.insert("Joe"); // Duplicate, will be ignored

    if names.contains("Joe") {

        println!("Joe is present!");

    }

    // Removing an element

names.remove("Jill");

    // Checking length

    println!("Number of persons: {}", names.len());

.insert() method insert elements to the HashSet.

When we try to insert the name Joe twice, the second insertion is ignored automatically.

Hash sets only store unique items.

The .contains() method checks if a specific item is present inside the HashSet.

It will print a success message if the name joe exists.

The remove() method deletes a specific value from the set.

We can also loop through all the elements and print them.

The order is not guaranteed because HashSets are unordered.

Save the program.

Summary

Let us summarize.

Write a Rust program that:

1. Takes a list of numbers
2. Uses a HashSet to find all the unique numbers.

Thank You