用 Rust 构建公司部门管理系统：HashMap 与 Vec 的实践应用

xiyijixiyifula2026-03-11 16:15

用 Rust 构建公司部门管理系统：HashMap 与 Vec 的实践应用

本文通过一个完整的公司部门管理系统示例，深入讲解 Rust 中 HashMap 和 Vec 的实际应用，展示如何构建一个交互式的命令行工具。

引言

在日常开发中，我们经常需要管理和组织关联数据。例如，在公司管理系统中，我们需要将员工分配到不同的部门，并能够快速查询某个部门的所有员工或公司所有员工的信息。这种场景下，哈希映射（HashMap）和动态数组（Vec）是理想的数据结构组合。

本文将通过构建一个完整的公司部门管理系统，展示如何在 Rust 中使用 HashMap 和 Vec 来管理关联数据，并实现一个友好的命令行交互界面。我们将涵盖以下内容：

  • HashMap 和 Vec 的基本概念与应用场景
  • 命令行输入处理
  • 数据排序与展示
  • 代码组织与模块化设计

前置要求

  • Rust 1.94.0+
  • 基本的 Rust 语法知识
  • 对所有权（Ownership）和借用（Borrowing）概念的理解

项目初始化

首先，使用 Cargo 创建一个新的二进制项目：

bash 复制代码 
cargo new company_directory
cd company_directory

在 Cargo.toml 中设置 Edition 为 2024：

toml 复制代码 
[package]
name = "company_directory"
version = "0.1.0"
edition = "2024"

[dependencies]

核心数据结构设计

HashMap 与 Vec 的组合

在本项目中，我们需要存储部门与员工的关联关系。每个部门可以有多个员工，而每个员工只属于一个部门。这种"一对多"的关系非常适合使用 HashMap 来实现：

rust 复制代码 
use std::collections::HashMap;

// 键：部门名称（String）
// 值：该部门的员工列表（Vec<String>）
let mut company: HashMap<String, Vec<String>> = HashMap::new();

这种设计有以下几个优势：

  1. 快速查找：通过部门名称可以快速获取该部门的员工列表
  2. 动态扩展：可以轻松添加新的部门和员工
  3. 灵活管理：每个部门的员工数量可以动态变化

数据操作 API

Rust 的 HashMap 提供了丰富的 API 来操作数据。在本项目中，我们主要使用以下方法：

  • entry(key).or_insert_with(Vec::new)：获取或创建部门
  • push()：向员工列表添加新员工
  • get(key)：获取指定部门的员工列表
rust 复制代码 
// 将员工添加到部门
company
    .entry(department.clone())
    .or_insert_with(Vec::new)
    .push(employee.clone());

这段代码的工作原理是：

  1. entry(department.clone()) 获取指定部门的 Entry
  2. or_insert_with(Vec::new) 如果部门不存在，则创建一个新的空 Vec
  3. push(employee.clone()) 将员工添加到该部门的员工列表中

命令行交互设计

输入处理

为了实现友好的用户交互，我们需要处理用户的命令行输入。Rust 的标准库提供了 std::io 模块来处理输入输出：

rust 复制代码 
use std::io::{self, Write};

fn main() {
    let mut company: HashMap<String, Vec<String>> = HashMap::new();

    loop {
        print!("请输入命令（或输入 'help' 查看帮助，'quit' 退出）: ");
        io::stdout().flush().unwrap();

        let mut input = String::new();
        io::stdin().read_line(&mut input).expect("无法读取输入");
        let input = input.trim();

        if input.is_empty() {
            continue;
        }

        match input {
            "help" => show_help(),
            "quit" | "exit" => {
                println!("感谢使用公司部门管理系统！");
                break;
            }
            _ => process_command(input, &mut company),
        }

        println!();
    }
}

这里有几个关键点：

  1. io::stdout().flush().unwrap()：确保提示信息立即显示
  2. read_line(&mut input)：读取用户输入到可变字符串
  3. trim()：去除输入两端的空白字符
  4. match 表达式：根据用户输入执行不同的操作

命令解析

我们需要解析用户输入的命令，并执行相应的操作。命令处理函数如下：

rust 复制代码 
fn process_command(input: &str, company: &mut HashMap<String, Vec<String>>) {
    if input.starts_with("将") && input.contains("添加到") {
        // 处理"将 <员工名> 添加到 <部门名>"命令
        let parts: Vec<&str> = input.split_whitespace().collect();

        if parts.len() >= 4 {
            let employee = parts[1].to_string();
            let department = parts[3].to_string();

            company
                .entry(department.clone())
                .or_insert_with(Vec::new)
                .push(employee.clone());

            println!("✓ 已将 {} 添加到 {} 部门", employee, department);
        } else {
            println!("✗ 命令格式错误。正确格式：将 <员工名> 添加到 <部门名>");
        }
    } else if input.starts_with("列出") {
        // 处理列出员工命令
        let parts: Vec<&str> = input.split_whitespace().collect();

        if parts.len() >= 3 && parts[1] == "所有" && parts[2] == "员工" {
            list_all_employees(company);
        } else if parts.len() >= 3 {
            let department = parts[1].to_string();
            list_department_employees(company, &department);
        } else {
            println!("✗ 命令格式错误。正确格式：列出 <部门名> 的员工 或 列出所有员工");
        }
    } else {
        println!("✗ 未知命令。输入 'help' 查看可用命令。");
    }
}

数据展示与排序

按部门列出员工

列出指定部门的员工时，我们需要：

  1. 从 HashMap 中获取该部门的员工列表
  2. 对员工列表进行排序
  3. 格式化输出
rust 复制代码 
fn list_department_employees(company: &HashMap<String, Vec<String>>, department: &str) {
    match company.get(department) {
        Some(employees) => {
            let mut sorted_employees = employees.clone();
            sorted_employees.sort(); // 按字母顺序排序

            println!();
            println!("{} 部门的员工（共 {} 人）：", department, sorted_employees.len());
            for (i, employee) in sorted_employees.iter().enumerate() {
                println!("  {}. {}", i + 1, employee);
            }
        }
        None => {
            println!("✗ 部门 '{}' 不存在或没有员工", department);
        }
    }
}

这里使用了 match 表达式来处理可能不存在的情况，这是 Rust 中处理 Option 类型的惯用方式。

列出所有员工

列出所有员工时，我们需要：

  1. 遍历所有部门和员工
  2. 收集所有员工及其所属部门
  3. 按员工名字母顺序排序
  4. 格式化输出
rust 复制代码 
fn list_all_employees(company: &HashMap<String, Vec<String>>) {
    if company.is_empty() {
        println!("✗ 公司还没有任何部门或员工");
        return;
    }

    // 收集所有员工和部门信息
    let mut all_employees: Vec<(String, String)> = Vec::new();

    for (department, employees) in company.iter() {
        for employee in employees {
            all_employees.push((employee.clone(), department.clone()));
        }
    }

    if all_employees.is_empty() {
        println!("✗ 公司还没有任何员工");
        return;
    }

    // 按员工名字母顺序排序
    all_employees.sort_by(|a, b| a.0.cmp(&b.0));

    println!();
    println!("公司所有员工（共 {} 人）：", all_employees.len());
    for (i, (employee, department)) in all_employees.iter().enumerate() {
        println!("  {}. {} - {} 部门", i + 1, employee, department);
    }
}

这里我们使用了元组 (String, String) 来存储员工和部门的关联关系，并使用 sort_by 方法自定义排序规则。

运行与测试

编译运行

使用以下命令编译并运行项目：

bash 复制代码 
cargo run

使用示例

bash 复制代码 
公司部门管理系统
================

请输入命令（或输入 'help' 查看帮助，'quit' 退出）: help

可用命令:
  将 <员工名> 添加到 <部门名> - 将员工添加到指定部门
  列出 <部门名> 的员工 - 列出指定部门的所有员工（按字母顺序）
  列出所有员工 - 列出公司所有部门的所有员工（按字母顺序）
  help - 显示此帮助信息
  quit 或 exit - 退出程序

请输入命令（或输入 'help' 查看帮助，'quit' 退出）: 将 Sally 添加到 项目部门
✓ 已将 Sally 添加到 项目部门

请输入命令（或输入 'help' 查看帮助，'quit' 退出）: 将 Amir 添加到 销售部门
✓ 已将 Amir 添加到 销售部门

请输入命令（或输入 'help' 查看帮助，'quit' 退出）: 将 张三 添加到 项目部门
✓ 已将 张三 添加到 项目部门

请输入命令（或输入 'help' 查看帮助，'quit' 退出）: 列出 项目部门 的员工

项目部门 的员工（共 2 人）：
  1. Sally
  2. 张三

请输入命令（或输入 'help' 查看帮助，'quit' 退出）: 列出所有员工

公司所有员工（共 3 人）：
  1. Amir - 销售部门
  2. Sally - 项目部门
  3. 张三 - 项目部门

请输入命令（或输入 'help' 查看帮助，'quit' 退出）: quit
感谢使用公司部门管理系统！

代码组织与最佳实践

函数设计

我们将代码组织成多个函数，每个函数负责单一职责：

  • main()：程序入口，处理主循环
  • show_help()：显示帮助信息
  • process_command()：解析和处理用户命令
  • list_department_employees()：列出指定部门的员工
  • list_all_employees()：列出所有员工

这种组织方式使代码易于理解和维护。

错误处理

在本项目中，我们使用了简单的错误处理方式：

  • 使用 expect() 处理不可恢复的错误（如读取输入失败）
  • 使用 match 表达式处理可能失败的操作（如查找部门）
  • 提供友好的错误提示信息

对于更复杂的应用，可以考虑使用 Result 类型和 ? 运算符进行更完善的错误处理。

性能考虑

  1. 克隆操作 ：代码中多次使用 clone()，这会带来性能开销。在实际应用中，可以通过使用引用来减少克隆。

  2. 排序：每次列出员工时都进行排序，如果数据量大，可以考虑缓存排序结果。

  3. 数据结构：对于大规模数据，可以考虑使用更高效的数据结构，如 BTreeMap。

扩展思考

基于当前实现，可以考虑以下扩展方向：

  1. 数据持久化：将数据保存到文件或数据库，实现数据的持久化存储
  2. 高级查询：支持更复杂的查询条件，如按部门统计员工数量
  3. 用户界面：开发图形用户界面或 Web 界面
  4. 并发支持：使用 Rust 的并发特性支持多用户同时操作
  5. 数据验证：添加输入验证，确保数据的完整性和一致性

完整代码

rust 复制代码 
use std::collections::HashMap;
use std::io::{self, Write};

/// 公司部门管理系统
///
/// 使用哈希映射（HashMap）和动态数组（Vec）来管理公司部门和员工
///
/// # 功能
/// - 添加员工到部门
/// - 列出某个部门的所有员工（按字母顺序排序）
/// - 列出公司所有部门的所有员工（按字母顺序排序）
fn main() {
    // 创建一个哈希映射，键是部门名称，值是该部门的员工列表
    let mut company: HashMap<String, Vec<String>> = HashMap::new();

    println!("公司部门管理系统");
    println!("================");
    println!();

    loop {
        print!("请输入命令（或输入 'help' 查看帮助，'quit' 退出）: ");
        io::stdout().flush().unwrap();

        let mut input = String::new();
        io::stdin().read_line(&mut input).expect("无法读取输入");
        let input = input.trim();

        if input.is_empty() {
            continue;
        }

        match input {
            "help" => show_help(),
            "quit" | "exit" => {
                println!("感谢使用公司部门管理系统！");
                break;
            }
            _ => process_command(input, &mut company),
        }

        println!();
    }
}

/// 显示帮助信息
fn show_help() {
    println!();
    println!("可用命令:");
    println!("  将 <员工名> 添加到 <部门名> - 将员工添加到指定部门");
    println!("  列出 <部门名> 的员工 - 列出指定部门的所有员工（按字母顺序）");
    println!("  列出所有员工 - 列出公司所有部门的所有员工（按字母顺序）");
    println!("  help - 显示此帮助信息");
    println!("  quit 或 exit - 退出程序");
    println!();
}

/// 处理用户输入的命令
fn process_command(input: &str, company: &mut HashMap<String, Vec<String>>) {
    if input.starts_with("将") && input.contains("添加到") {
        // 处理"将 <员工名> 添加到 <部门名>"命令
        let parts: Vec<&str> = input.split_whitespace().collect();

        if parts.len() >= 4 {
            let employee = parts[1].to_string();
            let department = parts[3].to_string();

            // 将员工添加到部门
            company
                .entry(department.clone())
                .or_insert_with(Vec::new)
                .push(employee.clone());

            println!("✓ 已将 {} 添加到 {} 部门", employee, department);
        } else {
            println!("✗ 命令格式错误。正确格式：将 <员工名> 添加到 <部门名>");
        }
    } else if input.starts_with("列出") {
        // 处理列出员工命令
        let parts: Vec<&str> = input.split_whitespace().collect();

        if parts.len() >= 3 && parts[1] == "所有" && parts[2] == "员工" {
            // 列出所有员工
            list_all_employees(company);
        } else if parts.len() >= 3 {
            // 列出指定部门的员工
            let department = parts[1].to_string();
            list_department_employees(company, &department);
        } else {
            println!("✗ 命令格式错误。正确格式：列出 <部门名> 的员工 或 列出所有员工");
        }
    } else {
        println!("✗ 未知命令。输入 'help' 查看可用命令。");
    }
}

/// 列出指定部门的所有员工（按字母顺序排序）
fn list_department_employees(company: &HashMap<String, Vec<String>>, department: &str) {
    match company.get(department) {
        Some(employees) => {
            let mut sorted_employees = employees.clone();
            sorted_employees.sort(); // 按字母顺序排序

            println!();
            println!("{} 部门的员工（共 {} 人）：", department, sorted_employees.len());
            for (i, employee) in sorted_employees.iter().enumerate() {
                println!("  {}. {}", i + 1, employee);
            }
        }
        None => {
            println!("✗ 部门 '{}' 不存在或没有员工", department);
        }
    }
}

/// 列出公司所有部门的所有员工（按字母顺序排序）
fn list_all_employees(company: &HashMap<String, Vec<String>>) {
    if company.is_empty() {
        println!("✗ 公司还没有任何部门或员工");
        return;
    }

    // 收集所有员工和部门信息
    let mut all_employees: Vec<(String, String)> = Vec::new();

    for (department, employees) in company.iter() {
        for employee in employees {
            all_employees.push((employee.clone(), department.clone()));
        }
    }

    if all_employees.is_empty() {
        println!("✗ 公司还没有任何员工");
        return;
    }

    // 按员工名字母顺序排序
    all_employees.sort_by(|a, b| a.0.cmp(&b.0));

    println!();
    println!("公司所有员工（共 {} 人）：", all_employees.len());
    for (i, (employee, department)) in all_employees.iter().enumerate() {
        println!("  {}. {} - {} 部门", i + 1, employee, department);
    }
}

总结

通过构建这个公司部门管理系统，我们学习了：

  1. HashMap 和 Vec 的组合应用：如何使用这两种数据结构来管理关联数据
  2. 命令行交互：如何处理用户输入并实现友好的交互界面
  3. 数据排序与展示：如何对数据进行排序并格式化输出
  4. 代码组织：如何将代码组织成多个函数，提高可读性和可维护性
  5. 错误处理：如何处理可能出现的错误情况

这个项目虽然简单，但它展示了 Rust 中常见的数据结构和编程模式，为进一步学习更复杂的应用打下了坚实的基础。希望本文能够帮助你更好地理解 Rust 的 HashMap 和 Vec，以及如何在实际项目中应用它们。

参考资料

相关推荐
AI智动派1 天前
从 Python 到 Rust：深入解析 LLM Agent 工具调用的内存安全与异步并发重构实践
rust
_朱志鹏1 天前
Rust练手项目1--minigrep
rust
ssshooter2 天前
Tauri 项目实践：客户端与 Web 端的授权登录实现方案
前端·后端·rust
AI智动派2 天前
《深入 Rust Async/Await：如何实现一个带超时保护与安全沙箱的 LLM Agent 循环》
rust
范特西林4 天前
一次 to_bits() 引发的 Rust 与 C++ 底层思考
rust
冬奇Lab5 天前
一天一个开源项目（第42篇）：OpenFang - 用 Rust 构建的 Agent 操作系统，16 层安全与 7 个自主 Hands
人工智能·rust·开源
量子位5 天前
Transformer论文作者重造龙虾，Rust搓出钢铁版，告别OpenClaw裸奔漏洞
rust·openai·ai编程
哈里谢顿5 天前
Rust 语言入门博客
rust
DongLi017 天前
rustlings 学习笔记 -- exercises/06_move_semantics
rust
热门推荐
01GitHub 镜像站点02OpenClaw 使用和管理 MCP 完全指南03本地部署 OpenClaw + DeepSeek-R1 完全指南04OpenClaw 连接飞书完整指南：插件安装、配置与踩坑记录05OpenClaw 飞书机器人不回复消息？3 小时踩坑总结06Window 10部署openclaw报错node.exe : npm error code 12807OpenClaw 接入 QQ Bot 完整实践指南08OpenClaw macOS 完整安装与本地模型配置教程（实战版）09npm-error code 128问题解决方法10得物前端部门，没了