Rust哈希计算库murmur2的使用

murmur2是一个Rust实现的MurmurHash2非加密哈希算法库，它提供了高性能的哈希计算功能，适用于需要快速哈希但不需要加密安全性的场景。

特点

• 高性能：MurmurHash2算法设计用于快速哈希计算
• 非加密：不适用于安全敏感场景
• 一致性：相同输入总是产生相同输出
• 低碰撞率：良好的哈希分布特性

使用方法

添加依赖

首先在Cargo.toml中添加依赖：

[dependencies]
murmur2 = "0.1"

基本使用示例

use murmur2::murmur2;

fn main() {
    let data = b"hello world";
    let seed = 0; // 可选种子值
    
    // 计算哈希值
    let hash = murmur2(data, seed);
    
    println!("Murmur2 hash of 'hello world': {}", hash);
}

32位和64位版本

murmur2库提供了32位和64位两种哈希实现：

use murmur2::{murmur2_32, murmur2_64};

fn main() {
    let data = b"example data";
    
    let hash32 = murmur2_32(data, 0);
    let hash64 = murmur2_64(data, 0);
    
    println!("32-bit hash: {}", hash32);
    println!("64-bit hash: {}", hash64);
}

处理不同类型的数据

use murmur2::murmur2;

fn main() {
    // 字符串哈希
    let s = "Rust programming";
    let hash_str = murmur2(s.as_bytes(), 123);
    
    // 数值哈希
    let num = 42u32;
    let hash_num = murmur2(&num.to_le_bytes(), 0);
    
    println!("String hash: {}", hash_str);
    println!("Number hash: {}", hash_num);
}

在HashMap中使用

use std::collections::HashMap;
use murmur2::murmur2;

#[derive(Hash)]
struct Key {
    id: u32,
    name: String,
}

impl Key {
    fn custom_hash(&self) -> u32 {
        let id_hash = murmur2(&self.id.to_le_bytes(), 0);
        let name_hash = murmur2(self.name.as_bytes(), 0);
        id_hash ^ name_hash
    }
}

fn main() {
    let mut map = HashMap::new();
    let key = Key {
        id: 1,
        name: "example".to_string(),
    };
    
    map.insert(key.custom_hash(), "value");
    
    println!("Map: {:?}", map);
}

完整示例Demo

下面是一个综合使用murmur2库的完整示例，展示了不同场景下的哈希计算：

use murmur2::{murmur2, murmur2_32, murmur2_64};
use std::collections::HashMap;

fn main() {
    // 1. 基本使用示例
    let data = b"hello world";
    let hash = murmur2(data, 0);
    println!("Basic hash: {}", hash);

    // 2. 32位和64位版本比较
    let sample_data = b"sample data for comparison";
    println!("\n32-bit hash: {}", murmur2_32(sample_data, 0));
    println!("64-bit hash: {}", murmur2_64(sample_data, 0));

    // 3. 不同类型数据哈希
    println!("\nDifferent data types:");
    // 字符串
    let s = "Rust is awesome";
    println!("String hash: {}", murmur2(s.as_bytes(), 123));
    
    // 数值
    let numbers = [42u32, 100u32, 255u32];
    for &num in &numbers {
        println!("Number {} hash: {}", num, murmur2(&num.to_le_bytes(), 0));
    }

    // 4. 在HashMap中使用自定义哈希
    println!("\nCustom HashMap example:");
    let mut custom_map = HashMap::new();
    
    #[derive(Hash)]
    struct CustomKey {
        id: u32,
        category: String,
    }
    
    impl CustomKey {
        fn hash(&self) -> u32 {
            let id_hash = murmur2(&self.id.to_le_bytes(), 0);
            let cat_hash = murmur2(self.category.as_bytes(), 0);
            id_hash.wrapping_add(cat_hash)
        }
    }
    
    let key1 = CustomKey {
        id: 1,
        category: "admin".to_string(),
    };
    
    let key2 = CustomKey {
        id: 2,
        category: "user".to_string(),
    };
    
    custom_map.insert(key1.hash(), "Admin data");
    custom_map.insert(key2.hash(), "User data");
    
    println!("Custom map contents: {:?}", custom_map);
}

性能提示

1. 对于小数据块，MurmurHash2性能极佳
2. 种子值可以用于创建不同的哈希序列
3. 对于已知长度的数据，可以考虑使用更具体的函数变体

注意事项

• MurmurHash2不是加密安全的哈希算法
• 不同平台或版本可能会产生不同的哈希结果
• 对于哈希表等用途，建议测试实际碰撞率

murmur2库是处理非加密哈希需求的轻量级解决方案，特别适合需要快速哈希计算的场景如哈希表、布隆过滤器等。