Vector 如何向Rust中向量的每个元素添加相同的整数？

在Python中，如果我有一个列表，并希望在每个元素中添加10，我将执行以下操作：

bar=[2,4,5,6,7]
bar=[x+10表示x英寸bar]

---

导致：

[12,14,15,16,17]

。如何在生锈的情况下实现这一点？执行for循环并遍历每个向量元素是唯一的方法吗？

执行此操作的方法与Python非常相似：使用迭代器！与Python的列表理解大致相当的是

iter:：map

以获取新元素，以及

iter:：collect

以收集到新的向量（或某种其他类型的集合）

因此，例如，如果

bar

是

Vec

（或任何其他基本整数类型），并且您希望向每个元素添加10，请尝试

bar = bar.into_iter().map(|x| x + 10).collect();

或者，您可以使用

bar.iter_mut().for_each(|x| *x += 10);

这基本上类似于for循环，但更简洁一些。这通常比第一种方法更有效，因为您不需要分配新的向量（一个足够聪明的编译器可能能够避免这种情况）。唯一的缺点是这个版本不太灵活。输出仍然需要是一个向量；您无法切换到哈希集或您拥有的内容。您也无法保存旧向量的副本。下面是一些可能的例子

fn main() {
    let mut bar = vec![2, 4, 5, 6, 7];
    // Overwrite the old vector
    bar = bar.into_iter().map(|x| x + 10).collect();
    println!("new bar: {:?}", bar);

    let bar = vec![2, 4, 5, 6, 7];
    // Make a completely new vector
    // Note that this works only because i32 implements the Copy trait,
    // so we can make copies of the elements of bar without any problems
    // In more general situations, we may need to clone each element
    let foo: Vec<_> = bar.iter().map(|&x| x + 10).collect();
    println!("old bar: {:?} (it's still around)", bar);
    println!("new foo: {:?}", foo);

    use std::collections::HashSet;
    let bar = vec![2, 4, 5, 6, 7];
    // transform the data and collect it into a HashSet
    // instead of a vector
    let bar: HashSet<_> = bar.into_iter().map(|x| x + 10).collect();
    println!("new bar: {:?} (note that now bar is unordered)", bar);

    let mut bar = vec![2, 4, 5, 6, 7];
    // Overwrite the old vector in place
    bar.iter_mut().for_each(|x| *x += 10);
    println!("new bar: {:?}", bar);
}

fn main（）{
让mut bar=vec！[2,4,5,6,7]；
//覆盖旧向量
bar=bar.into_iter（）.map（|x | x+10）.collect（）；
println！（“新条：{：？}”，条）；
设bar=vec！[2,4,5,6,7]；
//做一个全新的向量
//请注意，这只是因为i32实现了复制特性，
//所以我们可以毫无问题地复制酒吧的元素
//在更一般的情况下，我们可能需要克隆每个元素
让foo:Vec=bar.iter（）；
println！（“旧酒吧：{：？}（它还在附近）”，酒吧；
println！（“新foo:{：？}”，foo）；
使用std:：collections:：HashSet；
设bar=vec！[2,4,5,6,7]；
//转换数据并将其收集到哈希集
//而不是向量
让bar:HashSet=bar.into_iter（）.map（|x | x+10）.collect（）；
println！（“新条：{：？}（注意现在条是无序的）”，条；
让mut bar=vec！[2,4,5,6,7]；
//就地覆盖旧向量
对于每个（|x |*x+=10）的iter_mut（）；
println！（“新条：{：？}”，条）；
}

---

这是一段基本代码，说明了如何按照问题默认设置的方式进行操作。对于像我这样生锈的初学者来说，这可能很有用：

fn increment_mut(p: &mut Vec<i32>, to_add: i32){
    for i in 0..p.len() {
        p[i] += to_add;
    }
}

fn main() {
    let mut p = vec![2, 4, 5, 6, 7];
    increment_mut(&mut p, 10);

    // Print the complete vector in Debug.
    println!("{:?}", p)
}

使用

iter\u mut

---

谢谢，我只是不明白答案的一部分。当你说“唯一的缺点是这个版本不太灵活。输出仍然需要是一个向量；你不能切换到散列集或你所拥有的东西。”你说的不灵活和输出需要是一个向量是什么意思？如果hashSet方法的目标是始终使用向量，那么它的优势是什么？@Miguel有时目标不是始终使用向量。或者，即使您仍在使用向量，如果基础数据的类型发生变化，您也需要一个全新的向量。例如，如果

strings

是

Vec

类型的向量，则您将无法执行

字符串。对于_each（）.map（|s |*s=s.len（））

，因为这将更改每个字符串的类型和向量的整体。如果可能，首选迭代器。由于检查越界访问，直接索引访问可能会产生开销<代码>&mut-Vec是非惯用的（）。存在自修改运算符（

+=

）

p.iter（）

通常写为

&

。在printing for loop（）中不需要取消引用。非常感谢您的建议和修订@Shepmaster，我将深入研究并尝试改进此代码。

fn increment_mut2(p: &mut Vec<i32>, to_add: i32) {
    for x in p.iter_mut() {
        *x += to_add;
    }
}

fn main() {
    let mut p = vec![2, 4, 5, 6, 7];
    increment_mut2(&mut p, 10);

    // Print the complete vector in Debug.
    println!("{:?}", p)
}