Struct std::collections::HashSet

pub struct HashSet<T, S = RandomState> { /* fields omitted */ }

hash set，实现为 HashMap，其中值为 ()。

与 HashMap 类型一样，HashSet 要求元素实现 Eq 和 Hash traits。这通常可以通过使用 #[derive(PartialEq, Eq, Hash)] 来实现。 如果您自己实现这些，那么拥有以下属性非常重要：

k1 == k2 -> hash(k1) == hash(k2)

换句话说，如果两个键相等，则它们的哈希值必须相等。

以某种方式修改项目的逻辑错误是由该项目的哈希值 (由 Hash trait 确定) 或其相等性 (由 Eq trait 确定) 在其位于集合中时发生变化的。 通常只有通过 Cell，RefCell，二进制状态，I/O 或不安全代码才能实现此操作。 没有指定由此类逻辑错误导致的行为 (可能包括 panics、不正确的结果、中止、内存泄漏或未终止)，但不会是未定义的行为。

Examples

use std::collections::HashSet;
// 通过类型推断，我们可以省略显式类型签名 (在本示例中为 `HashSet<String>`)。
let mut books = HashSet::new();

// 添加一些书。
books.insert("A Dance With Dragons".to_string());
books.insert("To Kill a Mockingbird".to_string());
books.insert("The Odyssey".to_string());
books.insert("The Great Gatsby".to_string());

// 检查一个特定的。
if !books.contains("The Winds of Winter") {
    println!("We have {} books, but The Winds of Winter ain't one.",
             books.len());
}

// 删除一本书。
books.remove("The Odyssey");

// 遍历所有内容。
for book in &books {
    println!("{}", book);
}

将 HashSet 与自定义类型一起使用的最简单方法是派生 Eq 和 Hash。我们还必须导出 PartialEq，这将在 Eq 中隐含在 future 中。

use std::collections::HashSet;
#[derive(Hash, Eq, PartialEq, Debug)]
struct Viking {
    name: String,
    power: usize,
}

let mut vikings = HashSet::new();

vikings.insert(Viking { name: "Einar".to_string(), power: 9 });
vikings.insert(Viking { name: "Einar".to_string(), power: 9 });
vikings.insert(Viking { name: "Olaf".to_string(), power: 4 });
vikings.insert(Viking { name: "Harald".to_string(), power: 8 });

// 使用派生的实现来打印 Viking。
for x in &vikings {
    println!("{:?}", x);
}

可以从数组初始化具有已知项列表的 HashSet：

use std::collections::HashSet;

let viking_names = HashSet::from(["Einar", "Olaf", "Harald"]);

Implementations

impl<T> HashSet<T, RandomState>

pub fn new() -> HashSet<T, RandomState>

创建一个空的 HashSet。

哈希集最初创建时的容量为 0，因此只有在首次插入时才分配。

Examples

use std::collections::HashSet;
let set: HashSet<i32> = HashSet::new();

pub fn with_capacity(capacity: usize) -> HashSet<T, RandomState>

创建具有指定容量的空 HashSet。

哈希集将能够至少保留 capacity 个元素而无需重新分配。 如果 capacity 为 0，则不会分配哈希集。

Examples

use std::collections::HashSet;
let set: HashSet<i32> = HashSet::with_capacity(10);
assert!(set.capacity() >= 10);

impl<T, S> HashSet<T, S>

pub fn capacity(&self) -> usize

返回集合可以容纳而不重新分配的元素数。

Examples

use std::collections::HashSet;
let set: HashSet<i32> = HashSet::with_capacity(100);
assert!(set.capacity() >= 100);

pub fn iter(&self) -> Iter<'_, T>

一个迭代器，以任意顺序访问所有元素。 迭代器元素类型为 &'a T。

Examples

use std::collections::HashSet;
let mut set = HashSet::new();
set.insert("a");
set.insert("b");

// 将以任意顺序打印。
for x in set.iter() {
    println!("{}", x);
}

pub fn len(&self) -> usize

返回集合中的元素数。

Examples

use std::collections::HashSet;

let mut v = HashSet::new();
assert_eq!(v.len(), 0);
v.insert(1);
assert_eq!(v.len(), 1);

pub fn is_empty(&self) -> bool

如果集合不包含任何元素，则返回 true。

Examples

use std::collections::HashSet;

let mut v = HashSet::new();
assert!(v.is_empty());
v.insert(1);
assert!(!v.is_empty());

pub fn drain(&mut self) -> Drain<'_, T>

清除集合，返回迭代器中的所有元素。

Examples

use std::collections::HashSet;

let mut set: HashSet<_> = [1, 2, 3].iter().cloned().collect();
assert!(!set.is_empty());

// 以任意顺序打印 1、2、3
for i in set.drain() {
    println!("{}", i);
}

assert!(set.is_empty());

pub fn drain_filter<F>(&mut self, pred: F) -> DrainFilter<'_, T, F> where
    F: FnMut(&T) -> bool, 

🔬 This is a nightly-only experimental API. (hash_drain_filter #59618)

创建一个迭代器，该迭代器使用闭包确定是否应删除值。

如果闭包返回 true，则该值将被删除并产生。 如果闭包返回 false，则该值将保留在列表中，并且不会由迭代器产生。

如果迭代器仅被部分消耗或根本没有消耗，则其余所有值仍将受到闭包的处理，如果返回 true，则将其删除并丢弃。

如果在闭包中出现 panic，或者在丢弃值时出现 panic，或者 DrainFilter 本身被泄漏，那么还有多少值将被关闭，这是未指定的。

Examples

将一个集合分为偶数和奇数值，重新使用原始集合：

#![feature(hash_drain_filter)]
use std::collections::HashSet;

let mut set: HashSet<i32> = (0..8).collect();
let drained: HashSet<i32> = set.drain_filter(|v| v % 2 == 0).collect();

let mut evens = drained.into_iter().collect::<Vec<_>>();
let mut odds = set.into_iter().collect::<Vec<_>>();
evens.sort();
odds.sort();

assert_eq!(evens, vec![0, 2, 4, 6]);
assert_eq!(odds, vec![1, 3, 5, 7]);

pub fn clear(&mut self)

清除设置，删除所有值。

Examples

use std::collections::HashSet;

let mut v = HashSet::new();
v.insert(1);
v.clear();
assert!(v.is_empty());

pub fn with_hasher(hasher: S) -> HashSet<T, S>

创建一个新的空哈希集，它将使用给定的哈希值来哈希键。

还使用默认的初始容量创建哈希集。

警告: hasher 通常是随机生成的，旨在允许 HashSet 抵抗导致许多冲突和非常差的性能的攻击。 使用此函数手动设置它可能会导致 DoS 攻击 vector。

传递的 hash_builder 应该为 HashMap 实现 BuildHasher trait 才有用，有关详细信息，请参见其文档。

Examples

use std::collections::HashSet;
use std::collections::hash_map::RandomState;

let s = RandomState::new();
let mut set = HashSet::with_hasher(s);
set.insert(2);

pub fn with_capacity_and_hasher(capacity: usize, hasher: S) -> HashSet<T, S>

创建一个具有指定容量的空 HashSet，使用 hasher 对键进行哈希处理。

哈希集将能够至少保留 capacity 个元素而无需重新分配。如果 capacity 为 0，则不会分配哈希集。

警告: hasher 通常是随机生成的，旨在允许 HashSet 抵抗导致许多冲突和非常差的性能的攻击。 使用此函数手动设置它可能会导致 DoS 攻击 vector。

传递的 hash_builder 应该为 HashMap 实现 BuildHasher trait 才有用，有关详细信息，请参见其文档。

Examples

use std::collections::HashSet;
use std::collections::hash_map::RandomState;

let s = RandomState::new();
let mut set = HashSet::with_capacity_and_hasher(10, s);
set.insert(1);

pub fn hasher(&self) -> &S

返回集合的 BuildHasher 的引用。

Examples

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();

impl<T, S> HashSet<T, S> where
    T: Eq + Hash,
    S: BuildHasher, 

pub fn reserve(&mut self, additional: usize)

保留至少 additional 个要插入 HashSet 中的更多元素的容量。 该集合可以保留更多空间，以避免频繁的重新分配。

Panics

如果新的分配大小溢出 usize，就会出现 panics。

Examples

use std::collections::HashSet;
let mut set: HashSet<i32> = HashSet::new();
set.reserve(10);
assert!(set.capacity() >= 10);

pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

尝试为给 HashSet<K, V> 至少插入 additional 个元素保留容量。 该集合可以保留更多空间，以避免频繁的重新分配。

Errors

如果容量溢出，或者分配器报告失败，则返回错误。

Examples

use std::collections::HashSet;
let mut set: HashSet<i32> = HashSet::new();
set.try_reserve(10).expect("why is the test harness OOMing on 10 bytes?");

pub fn shrink_to_fit(&mut self)

尽可能缩小设备的容量。 它会在保持内部规则的同时尽可能地丢弃，并可能根据调整大小策略留出一些空间。

Examples

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);

pub fn shrink_to(&mut self, min_capacity: usize)

将集合的容量降低一个下限。 它将降低不低于提供的限制，同时保持内部规则，并可能根据调整大小策略留下一些空间。

如果当前容量小于下限，则为无操作。

Examples

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);

pub fn difference<'a>(
    &'a self,
    other: &'a HashSet<T, S>
) -> Difference<'a, T, S>

访问表示差异的值，即，在 self 中但不在 other 中的值。

Examples

use std::collections::HashSet;
let a: HashSet<_> = [1, 2, 3].iter().cloned().collect();
let b: HashSet<_> = [4, 2, 3, 4].iter().cloned().collect();

// 可以看作是 `a - b`。
for x in a.difference(&b) {
    println!("{}", x); // 打印 1
}

let diff: HashSet<_> = a.difference(&b).collect();
assert_eq!(diff, [1].iter().collect());

// 请注意，差异不是对称的，并且 `b - a` 表示其他含义：
let diff: HashSet<_> = b.difference(&a).collect();
assert_eq!(diff, [4].iter().collect());

pub fn symmetric_difference<'a>(
    &'a self,
    other: &'a HashSet<T, S>
) -> SymmetricDifference<'a, T, S>

访问代表对称差异的值，即 self 或 other 中的值，但不能同时存在于两者中。

Examples

use std::collections::HashSet;
let a: HashSet<_> = [1, 2, 3].iter().cloned().collect();
let b: HashSet<_> = [4, 2, 3, 4].iter().cloned().collect();

// 以任意顺序打印 1、4。
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());

pub fn intersection<'a>(
    &'a self,
    other: &'a HashSet<T, S>
) -> Intersection<'a, T, S>

访问表示相交的值，即 self 和 other 中的值。

Examples

use std::collections::HashSet;
let a: HashSet<_> = [1, 2, 3].iter().cloned().collect();
let b: HashSet<_> = [4, 2, 3, 4].iter().cloned().collect();

// 以任意顺序打印 2，3。
for x in a.intersection(&b) {
    println!("{}", x);
}

let intersection: HashSet<_> = a.intersection(&b).collect();
assert_eq!(intersection, [2, 3].iter().collect());

pub fn union<'a>(&'a self, other: &'a HashSet<T, S>) -> Union<'a, T, S>

访问表示并集的值，即 self 或 other 中的所有值，没有重复项。

Examples

use std::collections::HashSet;
let a: HashSet<_> = [1, 2, 3].iter().cloned().collect();
let b: HashSet<_> = [4, 2, 3, 4].iter().cloned().collect();

// 以任意顺序打印 1、2、3、4。
for x in a.union(&b) {
    println!("{}", x);
}

let union: HashSet<_> = a.union(&b).collect();
assert_eq!(union, [1, 2, 3, 4].iter().collect());

pub fn contains<Q: ?Sized>(&self, value: &Q) -> bool where
    T: Borrow<Q>,
    Q: Hash + Eq, 

如果集合包含值，则返回 true。

该值可以是集合值类型的任何借用形式，但是借用形式上的 Hash 和 Eq 必须与值类型的那些匹配。

Examples

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);

pub fn get<Q: ?Sized>(&self, value: &Q) -> Option<&T> where
    T: Borrow<Q>,
    Q: Hash + Eq, 

返回集合中与给定值相等的值的引用。

该值可以是集合值类型的任何借用形式，但是借用形式上的 Hash 和 Eq 必须与值类型的那些匹配。

Examples

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);

pub fn get_or_insert(&mut self, value: T) -> &T

🔬 This is a nightly-only experimental API. (hash_set_entry #60896)

如果给定的 value 不存在，则将其插入集合中，然后对集合中的值返回引用。

Examples

#![feature(hash_set_entry)]

use std::collections::HashSet;

let mut set: HashSet<_> = [1, 2, 3].iter().cloned().collect();
assert_eq!(set.len(), 3);
assert_eq!(set.get_or_insert(2), &2);
assert_eq!(set.get_or_insert(100), &100);
assert_eq!(set.len(), 4); // 插入了 100 个

pub fn get_or_insert_owned<Q: ?Sized>(&mut self, value: &Q) -> &T where
    T: Borrow<Q>,
    Q: Hash + Eq + ToOwned<Owned = T>, 

🔬 This is a nightly-only experimental API. (hash_set_entry #60896)

如果不存在给定的 value，则将其拥有的副本插入到集合中，然后对集合中的值返回引用。

Examples

#![feature(hash_set_entry)]

use std::collections::HashSet;

let mut set: HashSet<String> = ["cat", "dog", "horse"]
    .iter().map(|&pet| pet.to_owned()).collect();

assert_eq!(set.len(), 3);
for &pet in &["cat", "dog", "fish"] {
    let value = set.get_or_insert_owned(pet);
    assert_eq!(value, pet);
}
assert_eq!(set.len(), 4); // 插入了新的 "fish"

pub fn get_or_insert_with<Q: ?Sized, F>(&mut self, value: &Q, f: F) -> &T where
    T: Borrow<Q>,
    Q: Hash + Eq,
    F: FnOnce(&Q) -> T, 

🔬 This is a nightly-only experimental API. (hash_set_entry #60896)

如果不存在给定的 value，则将从 f 计算得出的值插入到集合中，然后对集合中的值返回引用。

Examples

#![feature(hash_set_entry)]

use std::collections::HashSet;

let mut set: HashSet<String> = ["cat", "dog", "horse"]
    .iter().map(|&pet| pet.to_owned()).collect();

assert_eq!(set.len(), 3);
for &pet in &["cat", "dog", "fish"] {
    let value = set.get_or_insert_with(pet, str::to_owned);
    assert_eq!(value, pet);
}
assert_eq!(set.len(), 4); // 插入了新的 "fish"

pub fn is_disjoint(&self, other: &HashSet<T, S>) -> bool

如果 self 与 other 没有共同的元素，则返回 true。 这等效于检查空的交点。

Examples

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);

pub fn is_subset(&self, other: &HashSet<T, S>) -> bool

如果集合是另一个集合的子集，则返回 true，即 other 至少包含 self 中的所有值。

Examples

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);

pub fn is_superset(&self, other: &HashSet<T, S>) -> bool

如果集合是另一个集合的超集，则返回 true，即 self 至少包含 other 中的所有值。

Examples

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);

pub fn insert(&mut self, value: T) -> bool

向集合中添加一个值。

如果集合中不存在该值，则返回 true。

如果集合中确实存在该值，则返回 false。

Examples

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);

pub fn replace(&mut self, value: T) -> Option<T>

向集合中添加一个值，替换等于给定值的现有值 (如果有)。 返回替换值。

Examples

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);

pub fn remove<Q: ?Sized>(&mut self, value: &Q) -> bool where
    T: Borrow<Q>,
    Q: Hash + Eq, 

从集合中删除一个值。返回值是否存在于集合中。

该值可以是集合值类型的任何借用形式，但是借用形式上的 Hash 和 Eq 必须与值类型的那些匹配。

Examples

use std::collections::HashSet;

let mut set = HashSet::new();

set.insert(2);
assert_eq!(set.remove(&2), true);
assert_eq!(set.remove(&2), false);

pub fn take<Q: ?Sized>(&mut self, value: &Q) -> Option<T> where
    T: Borrow<Q>,
    Q: Hash + Eq, 

删除并返回集合中等于给定值的值 (如果有)。

该值可以是集合值类型的任何借用形式，但是借用形式上的 Hash 和 Eq 必须与值类型的那些匹配。

Examples

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);

pub fn retain<F>(&mut self, f: F) where
    F: FnMut(&T) -> bool, 

仅保留谓词指定的元素。

换句话说，删除所有元素 e，以使 f(&e) 返回 false。 元素以未排序 (和未指定) 的顺序访问。

Examples

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);

Trait Implementations

impl<T, S> BitAnd<&'_ HashSet<T, S>> for &HashSet<T, S> where
    T: Eq + Hash + Clone,
    S: BuildHasher + Default, 

fn bitand(self, rhs: &HashSet<T, S>) -> HashSet<T, S>

将 self 和 rhs 的交集返回为新的 HashSet<T, S>。

Examples

use std::collections::HashSet;

let a: HashSet<_> = vec![1, 2, 3].into_iter().collect();
let b: HashSet<_> = vec![2, 3, 4].into_iter().collect();

let set = &a & &b;

let mut i = 0;
let expected = [2, 3];
for x in &set {
    assert!(expected.contains(x));
    i += 1;
}
assert_eq!(i, expected.len());

type Output = HashSet<T, S>

应用 & 运算符后的结果类型。

impl<T, S> BitOr<&'_ HashSet<T, S>> for &HashSet<T, S> where
    T: Eq + Hash + Clone,
    S: BuildHasher + Default, 

fn bitor(self, rhs: &HashSet<T, S>) -> HashSet<T, S>

返回 self 和 rhs 的并集作为新的 HashSet<T, S>。

Examples

use std::collections::HashSet;

let a: HashSet<_> = vec![1, 2, 3].into_iter().collect();
let b: HashSet<_> = vec![3, 4, 5].into_iter().collect();

let set = &a | &b;

let mut i = 0;
let expected = [1, 2, 3, 4, 5];
for x in &set {
    assert!(expected.contains(x));
    i += 1;
}
assert_eq!(i, expected.len());

type Output = HashSet<T, S>

应用 | 运算符后的结果类型。

impl<T, S> BitXor<&'_ HashSet<T, S>> for &HashSet<T, S> where
    T: Eq + Hash + Clone,
    S: BuildHasher + Default, 

fn bitxor(self, rhs: &HashSet<T, S>) -> HashSet<T, S>

返回 self 和 rhs 的对称差作为新的 HashSet<T, S>。

Examples

use std::collections::HashSet;

let a: HashSet<_> = vec![1, 2, 3].into_iter().collect();
let b: HashSet<_> = vec![3, 4, 5].into_iter().collect();

let set = &a ^ &b;

let mut i = 0;
let expected = [1, 2, 4, 5];
for x in &set {
    assert!(expected.contains(x));
    i += 1;
}
assert_eq!(i, expected.len());

type Output = HashSet<T, S>

应用 ^ 运算符后的结果类型。

impl<T, S> Clone for HashSet<T, S> where
    T: Clone,
    S: Clone, 

fn clone(&self) -> Self

返回值的副本。

fn clone_from(&mut self, other: &Self)

从 source 执行复制分配。

impl<T, S> Debug for HashSet<T, S> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

使用给定的格式化程序格式化该值。

impl<T, S> Default for HashSet<T, S> where
    S: Default, 

fn default() -> HashSet<T, S>

用哈希器的 Default 值创建一个空的 HashSet<T, S>。

impl<'a, T, S> Extend<&'a T> for HashSet<T, S> where
    T: 'a + Eq + Hash + Copy,
    S: BuildHasher, 

fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)

使用迭代器的内容扩展集合。

fn extend_one(&mut self, item: &'a T)

🔬 This is a nightly-only experimental API. (extend_one #72631)

用一个元素扩展一个集合。

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one #72631)

在集合中为给定数量的附加元素保留容量。

impl<T, S> Extend<T> for HashSet<T, S> where
    T: Eq + Hash,
    S: BuildHasher, 

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

使用迭代器的内容扩展集合。

fn extend_one(&mut self, item: T)

🔬 This is a nightly-only experimental API. (extend_one #72631)

用一个元素扩展一个集合。

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one #72631)

在集合中为给定数量的附加元素保留容量。

impl<T, const N: usize> From<[T; N]> for HashSet<T, RandomState> where
    T: Eq + Hash, 

fn from(arr: [T; N]) -> Self

Examples

use std::collections::HashSet;

let set1 = HashSet::from([1, 2, 3, 4]);
let set2: HashSet<_> = [1, 2, 3, 4].into();
assert_eq!(set1, set2);

impl<T, S> FromIterator<T> for HashSet<T, S> where
    T: Eq + Hash,
    S: BuildHasher + Default, 

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> HashSet<T, S>

从迭代器创建一个值。

impl<'a, T, S> IntoIterator for &'a HashSet<T, S>

type Item = &'a T

被迭代的元素的类型。

type IntoIter = Iter<'a, T>

我们将其变成哪种迭代器？

fn into_iter(self) -> Iter<'a, T>

从一个值创建一个迭代器。

impl<T, S> IntoIterator for HashSet<T, S>

fn into_iter(self) -> IntoIter<T>

创建一个消耗迭代器，即将每个值以任意顺序移出集合的迭代器。 调用此设置后将无法使用该设置。

Examples

use std::collections::HashSet;
let mut set = HashSet::new();
set.insert("a".to_string());
set.insert("b".to_string());

// 不能与常规 `.iter()` 一起收集到 Vec<String>。
let v: Vec<String> = set.into_iter().collect();

// 将以任意顺序打印。
for x in &v {
    println!("{}", x);
}

type Item = T

被迭代的元素的类型。

type IntoIter = IntoIter<T>

我们将其变成哪种迭代器？

impl<T, S> PartialEq<HashSet<T, S>> for HashSet<T, S> where
    T: Eq + Hash,
    S: BuildHasher, 

fn eq(&self, other: &HashSet<T, S>) -> bool

此方法测试 self 和 other 值是否相等，并由 == 使用。

fn ne(&self, other: &Rhs) -> bool

此方法测试 !=。

impl<T, S> Sub<&'_ HashSet<T, S>> for &HashSet<T, S> where
    T: Eq + Hash + Clone,
    S: BuildHasher + Default, 

fn sub(self, rhs: &HashSet<T, S>) -> HashSet<T, S>

将 self 和 rhs 之差作为新的 HashSet<T, S> 返回。

Examples

use std::collections::HashSet;

let a: HashSet<_> = vec![1, 2, 3].into_iter().collect();
let b: HashSet<_> = vec![3, 4, 5].into_iter().collect();

let set = &a - &b;

let mut i = 0;
let expected = [1, 2];
for x in &set {
    assert!(expected.contains(x));
    i += 1;
}
assert_eq!(i, expected.len());

type Output = HashSet<T, S>

应用 - 运算符后的结果类型。

impl<T, S> Eq for HashSet<T, S> where
    T: Eq + Hash,
    S: BuildHasher,