Struct alloc::collections::btree_set::BTreeSet1.0.0[−][src]

pub struct BTreeSet<T> { /* fields omitted */ }
Expand description

基于 B 树的集合。

有关此集合的性能优缺点的详细讨论，请参见 BTreeMap 文档。

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

Examples

use std::collections::BTreeSet;

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

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

// 检查一个特定的。
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

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

use std::collections::BTreeSet;

let set = BTreeSet::from([1, 2, 3]);
Run

Implementations

制作一个新的空 BTreeSet。

不会自行分配任何内容。

Examples
use std::collections::BTreeSet;

let mut set: BTreeSet<i32> = BTreeSet::new();
Run

在集合中元素的子范围上创建一个双端迭代器。 最简单的方法是使用范围语法 min..max，因此 range(min..max) 将产生从最小 (inclusive) 到最大 (exclusive) 的元素。 也可以将范围输入为 (Bound<T>, Bound<T>)，例如 range((Excluded(4), Included(10))) 将产生一个左排他的，范围从 4 到 10。

Examples
use std::collections::BTreeSet;
use std::ops::Bound::Included;

let mut set = BTreeSet::new();
set.insert(3);
set.insert(5);
set.insert(8);
for &elem in set.range((Included(&4), Included(&8))) {
    println!("{}", elem);
}
assert_eq!(Some(&5), set.range(4..).next());
Run

按升序访问表示差异的元素，即在 self 中但不在 other 中的元素。

Examples
use std::collections::BTreeSet;

let mut a = BTreeSet::new();
a.insert(1);
a.insert(2);

let mut b = BTreeSet::new();
b.insert(2);
b.insert(3);

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

按升序访问表示对称差异的元素，即在 self 或 other 中，但不是两者都有。

Examples
use std::collections::BTreeSet;

let mut a = BTreeSet::new();
a.insert(1);
a.insert(2);

let mut b = BTreeSet::new();
b.insert(2);
b.insert(3);

let sym_diff: Vec<_> = a.symmetric_difference(&b).cloned().collect();
assert_eq!(sym_diff, [1, 3]);
Run

按升序访问表示交集的元素，即 self 和 other 中的元素。

Examples
use std::collections::BTreeSet;

let mut a = BTreeSet::new();
a.insert(1);
a.insert(2);

let mut b = BTreeSet::new();
b.insert(2);
b.insert(3);

let intersection: Vec<_> = a.intersection(&b).cloned().collect();
assert_eq!(intersection, [2]);
Run

按升序访问代表 union 的元素，即 self 或 other 中的所有元素，无重复。

Examples
use std::collections::BTreeSet;

let mut a = BTreeSet::new();
a.insert(1);

let mut b = BTreeSet::new();
b.insert(2);

let union: Vec<_> = a.union(&b).cloned().collect();
assert_eq!(union, [1, 2]);
Run

清空 set，删除所有元素。

Examples
use std::collections::BTreeSet;

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

如果集合包含等于该值的元素，则返回 true。

该值可以是集合元素类型的任何借用形式，但借用形式的顺序必须与元素类型的顺序相匹配。

Examples
use std::collections::BTreeSet;

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

返回对集合中元素的引用，如果有，则等于该值。

该值可以是集合元素类型的任何借用形式，但借用形式的顺序必须与元素类型的顺序相匹配。

Examples
use std::collections::BTreeSet;

let set = BTreeSet::from([1, 2, 3]);
assert_eq!(set.get(&2), Some(&2));
assert_eq!(set.get(&4), None);
Run

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

Examples
use std::collections::BTreeSet;

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

let sup = BTreeSet::from([1, 2, 3]);
let mut set = BTreeSet::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::BTreeSet;

let sub = BTreeSet::from([1, 2]);
let mut set = BTreeSet::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
🔬 This is a nightly-only experimental API. (map_first_last #62924)

返回对集合中第一个元素的引用 (如果有)。 该元素始终是集合中所有元素的最小值。

Examples

基本用法：

#![feature(map_first_last)]
use std::collections::BTreeSet;

let mut set = BTreeSet::new();
assert_eq!(set.first(), None);
set.insert(1);
assert_eq!(set.first(), Some(&1));
set.insert(2);
assert_eq!(set.first(), Some(&1));
Run
🔬 This is a nightly-only experimental API. (map_first_last #62924)

返回对集合中最后一个元素的引用 (如果有)。 此元素始终是集合中所有元素的最大值。

Examples

基本用法：

#![feature(map_first_last)]
use std::collections::BTreeSet;

let mut set = BTreeSet::new();
assert_eq!(set.last(), None);
set.insert(1);
assert_eq!(set.last(), Some(&1));
set.insert(2);
assert_eq!(set.last(), Some(&2));
Run
🔬 This is a nightly-only experimental API. (map_first_last #62924)

从集合中移除第一个元素并返回它 (如果有)。 第一个元素始终是集合中的最小元素。

Examples
#![feature(map_first_last)]
use std::collections::BTreeSet;

let mut set = BTreeSet::new();

set.insert(1);
while let Some(n) = set.pop_first() {
    assert_eq!(n, 1);
}
assert!(set.is_empty());
Run
🔬 This is a nightly-only experimental API. (map_first_last #62924)

从集合中移除最后一个元素并返回它 (如果有)。 最后一个元素始终是集合中的最大元素。

Examples
#![feature(map_first_last)]
use std::collections::BTreeSet;

let mut set = BTreeSet::new();

set.insert(1);
while let Some(n) = set.pop_last() {
    assert_eq!(n, 1);
}
assert!(set.is_empty());
Run

向集合中添加一个值。

如果集合中不存在相等的元素，则返回 true。

如果集合确实存在相等的元素，则返回 false，并且不会更新条目。 有关更多信息，请参见 模块级文档。

Examples
use std::collections::BTreeSet;

let mut set = BTreeSet::new();

assert_eq!(set.insert(2), true);
assert_eq!(set.insert(2), false);
assert_eq!(set.len(), 1);
Run

向集合中添加一个值，替换与该值相等的现有元素 (如果有)。 返回被替换的元素。

Examples
use std::collections::BTreeSet;

let mut set = BTreeSet::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

如果该集合包含等于该值的元素，则将其从集合中删除并丢弃它。返回是否存在这样的元素。

该值可以是集合元素类型的任何借用形式，但借用形式的顺序必须与元素类型的顺序相匹配。

Examples
use std::collections::BTreeSet;

let mut set = BTreeSet::new();

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

移除并返回集合中与该值相等的元素 (如果有)。

该值可以是集合元素类型的任何借用形式，但借用形式的顺序必须与元素类型的顺序相匹配。

Examples
use std::collections::BTreeSet;

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

仅保留谓词指定的元素。

换句话说，删除所有元素 e，以使 f(&e) 返回 false。 元素按升序访问。

Examples
use std::collections::BTreeSet;

let mut set = BTreeSet::from([1, 2, 3, 4, 5, 6]);
// 仅保留偶数。
set.retain(|&k| k % 2 == 0);
assert!(set.iter().eq([2, 4, 6].iter()));
Run

将所有元素从 other 移到 Self，将 other 留空。

Examples
use std::collections::BTreeSet;

let mut a = BTreeSet::new();
a.insert(1);
a.insert(2);
a.insert(3);

let mut b = BTreeSet::new();
b.insert(3);
b.insert(4);
b.insert(5);

a.append(&mut b);

assert_eq!(a.len(), 5);
assert_eq!(b.len(), 0);

assert!(a.contains(&1));
assert!(a.contains(&2));
assert!(a.contains(&3));
assert!(a.contains(&4));
assert!(a.contains(&5));
Run

按值将集合拆分为两个。 返回一个新集合，其中所有元素都大于或等于该值。

Examples

基本用法：

use std::collections::BTreeSet;

let mut a = BTreeSet::new();
a.insert(1);
a.insert(2);
a.insert(3);
a.insert(17);
a.insert(41);

let b = a.split_off(&3);

assert_eq!(a.len(), 2);
assert_eq!(b.len(), 3);

assert!(a.contains(&1));
assert!(a.contains(&2));

assert!(b.contains(&3));
assert!(b.contains(&17));
assert!(b.contains(&41));
Run
🔬 This is a nightly-only experimental API. (btree_drain_filter #70530)

创建一个按升序访问所有元素的迭代器，并使用闭包来确定是否应删除元素。

如果闭包返回 true，则该元素将从集合中移除并产生。如果闭包返回 false 或 panics，则该元素保留在集合中，并且不会被产生。

如果迭代器只被部分消耗或者根本没有被消耗，剩余的每个元素仍然会被闭包处理，如果返回 true, 就会被移除和丢弃。

如果在闭包中出现 panic，或者如果在丢弃一个元素时出现 panic，或者如果 DrainFilter 本身被泄露，则未指定多少个元素会受到闭包的影响。

Examples

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

#![feature(btree_drain_filter)]
use std::collections::BTreeSet;

let mut set: BTreeSet<i32> = (0..8).collect();
let evens: BTreeSet<_> = set.drain_filter(|v| v % 2 == 0).collect();
let odds = set;
assert_eq!(evens.into_iter().collect::<Vec<_>>(), vec![0, 2, 4, 6]);
assert_eq!(odds.into_iter().collect::<Vec<_>>(), vec![1, 3, 5, 7]);
Run

获取按升序访问 BTreeSet 中元素的迭代器。

Examples
use std::collections::BTreeSet;

let set = BTreeSet::from([1, 2, 3]);
let mut set_iter = set.iter();
assert_eq!(set_iter.next(), Some(&1));
assert_eq!(set_iter.next(), Some(&2));
assert_eq!(set_iter.next(), Some(&3));
assert_eq!(set_iter.next(), None);
Run

迭代器返回的值以升序返回：

use std::collections::BTreeSet;

let set = BTreeSet::from([3, 1, 2]);
let mut set_iter = set.iter();
assert_eq!(set_iter.next(), Some(&1));
assert_eq!(set_iter.next(), Some(&2));
assert_eq!(set_iter.next(), Some(&3));
assert_eq!(set_iter.next(), None);
Run

返回集合中的元素数。

Examples
use std::collections::BTreeSet;

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

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

Examples
use std::collections::BTreeSet;

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

Trait Implementations

将 self 和 rhs 的交集返回为新的 BTreeSet<T>。

Examples
use std::collections::BTreeSet;

let a = BTreeSet::from([1, 2, 3]);
let b = BTreeSet::from([2, 3, 4]);

let result = &a & &b;
let result_vec: Vec<_> = result.into_iter().collect();
assert_eq!(result_vec, [2, 3]);
Run

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

返回 self 和 rhs 的并集作为新的 BTreeSet<T>。

Examples
use std::collections::BTreeSet;

let a = BTreeSet::from([1, 2, 3]);
let b = BTreeSet::from([3, 4, 5]);

let result = &a | &b;
let result_vec: Vec<_> = result.into_iter().collect();
assert_eq!(result_vec, [1, 2, 3, 4, 5]);
Run

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

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

Examples
use std::collections::BTreeSet;

let a = BTreeSet::from([1, 2, 3]);
let b = BTreeSet::from([2, 3, 4]);

let result = &a ^ &b;
let result_vec: Vec<_> = result.into_iter().collect();
assert_eq!(result_vec, [1, 4]);
Run

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

返回值的副本。 Read more

从 source 执行复制分配。 Read more

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

创建一个空的 BTreeSet。

使用迭代器的内容扩展集合。 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

use std::collections::BTreeSet;

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

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

将该值输入给定的 Hasher。 Read more

将这种类型的切片送入给定的 Hasher 中。 Read more

获取用于移出 BTreeSet 内容的迭代器。

Examples
use std::collections::BTreeSet;

let set = BTreeSet::from([1, 2, 3, 4]);

let v: Vec<_> = set.into_iter().collect();
assert_eq!(v, [1, 2, 3, 4]);
Run

被迭代的元素的类型。

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

被迭代的元素的类型。

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

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

此方法返回 self 和 other 之间的 Ordering。 Read more

比较并返回两个值中的最大值。 Read more

比较并返回两个值中的最小值。 Read more

将值限制在某个时间间隔内。 Read more

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

此方法测试 !=。

如果存在，则此方法返回 self 和 other 值之间的顺序。 Read more

此方法测试的内容少于 (对于 self 和 other)，并且由 < 操作员使用。 Read more

此方法测试小于或等于 (对于 self 和 other)，并且由 <= 运算符使用。 Read more

此方法测试大于 (对于 self 和 other)，并且由 > 操作员使用。 Read more

此方法测试是否大于或等于 (对于 self 和 other)，并且由 >= 运算符使用。 Read more

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

Examples
use std::collections::BTreeSet;

let a = BTreeSet::from([1, 2, 3]);
let b = BTreeSet::from([3, 4, 5]);

let result = &a - &b;
let result_vec: Vec<_> = result.into_iter().collect();
assert_eq!(result_vec, [1, 2]);
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

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

执行转换。

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

执行转换。