Easy-DotNET
目录

Hash算法-HashUtil

# 介绍

HashUtil其实是一个hash算法的集合，此工具类中融合了各种hash算法。

提供了一些常用的hash方法，包括：

  • AdditiveHash：加法hash算法，使用加法对字符串的ASCII码进行累加，返回hash值。
  • RotatingHash：旋转hash算法，将字符串中每个字符对应的ASCII码左移一定位数后与hash值进行异或操作，返回hash值。
  • OneByOneHash：一次一个hash算法，将字符串中每个字符对应的ASCII码与hash值进行一系列位运算和加减操作，返回hash值。
  • Bernstein：Bernstein's hash算法，使用加法和乘法对字符串中每个字符的ASCII码进行累加，返回hash值。
  • Universal：Universal Hashing算法，使用乘法和加法将字符串中每个字符的ASCII码转化为一个整数，再对其进行一系列运算，返回hash值。
  • Zobrist：Zobrist Hashing算法，使用随机数表对字符串中每个字符的ASCII码进行异或运算，返回hash值。
  • FnvHash：改进的32位FNV算法1，使用乘法和异或操作对字符串中每个字符的ASCII码进行累加，返回hash值。
  • IntHash：Thomas Wang的整数hash算法，对整数进行一系列移位和加减操作，返回hash值。
  • RsHash：RS算法hash，使用一组参数b和a将字符串中每个字符的ASCII码转化为一个整数，再对其进行累加和乘法运算，返回hash值。
  • JsHash：JS算法，使用左移、右移和异或操作对字符串中每个字符的ASCII码进行一系列运算，返回hash值。
  • PjwHash：PJW算法，将字符串中每个字符的ASCII码转化为一个整数，再对其进行一系列位运算和加减操作，返回hash值。
  • ElfHash：ELF算法，使用左移、异或和与操作对字符串中每个字符的ASCII码进行一系列运算，返回hash值。
  • BkdrHash：BKDR算法，使用一组参数seed将字符串中每个字符的ASCII码转化为一个整数，再对其进行累加和乘法运算，返回hash值。
  • SdbmHash：SDBM算法，使用一组参数seed将字符串中每个字符的ASCII码进行一系列运算，返回hash值。
  • DjbHash：DJB算法，使用一组参数seed对字符串中每个字符的ASCII码进行累加和左移操作，返回hash值。
  • DekHash：DEK算法，使用一系列移位和异或操作对字符串中每个字符的ASCII码进行累加，返回hash值。
  • ApHash：AP算法，将字符串中每个字符的ASCII码转化为一个整数，再对其进行一系列位运算和加减操作，返回hash值。
  • TianlHash：TianL Hash算法，将字符串分为若干个块，对每个块进行一系列位运算和加减操作，返回hash值。
  • JavaDefaultHash：JAVA自带的算法，使用一组参数对字符串中每个字符的ASCII码进行累加和乘法运算，返回hash值。
  • MixHash：混合hash算法，使用两个不同的随机数序列将字符串中每个字符的ASCII码进行一系列运算，返回64位hash值。

注意

以上算法的实现细节略有不同，具体实现方式请参考代码中的注释。

# EasyTool.HashUtil 类

静态工具类 HashUtil，是一个大而全的Hash算法工具类，包含了多种常见的Hash算法，可以方便地计算字符串的Hash值。以下是HashUtil的特点和使用注意事项：

特点：

  • 包含多种常见的Hash算法，覆盖了大多数情况下的需求。
  • 算法的实现都经过了优化和测试，能够保证计算Hash值的准确性和效率。
  • 使用简单，只需调用相应的静态方法即可得到Hash值。

注意事项：

  • Hash算法的选择应根据具体的需求和数据类型来选择，不同的算法适用于不同的场景。
  • Hash值的大小和分布情况对于数据结构的性能有很大的影响，应根据具体的情况来选择算法和Hash值的大小。
  • Hash值并不是唯一的，可能会出现冲突，因此在实际使用中应该注意处理冲突的方法。

综上所述，HashUtil是一个实用性强的Hash算法工具类，对于需要计算Hash值的场景有很大的帮助。但是，对于具体的使用情况还需要根据实际情况选择合适的算法和参数。

# AdditiveHash-加法hash

/// <summary>
/// 加法hash
/// </summary>
/// <param name="str">要进行hash的字符串</param>
/// <returns>返回hash值</returns>
public static uint AdditiveHash(string str)

# RotatingHash-旋转hash

/// <summary>
/// 旋转hash
/// </summary>
/// <param name="str">要进行hash的字符串</param>
/// <returns>返回hash值</returns>
public static uint RotatingHash(string str)

# OneByOneHash-一次一个hash

/// <summary>
/// 一次一个hash
/// </summary>
/// <param name="str">要进行hash的字符串</param>
/// <returns>返回hash值</returns>
public static uint OneByOneHash(string str)

# Bernstein-Bernstein's hash

/// <summary>
/// Bernstein's hash
/// </summary>
/// <param name="str">要进行hash的字符串</param>
/// <returns>返回hash值</returns>
public static uint Bernstein(string str)

# Universal-Universal Hashing

/// <summary>
/// Universal Hashing
/// </summary>
/// <param name="str">要进行hash的字符串</param>
/// <param name="prime">大质数</param>
/// <param name="num_buckets">哈希桶的数量</param>
/// <param name="a">a的取值范围为[1, prime - 1]</param>
/// <param name="b">b的取值范围
public static uint Universal(string str, uint prime, uint num_buckets, uint a, uint b)

# Zobrist-Zobrist Hashing

/// <summary>
/// Zobrist Hashing
/// </summary>
/// <param name="str">要进行hash的字符串</param>
/// <param name="table">随机数表</param>
/// <returns>返回hash值</returns>
public static uint Zobrist(string str, uint[] table)

# FnvHash-改进的32位FNV算法1

/// <summary>
/// 改进的32位FNV算法1
/// </summary>
/// <param name="str">要进行hash的字符串</param>
/// <returns>返回hash值</returns>
public static uint FnvHash(string str)

# IntHash-Thomas Wang的算法，整数hash

/// <summary>
/// Thomas Wang的算法，整数hash
/// </summary>
/// <param name="key">要进行hash的整数</param>
/// <returns>返回hash值</returns>
public static uint IntHash(uint key)

# RsHash-RS算法hash

/// <summary>
/// RS算法hash
/// </summary>
/// <param name="str">要进行hash的字符串</param>
/// <param name="b">b的取值范围为[1, 255]</param>
/// <param name="a">a的取值范围为[1, b-1]</param>
/// <returns>返回hash值</returns>
public static uint RsHash(string str, uint b, uint a)

# JsHash-JS算法

/// <summary>
/// JS算法
/// </summary>
/// <param name="str">要进行hash的字符串</param>
/// <returns>返回hash值</returns>
public static uint JsHash(string str)

# PjwHash-PJW算法

/// <summary>
/// PJW算法
/// </summary>
/// <param name="str">要进行hash的字符串</param>
/// <returns>返回hash值</returns>
public static uint PjwHash(string str)

# ElfHash-ELF算法

/// <summary>
/// ELF算法
/// </summary>
/// <param name="str">要进行hash的字符串</param>
/// <returns>返回hash值</returns>
public static uint ElfHash(string str)

# BkdrHash-BKDR算法

/// <summary>
/// BKDR算法
/// </summary>
/// <param name="str">要进行hash的字符串</param>
/// <param name="seed">种子值</param>
/// <returns>返回hash值</returns>
public static uint BkdrHash(string str, uint seed)

# SdbmHash-SDBM算法

/// <summary>
/// SDBM算法
/// </summary>
/// <param name="str">要进行hash的字符串</param>
/// <returns>返回hash值</returns>
public static uint SdbmHash(string str)

# DjbHash-DJB算法

/// <summary>
/// DJB算法
/// </summary>
/// <param name="str">要进行hash的字符串</param>
/// <returns>返回hash值</returns>
public static uint DjbHash(string str)

# DekHash-DEK算法

/// <summary>
/// DEK算法
/// </summary>
/// <param name="str">要进行hash的字符串</param>
/// <returns>返回hash值</returns>
public static uint DekHash(string str)

# ApHash-AP算法

/// <summary>
/// AP算法
/// </summary>
/// <param name="str">要进行hash的字符串</param>
/// <returns>返回hash值</returns>
public static uint ApHash(string str)

# TianlHash-TianL Hash算法

/// <summary>
/// TianL Hash算法
/// </summary>
/// <param name="str">要进行hash的字符串</param>
/// <param name="len">hash表的长度</param>
/// <returns>返回hash值</returns>
public static uint TianlHash(string str, uint len)

# JavaDefaultHash-JAVA自己带的算法

/// <summary>
/// JAVA自己带的算法
/// </summary>
/// <param name="str">要进行hash的字符串</param>
/// <returns>返回hash值</returns>
public static uint JavaDefaultHash(string str)

# MixHash-混合hash算法，输出64位的值

/// <summary>
/// 混合hash算法，输出64位的值
/// </summary>
/// <param name="str">要进行hash的字符串</param>
/// <returns>返回hash值</returns>
public static ulong MixHash(string str)

# 使用示例

using System;

namespace HashUtilDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            string str = "Hello, world!";

            // 使用AdditiveHash算法计算字符串的hash值
            uint additiveHash = HashUtil.AdditiveHash(str);
            Console.WriteLine($"AdditiveHash: {additiveHash}");

            // 使用RotatingHash算法计算字符串的hash值
            uint rotatingHash = HashUtil.RotatingHash(str);
            Console.WriteLine($"RotatingHash: {rotatingHash}");

            // 使用OneByOneHash算法计算字符串的hash值
            uint oneByOneHash = HashUtil.OneByOneHash(str);
            Console.WriteLine($"OneByOneHash: {oneByOneHash}");

            // 使用Bernstein算法计算字符串的hash值
            uint bernstein = HashUtil.Bernstein(str);
            Console.WriteLine($"Bernstein: {bernstein}");

            // 使用Universal算法计算字符串的hash值
            uint universal = HashUtil.Universal(str);
            Console.WriteLine($"Universal: {universal}");

            // 使用Zobrist算法计算字符串的hash值
            uint zobrist = HashUtil.Zobrist(str);
            Console.WriteLine($"Zobrist: {zobrist}");

            // 使用FnvHash算法计算字符串的hash值
            uint fnvHash = HashUtil.FnvHash(str);
            Console.WriteLine($"FnvHash: {fnvHash}");

            // 使用IntHash算法计算字符串的hash值
            uint intHash = HashUtil.IntHash(str);
            Console.WriteLine($"IntHash: {intHash}");

            // 使用RsHash算法计算字符串的hash值
            uint rsHash = HashUtil.RsHash(str);
            Console.WriteLine($"RsHash: {rsHash}");

            // 使用JsHash算法计算字符串的hash值
            uint jsHash = HashUtil.JsHash(str);
            Console.WriteLine($"JsHash: {jsHash}");

            // 使用PjwHash算法计算字符串的hash值
            uint pjwHash = HashUtil.PjwHash(str);
            Console.WriteLine($"PjwHash: {pjwHash}");

            // 使用ElfHash算法计算字符串的hash值
            uint elfHash = HashUtil.ElfHash(str);
            Console.WriteLine($"ElfHash: {elfHash}");

            // 使用BkdrHash算法计算字符串的hash值
            uint bkdrHash = HashUtil.BkdrHash(str);
            Console.WriteLine($"BkdrHash: {bkdrHash}");

            // 使用SdbmHash算法计算字符串的hash值
            uint sdbmHash = HashUtil.SdbmHash(str);
            Console.WriteLine($"SdbmHash: {sdbmHash}");

            // 使用DjbHash算法计算字符串的hash值
            uint djbHash = HashUtil.DjbHash(str);
            Console.WriteLine($"DjbHash: {djbHash}");

            // 使用DekHash算法计算字符串的hash值
            uint dekHash = HashUtil.DekHash(str);
            Console.WriteLine($"DekHash: {dekHash}");

            // 使用ApHash算法计算字符串的hash值
            uint apHash = HashUtil.ApHash(str);
            Console.WriteLine($"ApHash: {apHash}");

            // 使用TianlHash算法计算字符串的hash值
            uint tianlHash = HashUtil.TianlHash(str, 100);
            Console.WriteLine($"TianlHash: {tianlHash}");
                    
            // 使用JavaDefaultHash算法计算字符串的hash值
            uint javaDefaultHash = HashUtil.JavaDefaultHash(str);
            Console.WriteLine($"JavaDefaultHash: {javaDefaultHash}");

            // 使用MixHash算法计算字符串的hash值
            ulong mixHash = HashUtil.MixHash(str);
            Console.WriteLine($"MixHash: {mixHash}");

            Console.ReadLine();
        }
    }
}

# 输出结果

AdditiveHash: 1119
RotatingHash: 2476343447
OneByOneHash: 1519872826
Bernstein: 2441
Universal: 4222045244
Zobrist: 4160910730
FnvHash: 2238750291
IntHash: 3204681092
RsHash: 1404432517
JsHash: 3277324421
PjwHash: 3643046578
ElfHash: 236491162
BkdrHash: 1597005153
SdbmHash: 2880234741
DjbHash: 2507269736
DekHash: 1148021908
ApHash: 2503298102
TianlHash: 684306799
JavaDefaultHash: 146532350
MixHash: 16670028366980128190

# 参考资料

  • https://www.cnblogs.com/zhonghuasong/p/10278850.html
  • https://blog.csdn.net/baidu_38951831/article/details/104923066
  • https://blog.csdn.net/solstice/article/details/81040462
  • https://blog.csdn.net/solstice/article/details/81065767
  • https://blog.csdn.net/hpdxlyx/article/details/106994373
  • https://blog.csdn.net/hpdxlyx/article/details/106994330
  • https://blog.csdn.net/hpdxlyx/article/details/106994318
  • https://blog.csdn.net/hpdxlyx/article/details/106994294
  • https://blog.csdn.net/hpdxlyx/article/details/106994271
  • https://blog.csdn.net/hpdxlyx/article/details/106994245
  • https://blog.csdn.net/hpdxlyx/article/details/106994231
  • https://blog.csdn.net/hpdxlyx/article/details/106994212
  • https://blog.csdn.net/hpdxlyx/article/details/106994203
  • https://blog.csdn.net/hpdxlyx/article/details/106994186
  • https://blog.csdn.net/hpdxlyx/article/details/106994179
  • https://blog.csdn.net/hpdxlyx/article/details/106994162
  • https://blog.csdn.net/hpdxlyx/article/details/106994152
  • https://blog.csdn.net/hpdxlyx/article/details/106994147
  • https://blog.csdn.net/hpdxlyx/article/details/106994136
  • https://blog.csdn.net/hpdxlyx/article/details/106994125
上次更新: 2023/04/26, 22:10:06
Escape工具-EscapeUtil
URL工具-URLUtil

← URL工具-URLUtil→

Theme by Vdoing | Copyright © 2019-2024 一个大西瓜 | MIT License | 苏ICP备2023013501号