Rust Collections standard collection library provides efficient implementations of the most common general-purpose programming data structures. This chapter discusses the implementation of the commonly used collections − Vector, HashMap, and HashSet.
Vector Of Rust Collections
A Vector is a resizable array. It stores values in contiguous memory blocks. The predefined structure Vec can be used to create vectors. Some important features of a Vector are −
- A Vector can grow or shrink at runtime.
- A Vector is a homogeneous collection.
- A Vector stores data as sequence of elements in a particular order. Every element in a Vector is assigned a unique index number. The index starts from 0 and goes up to n-1 where, n is the size of the collection. For example, in a collection of 5 elements, the first element will be at index 0 and the last element will be at index 4.
- A Vector will only append values to (or near) the end. In other words, a Vector can be used to implement a stack.
- Memory for a Vector is allocated in the heap.
Syntax – Creating a Vector
let mut instance_name = Vec::new();
The static method new() of the Vecstructure is used to create a vector instance.
Alternatively, a vector can also be created using the vec! macro. The syntax is as given below −
let vector_name = vec![val1,val2,val3]
The following table lists some commonly used functions of the Vec structure.
| Sr.No | Method | Signature & Description |
|---|---|---|
| 1 | new() | pub fn new()->VectConstructs a new, empty Vec. The vector will not allocate until elements are pushed onto it. |
| 2 | push() | pub fn push(&mut self, value: T)Appends an element to the back of a collection. |
| 3 | remove() | pub fn removes (&mut self, index: u size) -> TRemoves and returns the element at position index within the vector, shifting all elements after it to the left. |
| 4 | contains() | pub fn contains(&self, x: &T) -> boolReturns true if the slice contains an element with the given value. |
| 5 | len() | pub fn len(&self) -> usizeReturns the number of elements in the vector, also referred to as its ‘length’. |
Illustration: Creating a Vector – new()
To create a vector, we use the static method new−
fn main() {
let mut v = Vec::new();
v.push(20);
v.push(30);
v.push(40);
println!("size of vector is :{}",v.len());
println!("{:?}",v);
}
The above example creates a Vector using the static method new() that is defined in structure Vec. The push(Val) function appends the value passed as a parameter to the collection. The len() function returns the length of the vector.
Output
size of vector is :3 [20, 30, 40]
Illustration: Creating a Vector – vec! Macro
The following code creates a vector using the vec! macro. The data type of the vector is inferred the first value that is assigned to it.
fn main() {
let v = vec![1,2,3];
println!("{:?}",v);
}
Output
[1, 2, 3]
As mentioned earlier, a vector can only contain values of the same data type. The following snippet will throw an error[E0308]: mismatched types error.
fn main() {
let v = vec![1,2,3,"hello"];
println!("{:?}",v);
}
Illustration: push()
Appends an element to the end of a collection.
fn main() {
let mut v = Vec::new();
v.push(20);
v.push(30);
v.push(40);
println!("{:?}",v);
}
Output
[20, 30, 40]
Illustration: remove()
Removes and returns the element at position index within the vector, shifting all elements after it to the left.
fn main() {
let mut v = vec![10,20,30];
v.remove(1);
println!("{:?}",v);
}
Output
[10, 30]
Illustration – contains()
Returns true if the slice contains an element with the given value −
fn main() {
let v = vec![10,20,30];
if v.contains(&10) {
println!("found 10");
}
println!("{:?}",v);
}
Output
found 10 [10, 20, 30]
Illustration: len()
Returns the number of elements in the vector, also referred to as its ‘length’.
fn main() {
let v = vec![1,2,3];
println!("size of vector is :{}",v.len());
}
Output
size of vector is :3
Accessing values from a Vector
Individual elements in a vector can be accessed using their corresponding index numbers. The following example creates a vector ad prints the value of the first element.
fn main() {
let mut v = Vec::new();
v.push(20);
v.push(30);
println!("{:?}",v[0]);
}
Output: `20`
Values in a vector can also be fetched using the reference to the collection.
fn main() {
let mut v = Vec::new();
v.push(20);
v.push(30);
v.push(40);
v.push(500);
for i in &v {
println!("{}",i);
}
println!("{:?}",v);
}
Output
20 30 40 500 [20, 30, 40, 500]
HashMap
A map is a collection of key-value pairs (called entries). No two entries in a map can have the same key. In short, a map is a lookup table. A HashMap stores the keys and values in a hash table. The entries are stored in an arbitrary order. The key is used to search for values in the HashMap. The HashMap structure is defined in the std::collections module. This module should be explicitly imported to access the HashMap structure.
Syntax: Creating a HashMap
let mut instance_name = HashMap::new();
The static method new() of the HashMap structure is used to create a HashMap object. This method creates an empty HashMap.
The commonly used functions of HashMap are discussed below −
| Sr.No | Method | Signature & Description |
|---|---|---|
| 1 | insert() | pub fn insert(&mut self, k: K, v: V) -> OptionInserts a key/value pair, if no key then None is returned. After the update, the old value is returned. |
| 2 | len() | pub fn len(&self) -> usizeReturns the number of elements in the map. |
| 3 | get() | pub fn get<Q: ?Sized>(&lself, k: &Q) -> Option<&V> where K:Borrow Q:Hash+ EqReturns a reference to the value corresponding to the key. |
| 4 | iter() | pub fn iter(&self) -> Iter<K, V>An iterator visiting all key-value pairs in arbitrary order. The iterator element type is (&’a K, &’a V). |
| 5 | contains_key | pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> boolReturns true if the map contains a value for the specified key. |
| 6 | remove() | pub fn remove_entry<Q: ?Sized>(&mut self, k: &Q) -> Option<(K, V)>Removes a key from the map, returning the stored key and value if the key was previously in the map. |
Illustration: insert()
Inserts a key/value pair into the HashMap.
use std::collections::HashMap;
fn main(){
let mut stateCodes = HashMap::new();
stateCodes.insert("KL","Kerala");
stateCodes.insert("MH","Maharashtra");
println!("{:?}",stateCodes);
}
The above program creates a HashMap and initializes it with 2 key-value pairs.
Output
{"KL": "Kerala", "MH": "Maharashtra"}
Illustration: len()
Returns the number of elements in the map
use std::collections::HashMap;
fn main() {
let mut stateCodes = HashMap::new();
stateCodes.insert("KL","Kerala");
stateCodes.insert("MH","Maharashtra");
println!("size of map is {}",stateCodes.len());
}
The above example creates a HashMap and prints the total number of elements in it.
Output
size of map is 2
Illustration – get()
Returns a reference to the value corresponding to the key. The following example retrieves the value for key KL in the HashMap.
use std::collections::HashMap;
fn main() {
let mut stateCodes = HashMap::new();
stateCodes.insert("KL","Kerala");
stateCodes.insert("MH","Maharashtra");
println!("size of map is {}",stateCodes.len());
println!("{:?}",stateCodes);
match stateCodes.get(&"KL") {
Some(value)=> {
println!("Value for key KL is {}",value);
}
None => {
println!("nothing found");
}
}
}
Output
size of map is 2
{"KL": "Kerala", "MH": "Maharashtra"}
Value for key KL is Kerala
Illustration − iter()
Returns an iterator containing reference to all key-value pairs in an arbitrary order.
use std::collections::HashMap;
fn main() {
let mut stateCodes = HashMap::new();
stateCodes.insert("KL","Kerala");
stateCodes.insert("MH","Maharashtra");
for (key, val) in stateCodes.iter() {
println!("key: {} val: {}", key, val);
}
}
Output
key: MH val: Maharashtra key: KL val: Kerala
Illustration: contains_key()
Returns true if the map contains a value for the specified key.
use std::collections::HashMap;
fn main() {
let mut stateCodes = HashMap::new();
stateCodes.insert("KL","Kerala");
stateCodes.insert("MH","Maharashtra");
stateCodes.insert("GJ","Gujarat");
if stateCodes.contains_key(&"GJ") {
println!("found key");
}
}
Output
found key
Illustration: remove()
Removes a key from the map.
use std::collections::HashMap;
fn main() {
let mut stateCodes = HashMap::new();
stateCodes.insert("KL","Kerala");
stateCodes.insert("MH","Maharashtra");
stateCodes.insert("GJ","Gujarat");
println!("length of the hashmap {}",stateCodes.len());
stateCodes.remove(&"GJ");
println!("length of the hashmap after remove() {}",stateCodes.len());
}
Output
length of the hashmap 3 length of the hashmap after remove() 2
HashSet
HashSet is a set of unique values of type T. Adding and removing values is fast, and it is fast to ask whether a given value is in the set or not. The HashSet structure is defined in the std::collections module. This module should be explicitly imported to access the HashSet structure.
Syntax: Creating a HashSet
let mut hash_set_name = HashSet::new();
The static method, new, of HashSet structure, is used to create a HashSet. This method creates an empty HashSet.
The following table lists some of the commonly used methods of the HashSet structure.
| Sr.No | Method | Signature & Description |
|---|---|---|
| 1 | insert() | pub fn insert(&mut self, value: T) -> bool Adds a value to the set. If the set did not have this value present, true is returned else false. |
| 2 | len() | pub fn len(&self) -> usizeReturns the number of elements in the set. |
| 3 | get() | pub fn get<Q:?Sized>(&self, value: &Q) -> Option<&T> where T: Borrow,Q: Hash + Eq,Returns a reference to the value in the set, if any that is equal to the given value. |
| 4 | iter() | pub fn iter(&self) -> IterReturns an iterator visiting all elements in arbitrary order. The iterator element type is &’a T. |
| 5 | contains_key | pub fn contains<Q: ?Sized>(&self, value: &Q) -> boolReturns true if the set contains a value. |
| 6 | remove() | pub fn remove<Q: ?Sized>(&mut self, value: &Q) -> boolRemoves a value from the set. Returns true if the value was present in the set. |
Illustration – insert()
Adds a value to the set. A HashSet does not add duplicate values to the collection.
use std::collections::HashSet;
fn main() {
let mut names = HashSet::new();
names.insert("Mohtashim");
names.insert("Kannan");
names.insert("AdglobPoint");
names.insert("Mohtashim");//duplicates not added
println!("{:?}",names);
}
Output
{"AdglobPoint", "Kannan", "Mohtashim"}
Illustration: len()
Returns the number of elements in the set.
use std::collections::HashSet;
fn main() {
let mut names = HashSet::new();
names.insert("Mohtashim");
names.insert("Kannan");
names.insert("AdglobPoint");
println!("size of the set is {}",names.len());
}
Output
size of the set is 3
Illustration – iter()
Returns an iterator visiting all elements in arbitrary order.
use std::collections::HashSet;
fn main() {
let mut names = HashSet::new();
names.insert("Mohtashim");
names.insert("Kannan");
names.insert("AdglobPoint");
names.insert("Mohtashim");
for name in names.iter() {
println!("{}",name);
}
}
Output
AdglobPoint Mohtashim Kannan
Illustration: get()
Returns a reference to the value in the set, if any, which is equal to the given value.
use std::collections::HashSet;
fn main() {
let mut names = HashSet::new();
names.insert("Mohtashim");
names.insert("Kannan");
names.insert("TutorialsPoint");
names.insert("Mohtashim");
match names.get(&"Mohtashim"){
Some(value)=>{
println!("found {}",value);
}
None =>{
println!("not found");
}
}
println!("{:?}",names);
}
Output
found Mohtashim
{"Kannan", "Mohtashim", "AdglobPoint"}
Illustration – contains()
Returns true if the set contains a value.
use std::collections::HashSet;
fn main() {
let mut names = HashSet::new();
names.insert("Mohtashim");
names.insert("Kannan");
names.insert("AdglobPoint");
if names.contains(&"Kannan") {
println!("found name");
}
}
Output
found name
Illustration: remove()
Removes a value from the set.
use std::collections::HashSet;
fn main() {
let mut names = HashSet::new();
names.insert("Mohtashim");
names.insert("Kannan");
names.insert("AdglobPoint");
println!("length of the Hashset: {}",names.len());
names.remove(&"Kannan");
println!("length of the Hashset after remove() : {}",names.len());
}
Output
length of the Hashset: 3 length of the Hashset after remove() : 2
Next Topic – Click Here
Pingback: Rust - Modules - Adglob Infosystem Pvt Ltd