Struct std::collections::HashSet1.0.0[−][src]

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

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

将 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);
}
Run

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

use std::collections::HashSet;

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

Implementations

创建一个空的 HashSet。

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

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

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

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

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

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

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

一个迭代器，以任意顺序访问所有元素。 迭代器元素类型为 &'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);
}
Run

返回集合中的元素数。

Examples
use std::collections::HashSet;

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

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

Examples
use std::collections::HashSet;

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

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

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());
Run
🔬 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]);
Run

仅保留谓词指定的元素。

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

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.len(), 3);
Run

清除设置，删除所有值。

Examples
use std::collections::HashSet;

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

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

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

警告: 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);
Run

创建一个具有指定容量的空 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);
Run

返回集合的 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();
Run

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

Panics

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

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

尝试为给 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?");
Run

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

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

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

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

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

访问表示差异的值，即，在 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());
Run

访问代表对称差异的值，即 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());
Run

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

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

访问表示并集的值，即 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());
Run

如果集合包含值，则返回 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);
Run

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

该值可以是集合值类型的任何借用形式，但是借用形式上的 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);
Run
🔬 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 个
Run
🔬 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"
Run
🔬 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"
Run

如果 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);
Run

如果集合是另一个集合的子集，则返回 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);
Run

如果集合是另一个集合的超集，则返回 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);
Run

向集合中添加一个值。

如果集合中不存在该值，则返回 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);
Run

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

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

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

该值可以是集合值类型的任何借用形式，但是借用形式上的 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);
Run

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

该值可以是集合值类型的任何借用形式，但是借用形式上的 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);
Run

Trait Implementations

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

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

返回 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());
Run

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

返回 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());
Run

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

返回值的副本。 Read more

从 source 执行复制分配。 Read more

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

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

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

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

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

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

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

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

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

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

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

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

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

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

被迭代的元素的类型。

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

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

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

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

被迭代的元素的类型。

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

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

此方法测试 !=。

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

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

Auto Trait Implementations

Blanket Implementations

获取 self 的 TypeId。 Read more

从拥有的值中一成不变地借用。 Read more

从拥有的值中借用。 Read more

执行转换。

执行转换。

获得所有权后的结果类型。

从借用的数据创建拥有的数据，通常是通过克隆。 Read more

🔬 This is a nightly-only experimental API. (toowned_clone_into #41263)

使用借来的数据来替换拥有的数据，通常是通过克隆。 Read more

发生转换错误时返回的类型。

执行转换。

发生转换错误时返回的类型。

执行转换。