Rust：Vec、HashMap、BTreeMap 数据检索性能测评

写了段测试程序，模拟了一下这三种数据类型的数据检索。程序考虑不一定全面，仅作参考吧。

测试程序首先产生 n 个随机字符串，分别存入这三个集合容器。在开始检索测试时启动计时器。为防止编译器自动优化代码造成错误的测试结果，把每次检索出的结果追加到字符串 s 中，并在测试结束后返回其长度。

测试代码如下：

use std::collections::{BTreeMap, HashMap};
extern crate rand;
use rand::Rng;
use std::time::Instant;

fn test_vec(n: usize) -> usize {
    let mut rng = rand::thread_rng();
    let mut x = Vec::new();
    for _ in 0..n {
        let s = rng.gen::<u128>().to_string();
        x.push((s.clone(), s.clone()));
    }
    let mut s = String::new();
    let start = Instant::now();
    for m in x.iter() {
        for n in x.iter() {
            if m == n {
                s.push_str(n.0.as_str());
                break;
            }
        }
    }
    println!("vec --- time cost: {:?} us", start.elapsed().as_micros());
    s.len()
}

fn test_hashmap(n: usize) -> usize {
    let mut rng = rand::thread_rng();
    let mut x = HashMap::new();
    for _ in 0..n {
        let s = rng.gen::<u128>().to_string();
        x.insert(s.clone(), s.clone());
    }
    let mut s = String::new();
    let start = Instant::now();
    for (m, _) in x.iter() {
        let n = x.get(m).unwrap().as_str();
        s.push_str(n);
    }
    println!("haspmap --- time cost: {:?} us", start.elapsed().as_micros());
    s.len()
}

fn test_btreemap(n: usize) -> usize {
    let mut rng = rand::thread_rng();
    let mut x = BTreeMap::new();
    for _ in 0..n {
        let s = rng.gen::<u128>().to_string();
        x.insert(s.clone(), s.clone());
    }
    let mut s = String::new();
    let start = Instant::now();
    for (m, _) in x.iter() {
        let n = x.get(m).unwrap().as_str();
        s.push_str(n);
    }
    println!("btreemap --- time cost: {:?} us", start.elapsed().as_micros());
    s.len()
}

fn main() {
    let n = 10;
    println!("n = {} ", n);
    test_vec(n);
    test_hashmap(n);
    test_btreemap(n);

    let n = 100;
    println!("n = {} ", n);
    test_vec(n);
    test_hashmap(n);
    test_btreemap(n);

    let n = 1000;
    println!("n = {} ", n);
    test_vec(n);
    test_hashmap(n);
    test_btreemap(n);

    let n = 10000;
    println!("n = {} ", n);
    test_vec(n);
    test_hashmap(n);
    test_btreemap(n);

    let n = 100000;
    println!("n = {} ", n);
    test_vec(n);
    test_hashmap(n);
    test_btreemap(n);
}

测试结果如下：

>cargo run --release
   Compiling demo v0.1.0 
    Finished release [optimized] target(s) in 1.42s
     Running `target\release\demo.exe`
     
n = 10
vec --- time cost: 7 us
haspmap --- time cost: 2 us
btreemap --- time cost: 2 us

n = 100
vec --- time cost: 21 us
haspmap --- time cost: 6 us
btreemap --- time cost: 8 us

n = 1000
vec --- time cost: 1211 us
haspmap --- time cost: 60 us
btreemap --- time cost: 76 us

n = 10000
vec --- time cost: 217291 us
haspmap --- time cost: 628 us
btreemap --- time cost: 1227 us

n = 100000
vec --- time cost: 24202474 us
haspmap --- time cost: 11605 us
btreemap --- time cost: 19651 us

可见，HaspMap 在 n = 10, 100, 1000, 10000, 100000 所有规模测试中，全部表现出较高的检索效率。