Returns a reference to the set's BuildHasher
.
use std::collections::HashSet;
use std::collections::hash_map::RandomState;
let hasher = RandomState::new();
let set: HashSet<i32> = HashSet::with_hasher(hasher);
let hasher: &RandomState = set.hasher();
Returns the number of elements the set can hold without reallocating.
use std::collections::HashSet;
let set: HashSet<i32> = HashSet::with_capacity(100);
assert!(set.capacity() >= 100);
An iterator visiting all elements in arbitrary order.
The iterator element type is &'a T
.
use std::collections::HashSet;
let mut set = HashSet::new();
set.insert("a");
set.insert("b");
for x in set.iter() {
println!("{}", x);
}
Visits the values representing the difference,
i.e. the values that are in self
but not in other
.
use std::collections::HashSet;
let a: HashSet<_> = [1, 2, 3].iter().cloned().collect();
let b: HashSet<_> = [4, 2, 3, 4].iter().cloned().collect();
for x in a.difference(&b) {
println!("{}", x);
}
let diff: HashSet<_> = a.difference(&b).collect();
assert_eq!(diff, [1].iter().collect());
let diff: HashSet<_> = b.difference(&a).collect();
assert_eq!(diff, [4].iter().collect());
Visits the values representing the symmetric difference,
i.e. the values that are in self
or in other
but not in both.
use std::collections::HashSet;
let a: HashSet<_> = [1, 2, 3].iter().cloned().collect();
let b: HashSet<_> = [4, 2, 3, 4].iter().cloned().collect();
for x in a.symmetric_difference(&b) {
println!("{}", x);
}
let diff1: HashSet<_> = a.symmetric_difference(&b).collect();
let diff2: HashSet<_> = b.symmetric_difference(&a).collect();
assert_eq!(diff1, diff2);
assert_eq!(diff1, [1, 4].iter().collect());
Visits the values representing the intersection,
i.e. the values that are both in self
and other
.
use std::collections::HashSet;
let a: HashSet<_> = [1, 2, 3].iter().cloned().collect();
let b: HashSet<_> = [4, 2, 3, 4].iter().cloned().collect();
for x in a.intersection(&b) {
println!("{}", x);
}
let intersection: HashSet<_> = a.intersection(&b).collect();
assert_eq!(intersection, [2, 3].iter().collect());
Visits the values representing the union,
i.e. all the values in self
or other
, without duplicates.
use std::collections::HashSet;
let a: HashSet<_> = [1, 2, 3].iter().cloned().collect();
let b: HashSet<_> = [4, 2, 3, 4].iter().cloned().collect();
for x in a.union(&b) {
println!("{}", x);
}
let union: HashSet<_> = a.union(&b).collect();
assert_eq!(union, [1, 2, 3, 4].iter().collect());
Returns the number of elements in the set.
use std::collections::HashSet;
let mut v = HashSet::new();
assert_eq!(v.len(), 0);
v.insert(1);
assert_eq!(v.len(), 1);
Returns true if the set contains no elements.
use std::collections::HashSet;
let mut v = HashSet::new();
assert!(v.is_empty());
v.insert(1);
assert!(!v.is_empty());
Returns true
if the set contains a value.
The value may be any borrowed form of the set's value type, but
Hash
and Eq
on the borrowed form must match those for
the value type.
use std::collections::HashSet;
let set: HashSet<_> = [1, 2, 3].iter().cloned().collect();
assert_eq!(set.contains(&1), true);
assert_eq!(set.contains(&4), false);
Returns a reference to the value in the set, if any, that is equal to the given value.
The value may be any borrowed form of the set's value type, but
Hash
and Eq
on the borrowed form must match those for
the value type.
use std::collections::HashSet;
let set: HashSet<_> = [1, 2, 3].iter().cloned().collect();
assert_eq!(set.get(&2), Some(&2));
assert_eq!(set.get(&4), None);
Returns true
if self
has no elements in common with other
.
This is equivalent to checking for an empty intersection.
use std::collections::HashSet;
let a: HashSet<_> = [1, 2, 3].iter().cloned().collect();
let mut b = HashSet::new();
assert_eq!(a.is_disjoint(&b), true);
b.insert(4);
assert_eq!(a.is_disjoint(&b), true);
b.insert(1);
assert_eq!(a.is_disjoint(&b), false);
Returns true
if the set is a subset of another,
i.e. other
contains at least all the values in self
.
use std::collections::HashSet;
let sup: HashSet<_> = [1, 2, 3].iter().cloned().collect();
let mut set = HashSet::new();
assert_eq!(set.is_subset(&sup), true);
set.insert(2);
assert_eq!(set.is_subset(&sup), true);
set.insert(4);
assert_eq!(set.is_subset(&sup), false);
Returns true
if the set is a superset of another,
i.e. self
contains at least all the values in other
.
use std::collections::HashSet;
let sub: HashSet<_> = [1, 2].iter().cloned().collect();
let mut set = HashSet::new();
assert_eq!(set.is_superset(&sub), false);
set.insert(0);
set.insert(1);
assert_eq!(set.is_superset(&sub), false);
set.insert(2);
assert_eq!(set.is_superset(&sub), true);