Struct std::collections::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

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

访问代表并集的值，即 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

清除设置，删除所有值。

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<_> = [1, 2, 3].iter().cloned().collect();
assert_eq!(set.contains(&1), true);
assert_eq!(set.contains(&4), false);
Run

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

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

Examples

use std::collections::BTreeSet;

let set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
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<_> = [1, 2, 3].iter().cloned().collect();
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<_> = [1, 2, 3].iter().cloned().collect();
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<_> = [1, 2].iter().cloned().collect();
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，并且不会更新该条目。 有关更多信息，请参见 module-level documentation。

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<_> = [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::BTreeSet;

let xs = [1, 2, 3, 4, 5, 6];
let mut set: BTreeSet<i32> = xs.iter().cloned().collect();
// 仅保留偶数。
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<usize> = [1, 2, 3].iter().cloned().collect();
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<usize> = [3, 1, 2].iter().cloned().collect();
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<_> = vec![1, 2, 3].into_iter().collect();
let b: BTreeSet<_> = vec![2, 3, 4].into_iter().collect();

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<_> = vec![1, 2, 3].into_iter().collect();
let b: BTreeSet<_> = vec![3, 4, 5].into_iter().collect();

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<_> = vec![1, 2, 3].into_iter().collect();
let b: BTreeSet<_> = vec![2, 3, 4].into_iter().collect();

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

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

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

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

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

Examples

use std::collections::BTreeSet;

let set: BTreeSet<usize> = [1, 2, 3, 4].iter().cloned().collect();

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<_> = vec![1, 2, 3].into_iter().collect();
let b: BTreeSet<_> = vec![3, 4, 5].into_iter().collect();

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)

recently added

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

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

执行转换。

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

执行转换。