Rust中HashMap類型的使用詳解

更新時間：2024年03月14日 09:32:10 作者：希望_睿智

Rust中一種常見的集合類型是哈希映射,本文主要介紹了Rust中HashMap類型的使用詳解,包含創(chuàng)建訪問修改遍歷等,具有一定的參考價值,感興趣的可以了解一下

概述

HashMap，被稱為哈希表或散列表，是一種可以存儲鍵值對的數(shù)據(jù)結構。它使用哈希函數(shù)將鍵映射到存儲位置，以便可以快速檢索和更新元素。這種數(shù)據(jù)結構在許多編程語言中都存在，而在Rust中，它被實現(xiàn)為HashMap<K, V>。其中，K表示鍵的類型，V表示值的類型。HashMap以哈希表為基礎實現(xiàn)，允許我們在常數(shù)平均時間復雜度內完成插入、刪除和查找操作。

HashMap的創(chuàng)建

Rust標準庫中提供了std::collections::HashMap<K, V>，這是一個關聯(lián)數(shù)組或映射。其中，K是鍵類型，必須實現(xiàn)Eq和Hash traits以確保鍵的唯一性和能夠進行哈希計算。V是值類型，可以是任何Rust支持的類型。

每個鍵都會通過哈希函數(shù)轉化為一個索引，并以此存儲對應的值，從而使得通過鍵快速定位到值成為可能。當兩個不同的鍵通過哈希函數(shù)得到相同的索引時，會發(fā)生“哈希沖突”。此時，HashMap會通過開放尋址法或者鏈地址法等策略來解決這個問題。

要使用HashMap，必須先引入std::collections::HashMap模塊。新建HashMap，主要有以下幾種方式。

1、使用new函數(shù)創(chuàng)建一個新的、空的HashMap。

use std::collections::HashMap;

fn main() {
    // 創(chuàng)建一個空的HashMap，鍵類型為String，值類型為i32
    let mut map_fruit: HashMap<String, i32> = HashMap::new();
    
    // 插入一些鍵值對
    map_fruit.insert("Lemon".to_string(), 66);
    map_fruit.insert("Apple".to_string(), 99);
    // 輸出：{"Lemon": 66, "Apple": 99}
    println!("{:?}", map_fruit);
}

2、新建帶有元素的HashMap。通過傳入一個鍵值對的集合（比如：數(shù)組、切片或迭代器），我們可以在創(chuàng)建HashMap的同時初始化它。這可以通過collect方法來實現(xiàn)，它通常與vec!宏或數(shù)組字面量一起使用，以創(chuàng)建包含(key, value)元組的集合。在下面的示例代碼中，我們首先創(chuàng)建了一個HashMap。它的鍵是String類型，值是i32類型。然后，我們使用vec!宏創(chuàng)建了一個包含三個(key, value)元組的向量，并使用into_iter方法將其轉換為迭代器。最后，我們使用collect方法將其收集到一個HashMap中。

use std::collections::HashMap;

fn main() {
    let map_fruit: HashMap<String, i32> = vec![
        ("Lemon".to_string(), 66), 
        ("Apple".to_string(), 99)].into_iter().collect();
    
    // 輸出：{"Lemon": 66, "Apple": 99}
    println!("{:?}", map_fruit);
}

3、HashMap::from是一個創(chuàng)建HashMap的便捷方法，主要用于從實現(xiàn)了IntoIterator特征且迭代器產出元組 (K, V) 的類型創(chuàng)建一個HashMap。

use std::collections::HashMap;

fn main() {
    let pairs = [("Lemon".to_string(), 66), ("Apple".to_string(), 99)];
    let map_fruit = HashMap::from(pairs);

    // 輸出：{"Lemon": 66, "Apple": 99}
    println!("{:?}", map_fruit);
}

4、使用with_capacity函數(shù)創(chuàng)建預先分配指定容量的HashMap。注意：預設容量只是預留空間，實際使用的數(shù)量會根據(jù)插入的鍵值對自動增長。

use std::collections::HashMap;

fn main() {
    // 創(chuàng)建一個初始容量為5的HashMap
    let mut map_fruit: HashMap<String, i32> = HashMap::with_capacity(5);
    
    // 插入一些鍵值對
    map_fruit.insert("Lemon".to_string(), 66);
    map_fruit.insert("Apple".to_string(), 99);
    // 輸出：{"Lemon": 66, "Apple": 99}
    println!("{:?}", map_fruit);
}

HashMap的訪問

HashMap是一個存儲鍵值對的數(shù)據(jù)結構，并且可以通過鍵來快速檢索值。為了訪問HashMap中的值，我們可以使用get方法或get_mut方法，具體取決于是否需要獲取值的可變引用。

1、get方法用于獲取與給定鍵相關聯(lián)的值的不可變引用。如果鍵存在于HashMap中，get將返回Some(value)，其中value是與該鍵相關聯(lián)的值的引用。如果鍵不存在，它將返回None。

use std::collections::HashMap;

fn main() {
    let mut map_fruit = HashMap::new();
    map_fruit.insert("Lemon".to_string(), 66);
    map_fruit.insert("Apple".to_string(), 99);

    // 訪問存在的鍵
    if let Some(value) = map_fruit.get("Apple") {
        println!("found value: {}", value);
    } else {
        println!("not found");
    }
  
    // 訪問不存在的鍵
    if let Some(value) = map_fruit.get("Peach") {
        println!("found value: {}", value);
    } else {
        println!("not found");
    }
}

2、如果我們需要獲取值的可變引用以便修改它，則應該使用get_mut方法。與get方法類似，如果鍵存在于HashMap中，get_mut將返回Some(&mut value)，其中&mut value是與該鍵相關聯(lián)的值的可變引用。如果鍵不存在，它將返回None。

use std::collections::HashMap;

fn main() {
    let mut map_fruit = HashMap::new();
    map_fruit.insert("Lemon".to_string(), 66);
    map_fruit.insert("Apple".to_string(), 99);

    // 訪問存在的鍵
    if let Some(value) = map_fruit.get_mut("Apple") {
        *value = 100;
    } else {
        println!("not found");
    }

    // 輸出：{"Apple": 100, "Lemon": 66}
    println!("{:?}", map_fruit);
  
    // 訪問不存在的鍵
    if let Some(value) = map_fruit.get_mut("Peach") {
        println!("found value: {}", value);
    } else {
        println!("not found");
    }
}

HashMap的修改

1、插入新鍵值對。如果鍵不存在，使用insert方法將添加一個新的鍵值對。如果鍵已經(jīng)存在，則會替換原有的值。

use std::collections::HashMap;

fn main() {
    // 創(chuàng)建一個空的HashMap，鍵類型為String，值類型為i32
    let mut map_fruit: HashMap<String, i32> = HashMap::new();
    
    // 插入一些鍵值對
    map_fruit.insert("Lemon".to_string(), 66);
    map_fruit.insert("Apple".to_string(), 99);
    // 輸出：{"Lemon": 66, "Apple": 99}
    println!("{:?}", map_fruit);
}

2、如果需要根據(jù)鍵是否存在來執(zhí)行不同的操作（比如：只在鍵不存在時插入值，或者在鍵存在時更新值），可以使用entry API。這提供了更細粒度的控制，并避免了不必要的查找。entry方法會根據(jù)鍵是否存在返回一個Entry枚舉；or_insert方法會在鍵不存在時插入給定的值，并返回鍵的值的可變引用；and_modify方法會修改現(xiàn)有的值。

use std::collections::HashMap;

fn main() {
    let mut map_fruit = HashMap::new();
    map_fruit.insert("Lemon".to_string(), 66);
    map_fruit.insert("Apple".to_string(), 99);

    // 使用entry API插入新的鍵值對，并修改值為原來的2倍
    map_fruit.entry("Peach".to_string()).or_insert(256);
    map_fruit.entry("Peach".to_string()).and_modify(|v| *v *= 2);
    // 輸出: {"Peach": 512, "Lemon": 66, "Apple": 99}
    println!("{:?}", map_fruit);
}

3、使用remove方法可以移除指定鍵的鍵值對。當我們調用remove方法并傳入一個鍵時，如果該鍵存在于HashMap中，它會返回與該鍵相關聯(lián)的值，并從HashMap中刪除該鍵值對。如果鍵不存在，會返回None。

use std::collections::HashMap;

fn main() {
    let mut map_fruit = HashMap::new();
    map_fruit.insert("Lemon".to_string(), 66);
    map_fruit.insert("Apple".to_string(), 99);

    // 嘗試刪除并獲取"Lemon"的值，會成功
    if let Some(value) = map_fruit.remove("Lemon") {
        println!("{} removed", value);
    } else {
        println!("not found");
    }

    // 嘗試刪除并獲取"Peach"的值，會失敗
    if let Some(value) = map_fruit.remove("Peach") {
        println!("{} removed", value);
    } else {
        println!("not found");
    }

    // 輸出: {"Apple": 99}
    println!("{:?}", map_fruit);
}

HashMap的遍歷

在Rust中，我們可以使用多種方式來遍歷HashMap，包括：遍歷所有的鍵、遍歷所有的值、同時遍歷鍵和值。

1、遍歷所有的鍵。我們可以使用keys()方法來獲取一個包含所有鍵的迭代器，并遍歷它們。

use std::collections::HashMap;

fn main() {
    let pairs = [("Lemon".to_string(), 66), ("Apple".to_string(), 99)];
    let map_fruit = HashMap::from(pairs);

    // 分別輸出：Lemon Apple
    for key in map_fruit.keys() {
        println!("{}", key);
    }
}

2、遍歷所有的值。我們可以使用values()方法來獲取一個包含所有值的迭代器，并遍歷它們。

use std::collections::HashMap;

fn main() {
    let pairs = [("Lemon".to_string(), 66), ("Apple".to_string(), 99)];
    let map_fruit = HashMap::from(pairs);

    // 分別輸出：99 66
    for value in map_fruit.values() {
        println!("{}", value);
    }
}

3、同時遍歷鍵和值。如果需要同時訪問鍵和值，我們可以使用iter()方法，它會返回一個包含鍵值對引用的迭代器。

use std::collections::HashMap;

fn main() {
    let pairs = [("Lemon".to_string(), 66), ("Apple".to_string(), 99)];
    let map_fruit = HashMap::from(pairs);

    // 分別輸出：Apple: 99 Lemon: 66
    for (key, value) in map_fruit.iter() {
        println!("{}: {}", key, value);
    }
}

4、遍歷并修改值。如果需要遍歷HashMap并修改其中的值，我們可以使用iter_mut()方法，它會返回一個包含可變鍵值對引用的迭代器。注意：當使用iter_mut()方法時，不能有其他對HashMap或其任何元素的可變引用。因為Rust的借用規(guī)則要求：在同一時間，變量只能有一個可變引用存在。

use std::collections::HashMap;

fn main() {
    let pairs = [("Lemon".to_string(), 66), ("Apple".to_string(), 99)];
    let mut map_fruit = HashMap::from(pairs);

    // 修改值為原來的10倍
    for (key, value) in map_fruit.iter_mut() {
        *value *= 10; 
    }

    // 分別輸出：Lemon: 660 Apple: 990
    for (key, value) in map_fruit.iter() {
        println!("{}: {}", key, value);
    }
}

HashMap的所有權

在Rust中，HashMap對插入其中的鍵值對的所有權規(guī)則，遵循Rust語言的核心所有權原則。這意味著，當我們將一個值放入HashMap時，會根據(jù)值的類型決定所有權如何轉移。

1、復制所有權。對于實現(xiàn)了Copy特征的類型（比如：整數(shù)、浮點數(shù)等基本類型），插入HashMap時不會發(fā)生所有權轉移，而是進行值的復制。

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    let number: i32 = 66;
    map.insert("Lemon", number);
    
    // 這里仍可以繼續(xù)使用number，因為復制了一份
    println!("{}", number);
}

2、轉移所有權。如果插入到HashMap中的值是不可復制的類型（比如：String或自定義結構體），那么當調用insert方法時，該值的所有權會被轉移給HashMap。這意味著，原變量將不再有效，并且不能再被使用。

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    let peach = String::from("Peach");
    // peach的所有權轉移到了HashMap中
    map.insert("Fruit", peach);
    
    // 這里訪問peach會導致編譯錯誤，因為它已經(jīng)不再擁有所有權
    // println!("{}", peach);
}

3、引用所有權。如果想要存儲指向數(shù)據(jù)的引用，而不是數(shù)據(jù)本身，可以使用引用類型（比如：&str或&T）。但是，引用的生命周期必須與引用的對象保持一致，確保在整個引用存在期間，對象也依然有效。

use std::collections::HashMap;

fn main() {
    let text = String::from("CSDN");
    let mut map = HashMap::new();
    map.insert("Hello", &text);
    // text必須一直有效，因為HashMap持有對它的引用
}

到此這篇關于Rust中HashMap類型的使用詳解的文章就介紹到這了,更多相關Rust HashMap內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章:

Rust
HashMap

Rust開發(fā)環(huán)境搭建到運行第一個程序HelloRust的圖文教程
本文主要介紹了Rust開發(fā)環(huán)境搭建到運行第一個程序HelloRust的圖文教程,文中通過圖文介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧
2023-12-12
rust udp編程方法的具體使用
Rust標準庫通過std::net模塊提供了UDP網(wǎng)絡編程支持,下面就來介紹一下rust udp編程方法的具體使用,具有一定的參考價值,感興趣的可以了解一下
2025-06-06
在Rust?web服務中使用Redis的方法
這篇文章主要介紹了在Rust?web服務中使用Redis,在這篇文章中，我們將演示如何在一個Rust?web應用程序中使用Redis，需要的朋友可以參考下
2022-08-08
Rust應用調用C語言動態(tài)庫的操作方法
這篇文章主要介紹了Rust應用調用C語言動態(tài)庫,本文記錄了筆者編寫一個簡單的C語言動態(tài)庫，并通過Rust調用動態(tài)庫導出的函數(shù)，需要的朋友可以參考下
2023-01-01
Rust的slab庫使用場景分析
slab 是一個輕量級、高性能的工具,非常適合管理固定大小的資源集合,尤其是在網(wǎng)絡編程和事件驅動架構中,這篇文章主要介紹了Rust的slab庫使用教程,需要的朋友可以參考下
2024-12-12
Rust語言中的哈希表
哈希表也是集合中的一種,也是最常用的集合形式,目前Rust語言核心部分沒有對哈希表進行實現(xiàn),是使用標準庫提供的,這篇文章主要介紹了Rust語言之哈希表,需要的朋友可以參考下
2024-02-02
Rust 枚舉和模式匹配的實現(xiàn)
枚舉是 Rust 中非常重要的復合類型,也是最強大的復合類型之一,廣泛用于屬性配置、錯誤處理、分支流程、類型聚合等場景中,本文就來介紹一下Rust 枚舉和模式匹配,感興趣的可以了解一下
2023-12-12
為什么要選Rust？學習Rust從零開始配置和實現(xiàn)第一個簡單項目
本文介紹了Rust語言的核心價值、應用場景、開發(fā)環(huán)境搭建、第一個Rust項目的創(chuàng)建與擴展、調試、發(fā)布流程,以及新手常見陷阱與避坑方法,通過學習Rust,開發(fā)者可以實現(xiàn)高效且安全的系統(tǒng)級開發(fā)、網(wǎng)絡編程和工具開發(fā)
2026-01-01
關于使用rust調用c++靜態(tài)庫并編譯nodejs包的問題
這篇文章主要介紹了使用rust調用c++靜態(tài)庫并編譯nodejs包的問題，本文通過實例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值,需要的朋友可以參考下
2022-08-08
Rust中Cargo的使用詳解
Cargo 是 Rust 的構建系統(tǒng)和包管理器，?多數(shù) Rustacean 們使? Cargo 來管理他們的 Rust 項?，因為它可以為你處理很多任務，?如構建代碼、下載依賴庫并編譯這些庫，這篇文章主要介紹了Rust中Cargo的使用,需要的朋友可以參考下
2022-11-11