Rust 基础集合操作命令式 vs 函数式实现对比归纳笔记

1.遍历打印Vec<T>的所有元素

命令式实现：

let nums = vec![1, 2, 3, 4, 5];

for num in &nums {
    println!("元素: {}", num);
}

函数式实现：

let nums = vec![1, 2, 3, 4, 5];

nums.iter().for_each(|num| println!("元素: {}", num));

2. 过滤 + 映射（保留偶数并乘 10）

命令式实现：

let nums = vec![1, 2, 3, 4, 5, 6];

let mut res = Vec::new();
for num in nums {
    if num % 2 == 0 {
        res.push(num * 10);
    }
}
println!("{:?}", res); // [20, 40, 60]

函数式实现：

let nums = vec![1, 2, 3, 4, 5, 6];

let res: Vec<i32> = nums
    .iter()
    .filter(|&num| num % 2 == 0)
    .map(|num| num * 10)
    .collect();
println!("{:?}", res); // [20, 40, 60]

3. 元素求和

命令式实现：

let nums = vec![1, 2, 3, 4, 5];

let mut sum = 0;
for num in nums {
    sum += num;
}
println!("和: {}", sum); // 15

函数式实现：

let nums = vec![1, 2, 3, 4, 5];

let sum: i32 = nums.iter().sum();
println!("和: {}", sum); // 15

4. 修改原数组元素（每个元素乘 2）

命令式实现：

let mut nums = vec![1, 2, 3];

for num in &mut nums {
    *num *= 2;
}
println!("{:?}", nums); // [2, 4, 6]

函数式实现：

let mut nums = vec![1, 2, 3];

nums.iter_mut().for_each(|num| *num *= 2);
println!("{:?}", nums); // [2, 4, 6]

5.遍历HashMap所有键值对

命令式实现：

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, "A".to_string());
map.insert(2, "B".to_string());

for (key, value) in &map {
    println!("key: {}, value: {}", key, value);
}

函数式实现：

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, "A".to_string());
map.insert(2, "B".to_string());

map.iter().for_each(|(key, value)| {
    println!("key: {}, value: {}", key, value);
});

6.HashMap根据 ID 集合提取对应 Value（克隆）

命令式实现：

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, "A".to_string());
map.insert(2, "B".to_string());
map.insert(3, "C".to_string());
let target_ids = vec![1, 3];

let mut values = Vec::new();
for &id in &target_ids {
    if let Some(v) = map.get(&id) {
        values.push(v.clone());
    }
}
println!("{:?}", values); // ["A", "C"]

函数式实现：

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, "A".to_string());
map.insert(2, "B".to_string());
map.insert(3, "C".to_string());
let target_ids = vec![1, 3];

let values: Vec<String> = target_ids
    .iter()
    .filter_map(|&id| map.get(&id).cloned())
    .collect();
println!("{:?}", values); // ["A", "C"]

7.HashMap过滤并收集符合条件的键值对

命令式实现：

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, 5);
map.insert(2, 15);
map.insert(3, 20);

let mut filtered_map = HashMap::new();
for (key, value) in map {
    if value > 10 {
        filtered_map.insert(key, value);
    }
}
println!("{:?}", filtered_map); // {2: 15, 3: 20}

函数式实现：

//获取所有权，消耗原集合版本：
use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, 5);
map.insert(2, 15);
map.insert(3, 20);

let filtered_map: HashMap<u64, i32> = map
    .into_iter()
    .filter(|(_, v)| *v > 10)
    .collect();
println!("{:?}", filtered_map); // {2: 15, 3: 20}

//不获取原集合所有权，不消耗元集合版本：
use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, 5);
map.insert(2, 15);
map.insert(3, 20);

let filtered_map: HashMap<&u64, &i32> = map
    .iter()
    .filter(|(_, v)| **v > 10)
    .collect();
println!("{:?}", filtered_map); // {2: 15, 3: 20}

//不获取原集合所有权，不消耗原集合，collect创建集合元素为非引用类型：
use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, 5);
map.insert(2, 15);
map.insert(3, 20);

let filtered_map: HashMap<u64, i32> = map
    .iter()
    .filter(|(_, v)| **v > 10)
    .map(|(k,v)|(k.clone(), v.clone()))
    .collect();
println!("{:?}", filtered_map); // {2: 15, 3: 20}

8.扁平化嵌套数组Vec<Vec<i32>>并去重

命令式实现：

let nested = vec![vec![1, 2, 2], vec![3, 4, 3]];

use std::collections::HashSet;
let mut set = HashSet::new();
for inner in nested {
    for num in inner {
        set.insert(num);
    }
}
let flat_unique: Vec<i32> = set.into_iter().collect();
println!("{:?}", flat_unique); // [1, 2, 3, 4]

函数式实现：

let nested = vec![vec![1, 2, 2], vec![3, 4, 3]];

let mut flattened: Vec<_> = nested.into_iter().flatten().collect();
let _= flattened.sort();
let _ = flattened.dedup();
println!("{:?}", flattened); // [1, 2, 3, 4]

//另一种函数式实现方法：
let nested = vec![vec![1, 2, 2], vec![3, 4, 3]];

use std::collections::HashSet;
let flat_unique: Vec<i32> = nested
    .into_iter()
    .flat_map(|inner| inner.into_iter()) // 扁平化嵌套迭代器
    .collect::<HashSet<_>>() // 去重
    .into_iter()
    .collect();
println!("{:?}", flat_unique); // [1, 2, 3, 4]

//不获取原集合所有权，不消耗原集合：
let nested = vec![vec![1, 2, 2], vec![3, 4, 3]];

use std::collections::HashSet;
let flat_unique: Vec<&i32> = nested
    .iter()
    .flat_map(|inner| inner.iter()) // 扁平化嵌套迭代器
    .collect::<HashSet<_>>() // 去重
    .into_iter()
    .collect();
println!("{:?}", flat_unique); // [1, 2, 3, 4]

9.Vec查找元素

命令式实现：

let names = vec!["Alice", "Bob", "Charlie"];
let mut found = None;
for name in &names {
    if name.starts_with('C') {
        found = Some(name);
        break;
    }
}
println!("cmd style:{:?}", found);

函数式实现：

let names = vec!["Alice", "Bob", "Charlie"];

let found = names.iter().find(|name| name.starts_with('C'));
println!("function style:{:?}", found);

10.Vec转换并收集为Map

命令式实现：

use std::collections::HashMap;

// 命令式风格
let names = vec!["Alice", "Bob", "Charlie"];
let mut name_map = HashMap::new();
for (i, name) in names.iter().enumerate() {
    name_map.insert(i, name.to_string());
}
println!("{:?}", name_map);

函数式实现：

use std::collections::HashMap;

let names = vec!["Alice", "Bob", "Charlie"];
let name_map: HashMap<_, _> = names.iter()
    .enumerate()
    .map(|(i, name)| (i, name.to_string()))
    .collect();
    
println!("{:?}", name_map);

11.Vec分组操作

命令式实现：

let numbers = vec![1, 2, 3, 4, 5, 6];
let mut groups = (Vec::new(), Vec::new());
for n in numbers {
    if n % 2 == 0 {
        groups.0.push(n);
    } else {
        groups.1.push(n);
    }
}
println!("{:?}", groups);

函数式实现：

let numbers = vec![1, 2, 3, 4, 5, 6];
let (evens, odds): (Vec<_>, Vec<_>) = numbers
    .into_iter()
    .partition(|x| x % 2 == 0);
println!("evens:{:?}, odds:{:?}", evens, odds);

12.Vec归约/求和

命令式实现：

let numbers = vec![1, 2, 3, 4, 5];
let mut sum = 0;
for n in &numbers {
    sum += n;
}
println!("sum:{:?}", sum);

函数式实现：

let numbers = vec![1, 2, 3, 4, 5];
// 函数式风格
let sum: i32 = numbers.iter().sum();
println!("sum:{:?}", sum);
// 或使用 fold
let sum = numbers.iter().fold(0, |acc, x| acc + x);
println!("sum:{:?}", sum);

13.Vec链式多重转换

命令式实现：

let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let mut result = Vec::new();
for n in numbers {
    if n % 2 == 0 {
        let transformed = n * 3 + 1;
        result.push(transformed);
    }
}
println!("result:{:?}", result);

函数式实现：

let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let result: Vec<_> = numbers
    .into_iter()
    .filter(|x| x % 2 == 0)
    .map(|x| x * 3 + 1)
    .collect();
println!("result:{:?}", result);

14.Vec条件检查

命令式实现：

let numbers = vec![1, 2, 3, 4, 5];
let mut all_positive = true;
for n in &numbers {
    if *n <= 0 {
        all_positive = false;
        break;
    }
}
println!("result:{:?}", all_positive);

函数式实现：

let numbers = vec![1, 2, 3, 4, 5];
let all_positive = numbers.iter().all(|x| *x > 0);
let any_negative = numbers.iter().any(|x| *x < 0);
println!("all_positive:{:?}, any_negative:{:?}", all_positive,any_negative);

15.Vec去重排序另一版本：

函数式实现：

let mut numbers = vec![3, 1, 4, 1, 5, 9, 2, 6, 5];
let mut unique_sorted = Vec::new();
numbers.sort();
let mut prev = None;
for n in numbers.iter() {
    if prev != Some(n) {
        unique_sorted.push(n);
        prev = Some(n);
    }
}
println!("numbers:{:?}, unique_sorted:{:?}", numbers,unique_sorted);

函数式实现：

let numbers = vec![3, 1, 4, 1, 5, 9, 2, 6, 5];
use itertools::Itertools; // 需要在Cargo.toml中添加 itertools 依赖
let unique_sorted: Vec<_> = numbers
    .into_iter()
    .sorted()
    .dedup()
    .collect();
println!("unique_sorted:{:?}",unique_sorted);

使用模式对比表

操作模式	命令式风格	函数式风格
遍历处理	for循环 + 手动收集	iter().map().collect()
条件过滤	for + if判断	iter().filter().collect()
查找元素	for + break	.find() / .position()
转换映射	循环中逐个转换	.map() / .map_while()
扁平化	嵌套循环	.flatten() / .flat_map()
分组	多个集合 + 条件判断	.partition() / .group_by()
聚合	累加变量	.fold() / .reduce() / .sum()
条件检查	标志变量 + 循环	.all() / .any()
去重	手动记录 + 检查	.dedup() + 排序或使用HashSet
链式操作	多层嵌套循环	链式调用多个适配器

注意：迭代器的适配器和消费器的区别，若没有消费器的驱动，则适配器不工作。归纳的对比表也未必准确，仁者见仁智者见智，仅供大家参考罢了，不必教条。

总结：

命令式和函数式可以配合使用，千万不要教条刻板！非黑即白！

还有笔记归纳的是否到位，我尽力了，抛砖引玉罢了；水平有限，我也在不断学习的过程中，错误难免，希望大家多多包含指导。

后记：

我是一个普通的c++老码农，Rust语言爱好者，如今已四十不惑，青丝白发生，人谈不上机智，然多年来敏而好学，不敢懈怠，随处学随处记，笔耕不辍，坚信好脑瓜不如烂笔头！如今赋闲家中，翻腾出来这些粗鄙之文，分享出来，抛砖引玉！不过本人水平有限，许多时候也是不求甚解，匆促行文，故而文中难免存有谬误，望诸君海涵指正！

帮忙点个赞吧！鼓励我坚持写下去！谢谢啦！