Struct std::collections::hash_set::HashSet

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

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

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

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

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

以这样一种方式修改键是一个逻辑错误，即键的哈希 (由 Hash 特征确定) 或其相等性 (由 Eq 特征确定) 在更改时发生变化在 map 上。 通常只有通过 Cell，RefCell，二进制状态，I/O 或不安全代码才能实现此操作。 此类逻辑错误导致的行为未指定，但会封装到观察到逻辑错误的 HashSet 中，不会导致未定义的行为。 这可能包括 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 更多的元素。 如果 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}");
}

Performance

在当前的实现中，迭代集合需要 O(capacity) 时间而不是 O(len) 时间，因为它在内部也访问了空的 buckets。

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::from([1, 2, 3]);
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 retain<F>(&mut self, f: F)where F: FnMut(&T) -> bool,

仅保留谓词指定的元素。

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

Examples

use std::collections::HashSet;

let mut set = HashSet::from([1, 2, 3, 4, 5, 6]);
set.retain(|&k| k % 2 == 0);
assert_eq!(set, HashSet::from([2, 4, 6]));

Performance

在当前的实现中，这个操作需要 O(capacity) 时间而不是 O(len)，因为它在内部也访问了空的 buckets。

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 更多的元素。 如果 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 中的更多元素的容量。集合可以保留更多空间来推测性地避免频繁的重新分配。

调用 reserve 后，容量将大于或等于 self.len() + additional。 如果容量已经足够，则不执行任何操作。

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 中的至少 additional 更多元素保留容量。集合可以保留更多空间来推测性地避免频繁的重新分配。

调用 try_reserve 后，如果返回 Ok(())，容量将大于等于 self.len() + 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 a handful of 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::from([1, 2, 3]);
let b = HashSet::from([4, 2, 3, 4]);

// 可以看作是 `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::from([1, 2, 3]);
let b = HashSet::from([4, 2, 3, 4]);

// 以任意顺序打印 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 中的值。

当 self 和 other 中存在相等的元素时，生成的 Intersection 可能会引用其中一个。 如果 T 包含未通过其 Eq 实现进行比较的字段，并且可能在两组 T 的两个相等副本之间保持不同的值，则这可能是相关的。

Examples

use std::collections::HashSet;
let a = HashSet::from([1, 2, 3]);
let b = HashSet::from([4, 2, 3, 4]);

// 以任意顺序打印 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::from([1, 2, 3]);
let b = HashSet::from([4, 2, 3, 4]);

// 以任意顺序打印 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>(&self, value: &Q) -> boolwhere T: Borrow<Q>, Q: Hash + Eq + ?Sized,

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

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

Examples

use std::collections::HashSet;

let set = HashSet::from([1, 2, 3]);
assert_eq!(set.contains(&1), true);
assert_eq!(set.contains(&4), false);

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

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

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

Examples

use std::collections::HashSet;

let set = HashSet::from([1, 2, 3]);
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::from([1, 2, 3]);
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>(&mut self, value: &Q) -> &Twhere T: Borrow<Q>, Q: Hash + Eq + ToOwned<Owned = T> + ?Sized,

🔬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, F>(&mut self, value: &Q, f: F) -> &Twhere T: Borrow<Q>, Q: Hash + Eq + ?Sized, 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::from([1, 2, 3]);
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::from([1, 2, 3]);
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::from([1, 2]);
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>(&mut self, value: &Q) -> boolwhere T: Borrow<Q>, Q: Hash + Eq + ?Sized,

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

该值可以是集合值类型的任何借用形式，但是借用形式上的 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>(&mut self, value: &Q) -> Option<T>where T: Borrow<Q>, Q: Hash + Eq + ?Sized,

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

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

Examples

use std::collections::HashSet;

let mut set = HashSet::from([1, 2, 3]);
assert_eq!(set.take(&2), Some(2));
assert_eq!(set.take(&2), None);

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::from([1, 2, 3]);
let b = HashSet::from([2, 3, 4]);

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::from([1, 2, 3]);
let b = HashSet::from([3, 4, 5]);

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::from([1, 2, 3]);
let b = HashSet::from([3, 4, 5]);

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::from([1, 2, 3]);
let b = HashSet::from([3, 4, 5]);

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,