Rust Tutorial : Collections
from tutorialspoint.com

Vector
Vector Definition
a Vector is a resizable array
it stores values in contiguous memory blocks
the predefined structure Vec can be used to create vectors
important features of a Vector
  • 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
    zero-based index
  • a Vector will only append values to (or near) the end
    a Vector can be used to implement a stack
  • memory for a Vector is allocated in the heap
Syntax - Creating a Vector
the static method new() of the Vecstructure is used to create a vector instance 
let mut instance_name = Vec::new();
a vector can also be created using the vec! macro 
let vector_name = vec![val1,val2,val3]
some commonly used functions of the Vec structure

Method Signature & Description
new() pub fn new()->Vect
constructs a new, empty Vec
the vector will not allocate until elements are pushed onto it
push() pub fn push(&mut self, value: T)
appends an element to the back of a collection
remove() pub fn remove(&mut self, index: usize) -> T
removes and returns the element at position index within the vector, shifting all elements after it to the left
contains() pub fn contains(&self, x: &T) -> bool
returns true if the slice contains an element with the given value
len() pub fn len(&self) -> usize
returns the number of elements in the vector, also referred to as its 'length'
Creating a Vector - new()
to create a vector use the static method new
example creates a Vector using the static method new() that is defined in structure Vec
the push(val) function appends the value passed as parameter to the collection
the len() function returns the length of the vector 
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);
}
output 
size of vector is :3
[20, 30, 40]
Creating a Vector - vec! Macro
code creates a vector using the vec! macro
a vector can only contain values of the same data type
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);
}
push()
appends an element to the end of the collection 
fn main() {
   let mut v = Vec::new();
   v.push(20);
   v.push(30);
   v.push(40);
   
   println!("{:?}",v);
}
output 
[20, 30, 40]
remove()
removes and returns the element at position index within the vector
shifts all elements after it to the left 
fn main() {
   let mut v = vec![10,20,30];
   v.remove(1);
   println!("{:?}",v);
}
output 
[10, 30]
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]
len()
returns the number of elements in the vector 
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
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);
   // prints '20' 
   println!("{:?}",v[0]);
}
values in a vector can also be fetched using 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
HashMap Definition
a map is a collection of key-value pairs (called entries)
no two entries in a map can have the same key
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
module should be explicitly imported to access the HashMap structure

Syntax: Creating a HashMap
the static method new() of the HashMap structure is used to create a HashMap object
method creates an empty HashMap 
let mut instance_name = HashMap::new();
commonly used functions of HashMap

Method Signature & Description
insert() 
pub fn insert(&mut self, k: K, v: V) -> Option
inserts a key/value pair, if no key then None is returned. After update, old value is returned
len() 
pub fn len(&self) -> usize
returns the number of elements in the map
get() 
pub fn get<Q: ?Sized>(&lself, k: &Q) -> Option<&V> 
    where K:Borrow Q:Hash+ Eq
returns a reference to the value corresponding to the key
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)
contains_key 
pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool
returns true if the map contains a value for the specified key
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

insert()
create a HashMap and initializes it with 2 key-value pairs 
use std::collections::HashMap;
fn main(){
   let mut stateCodes = HashMap::new();
   stateCodes.insert("KL","Kerala");
   stateCodes.insert("MH","Maharashtra");
   println!("{:?}",stateCodes);
}
output 
{"KL": "Kerala", "MH": "Maharashtra"}
len()
creates a HashMap and prints the total 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());
}
output 
size of map is 2
get()
returns a reference to the value corresponding to the key
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
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
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");
   }
}
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());
}
HashSet
HashSet Definition
HashSet is a set of unique values of type T
adding and removing values is fast
is fast to ask whether a given value is in the set or not
the HashSet structure is defined in the std::collections module
module should be explicitly imported to access the HashSet structure

Creating a HashSet
the static method new() of the HashSet structure is used to create a HashSet
method creates an empty HashSet

commonly used methods of the HashSet structure

Method Signature & Description
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.
len() 
pub fn len(&self) -> usize
returns the number of elements in the set
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
iter() 
pub fn iter(&self) -> Iter
returns an iterator visiting all elements in arbitrary order
the iterator element type is &'a T.
contains_key 
pub fn contains<Q: ?Sized>(&self, value: &Q) -> bool
returns true if the set contains a value
remove() 
pub fn remove<Q: ?Sized>(&mut self, value: &Q) -> bool
removes a value from the set
returns true if the value was present in the set
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("TutorialsPoint");
   names.insert("Mohtashim");//duplicates not added

   println!("{:?}",names);
}
output 
{"TutorialsPoint", "Kannan", "Mohtashim"}
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("TutorialsPoint");
   println!("size of the set is {}",names.len());
}
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("TutorialsPoint");
   names.insert("Mohtashim");

   for name in names.iter() {
      println!("{}",name);
   }
}
output 
TutorialsPoint
Mohtashim
Kannan
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", "TutorialsPoint"}
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("TutorialsPoint");

   if names.contains(&"Kannan") {
      println!("found name");
   }  
}
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("TutorialsPoint");
   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
index