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);
Reserves capacity for at least additional
more elements to be inserted
in the HashSet
. The collection may reserve more space to avoid
frequent reallocations.
Panics if the new allocation size overflows usize
.
use std::collections::HashSet;
let mut set: HashSet<i32> = HashSet::new();
set.reserve(10);
assert!(set.capacity() >= 10);
Shrinks the capacity of the set as much as possible. It will drop
down as much as possible while maintaining the internal rules
and possibly leaving some space in accordance with the resize policy.
use std::collections::HashSet;
let mut set = HashSet::with_capacity(100);
set.insert(1);
set.insert(2);
assert!(set.capacity() >= 100);
set.shrink_to_fit();
assert!(set.capacity() >= 2);
🔬 This is a nightly-only experimental API. (shrink_to
)
new API
Shrinks the capacity of the set with a lower limit. It will drop
down no lower than the supplied limit while maintaining the internal rules
and possibly leaving some space in accordance with the resize policy.
Panics if the current capacity is smaller than the supplied
minimum capacity.
#![feature(shrink_to)]
use std::collections::HashSet;
let mut set = HashSet::with_capacity(100);
set.insert(1);
set.insert(2);
assert!(set.capacity() >= 100);
set.shrink_to(10);
assert!(set.capacity() >= 10);
set.shrink_to(0);
assert!(set.capacity() >= 2);
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());
Clears the set, returning all elements in an iterator.
use std::collections::HashSet;
let mut set: HashSet<_> = [1, 2, 3].iter().cloned().collect();
assert!(!set.is_empty());
for i in set.drain() {
println!("{}", i);
}
assert!(set.is_empty());
Clears the set, removing all values.
use std::collections::HashSet;
let mut v = HashSet::new();
v.insert(1);
v.clear();
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);
Adds a value to the set.
If the set did not have this value present, true
is returned.
If the set did have this value present, false
is returned.
use std::collections::HashSet;
let mut set = HashSet::new();
assert_eq!(set.insert(2), true);
assert_eq!(set.insert(2), false);
assert_eq!(set.len(), 1);
Adds a value to the set, replacing the existing value, if any, that is equal to the given
one. Returns the replaced value.
use std::collections::HashSet;
let mut set = HashSet::new();
set.insert(Vec::<i32>::new());
assert_eq!(set.get(&[][..]).unwrap().capacity(), 0);
set.replace(Vec::with_capacity(10));
assert_eq!(set.get(&[][..]).unwrap().capacity(), 10);
Removes a value from the set. Returns true
if the value was
present in the set.
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 mut set = HashSet::new();
set.insert(2);
assert_eq!(set.remove(&2), true);
assert_eq!(set.remove(&2), false);
Removes and returns the value in the set, if any, that is equal to the given one.
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 mut set: HashSet<_> = [1, 2, 3].iter().cloned().collect();
assert_eq!(set.take(&2), Some(2));
assert_eq!(set.take(&2), None);
Retains only the elements specified by the predicate.
In other words, remove all elements e
such that f(&e)
returns false
.
use std::collections::HashSet;
let xs = [1,2,3,4,5,6];
let mut set: HashSet<i32> = xs.iter().cloned().collect();
set.retain(|&k| k % 2 == 0);
assert_eq!(set.len(), 3);