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

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

hash set,实现为 HashMap,其中值为 ()

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

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

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

以某种方式修改项目的逻辑错误是由该项目的哈希值 (由 Hash trait 确定) 或其相等性 (由 Eq trait 确定) 在其位于集合中时发生变化的。 通常只有通过 CellRefCell,二进制状态,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 与自定义类型一起使用的最简单方法是派生 EqHash。我们还必须导出 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<_> = [1, 2, 3].iter().cloned().collect();
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

清除设置,删除所有值。

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

访问代表对称差异的值,即 selfother 中的值,但不能同时存在于两者中。

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

访问表示相交的值,即 selfother 中的值。

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

访问表示并集的值,即 selfother 中的所有值,没有重复项。

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

如果集合包含值,则返回 true

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

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

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

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

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);
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<_> = [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 个
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

如果 selfother 没有共同的元素,则返回 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);
Run

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

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

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

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

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

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

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

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

仅保留谓词指定的元素。

换句话说,删除所有元素 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);
Run

Trait Implementations

selfrhs 的交集返回为新的 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());
Run

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

返回 selfrhs 的并集作为新的 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());
Run

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

返回 selfrhs 的对称差作为新的 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());
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

被迭代的元素的类型。

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

此方法测试 selfother 值是否相等,并由 == 使用。 Read more

此方法测试 !=

selfrhs 之差作为新的 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());
Run

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

Auto Trait Implementations

Blanket Implementations

获取 selfTypeIdRead more

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

从拥有的值中借用。 Read more

执行转换。

执行转换。

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

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

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

recently added

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

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

执行转换。

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

执行转换。