一文了解Hash

最新推荐文章于 2025-07-15 19:15:35 发布
最新推荐文章于 2025-07-15 19:15:35 发布
阅读量1.1k 收藏 15
点赞数 20
CC 4.0 BY-SA版权
分类专栏： 算法结构 文章标签： 哈希算法 散列表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43855095/article/details/145265522

一、什么是hash、哈希函数、哈希表

  • Hash
    • 一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值
  • 哈希函数
    • 通过kry获取到所要查找的位置：hash函数就是根据key计算出应该存储地址的位置，而哈希表是基于哈希函数建立的一种查找表
  • 哈希（Hash）算法
    • 即散列函数。它是一种单向密码体制，即它是一个从明文到密文的不可逆的映射，只有加密过程，没有解密过程。同时，哈希函数可以将任意长度的输入经过变化以后得到固定长度的输出。哈希函数的这种单向特征和输出数据长度固定的特征使得它可以生成消息或者数据。

二、常用哈希函数的构造方法

  • 直接定制法
    • 哈希函数为关键字的线性函数如 H（key）=a*key+b，这种构造方法比较简便，均匀，但是有很大限制，仅限于地址大小=关键字集合的情况
  • 数字分析法
    • 假设关键字集合中的每个关键字key都是由s位数字组成（k 1 , k 2 , … … , k n ），分析key中的全体数据，并从中提取分布均匀的若干位或他们的组合构成全体
  • 平方取中法
    • 如果关键字的每一位都有某些数字重复出现频率很高的现象，可以先求关键字的平方值，通过平方扩大差异，而后取中间数位作为最终存储地址
  • 折叠法
    • 如果数字的位数很多，可以将数字分割为几个部分，取他们的叠加和作为hash地址
      • 比如key=123 456 789
      • 我们可以存储在61524，取末三位，存在524的位置；该方法适用于数字位数较多且事先不知道数据分布的情况
  • 除留余数法（用的较多）
    • H（key）=key MOD p （p<=m m为表长）
    • 很明显，如何选取p是个关键问题。
      • 比如我们存储3 6 9，那么p就不能取3，因为 3 MOD 3 == 6 MOD 3 == 9 MOD 3，p应为不大于m的质数或是不含20以下的质因子的合数，这样可以减少地址的重复（冲突）
    • MOD 取余

三、哈希碰撞（hash冲突）及处理

  • 散列函数，都会存在一定的散列碰撞，因此存在一定的重复风险
  • 处理方法
    • 开放寻址法
      • 所有的元素都在散列表中，每一个表项或包含动态集合的一个元素，或包含NIL。这种方法中散列表可能被填满，以至于不能插入任何新的元素
      • 在开放寻址法中，当要插入一个元素时，可以连续地检查或探测散列表的各项，直到有一个空槽来放置待插入的关键字为止。
      • 有三种技术用于开放寻址法：线性探测、二次探测以及双重探测
      • 在 Java 中的 ThreadLocalMap 就是采用了开放寻址法来解决哈希冲突，因为开放寻址法在极端环境下时间复杂度会退化成 O(n)，所以适用于数据量较少的场景
    • 链地址法
      • 链地址法也叫链表法，就是插入一个元素时，如果发现当前位置已经有元素，则以当前节点为头节点（尾插法）或者尾结点（头插法）构造一个链表
      • 如果进一步优化的话，可以将链表修改为红黑树等数组结构，比如 jdk 1.8 之后的 HashMap 就是采用的这种方式进行优化

四、MD5碰撞

  • 概念：两个不同的字符串，通过逆算散列会出现值一定的可能
  • 常见的碰撞方法：利用计算机的资源尝试碰撞已知的MD5码
    • 穷举法
      • 穷举法就是不停地尝试各种字符的排列组合，看哪一个组合的MD5码能对上。缺点是太耗费时间。举个例子，假设我们要破解一个6位大小写字母和数字混合的密码，那么一共有 (26 + 26 + 10) ^ 6 种组合。这个数的大小超过500亿
    • 字典法

五、一致性hash

  • 出现的原因：在分布式环境下，通常会使用hash MOD N（hash取余）将请求分发到不同的服务器上，但是当服务器增加或删除的时候，会造成一致性hash的问题
  • 一致性Hash的原理
  • 一致性hash算法+虚拟节点的实现

    • 环型Hash空间

      • 根据常用的Hash，是将key哈希到一个长为232的桶中，即0～232-1的数字空间，最后通过首尾相连，我们可以想象成一个闭合的圆
        在这里插入图片描述

    • 把数据通过一定的Hash算法处理后，映射到环上

      • 例如：我们有Object1、Object2、Object3、Object4，通过Hash算法求出值如下
        • Hash(Object1) = key1
        • Hash(Object2) = key2
        • Hash(Object3) = key3
        • Hash(Object4) = key4;
          在这里插入图片描述

    • 将机器信息通过hash算法映射到环上

      • 一般情况下是对机器的信息通过计算hash，然后以顺时针方向计算，将对象信息存储在相应的位置。
      • 假设三个服务器

        • NODE1、NODE2、NODE3

        • 将三个服务器通过hash散列到环形空间

        • 数据通过顺时针旋转，找到对应的服务器

          在这里插入图片描述

    • 虚拟节点

      • 如果当服务器的节点距离太近，node1和node2举例太近，大部分的数据都会被转到node2节点
        • node2的服务器频率压力过高，造成node2效率低
        • 如果node2宕机，瞬间压力集中到node1，会造成node1崩溃等
      • 虚拟节点的推出就是为了解决节点的分布不均衡问题
        • 将真是节点虚拟映射多个子节点分不到环形hash上，保证数据均匀的分发到不同节点，避免瓶颈
          在这里插入图片描述
          在这里插入图片描述

六、一致性hash算法+虚拟节点的实现

  • hash算法的选择
    • ava代码不要使用hashcode函数，这个函数结果不够散列，而且会有负值需要处理。
    • 这种计算Hash值的算法有很多，比如CRC32_HASH、FNV1_32_HASH、KETAMA_HASH等
    • 其中KETAMA_HASH是默认的MemCache推荐的一致性Hash算法，用别的Hash算法也可以，比如FNV1_32_HASH算法的计算效率就会高一些
  • 数据结构的选择。根据算法原理，我们的算法有几个要求
    • 要能根据hash值排序存储
    • 排序存储要被快速查找 （List不行）
    • 排序查找还要能方便变更 （Array不行）
  • 另外，由于二叉树可能极度不平衡。所以采用红黑树是最稳妥的实现方法。Java中直接使用TreeMap即可。

hash一致负载均衡

package com.grea.qz.config;

import java.util.LinkedList;
import java.util.List;
import java.util.SortedMap;
import java.util.TreeMap;

/**
 * hash一致负载均衡
 */
public class ConsistencyHashing {

    // 虚拟节点的个数
    private static final int VIRTUAL_NUM = 5;

    // 虚拟节点分配，key是hash值，value是虚拟节点服务器名称
    private static SortedMap<Integer, String> shards = new TreeMap<Integer, String>();

    // 真实节点列表
    private static List<String> realNodes = new LinkedList<String>();

    //模拟初始服务器
    private static String[] servers = {"192.168.1.1", "192.168.1.2", "192.168.1.3", "192.168.1.5", "192.168.1.6"};

    static {
        for (String server : servers) {
            realNodes.add(server);
            System.out.println("真实节点[" + server + "] 被添加");
            for (int i = 0; i < VIRTUAL_NUM; i++) {
                String virtualNode = server + "&&VN" + i;
                int hash = getHash(virtualNode);
                shards.put(hash, virtualNode);
                System.out.println("虚拟节点[" + virtualNode + "] hash:" + hash + "，被添加");
            }
        }
    }

    /**
     * 获取被分配的节点名
     *
     * @param node
     * @return
     */
    public static String getServer(String node) {
        int hash = getHash(node);
        Integer key;
        SortedMap<Integer, String> subMap = shards.tailMap(hash);
        if (subMap.isEmpty()) {
            key = shards.lastKey();
        } else {
            key = subMap.firstKey();
        }
        String virtualNode = shards.get(key);
        return virtualNode.substring(0, virtualNode.indexOf("&&"));
    }

    /**
     * 添加节点
     *
     * @param node
     */
    public static void addNode(String node) {
        if (!realNodes.contains(node)) {
            realNodes.add(node);
            System.out.println("真实节点[" + node + "] 上线添加");
            for (int i = 0; i < VIRTUAL_NUM; i++) {
                String virtualNode = node + "&&VN" + i;
                int hash = getHash(virtualNode);
                shards.put(hash, virtualNode);
                System.out.println("虚拟节点[" + virtualNode + "] hash:" + hash + "，被添加");
            }
        }
    }

    /**
     * 删除节点
     *
     * @param node
     */
    public static void delNode(String node) {
        if (realNodes.contains(node)) {
            realNodes.remove(node);
            System.out.println("真实节点[" + node + "] 下线移除");
            for (int i = 0; i < VIRTUAL_NUM; i++) {
                String virtualNode = node + "&&VN" + i;
                int hash = getHash(virtualNode);
                shards.remove(hash);
                System.out.println("虚拟节点[" + virtualNode + "] hash:" + hash + "，被移除");
            }
        }
    }

    /**
     * FNV1_32_HASH算法
     */
    private static int getHash(String str) {
        final int p = 16777619;
        int hash = (int) 2166136261L;
        for (int i = 0; i < str.length(); i++)
            hash = (hash ^ str.charAt(i)) * p;
        hash += hash << 13;
        hash ^= hash >> 7;
        hash += hash << 3;
        hash ^= hash >> 17;
        hash += hash << 5;
        // 如果算出来的值为负数则取其绝对值
        if (hash < 0) hash = Math.abs(hash);
        return hash;
    }

    public static void main(String[] args) {

        //模拟客户端的请求
        String[] nodes = {"127.0.0.1", "10.9.3.253", "192.168.10.1"};

        for (String node : nodes) {
            System.out.println("[" + node + "]的hash值为" + getHash(node) + ", 被路由到结点[" + getServer(node) + "]");
        }

        // 添加一个节点(模拟服务器上线)
        addNode("192.168.1.7");
        // 删除一个节点（模拟服务器下线）
        delNode("192.168.1.2");

        for (String node : nodes) {
            System.out.println("[" + node + "]的hash值为" + getHash(node) + ", 被路由到结点[" + getServer(node) + "]");
        }
    }
}

动态分配权重

package com.grea.qz.config;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.SortedMap;
import java.util.TreeMap;

/**
 * 个人那句不同的服务配置，动态分配权重
 */
public class ConsistencyHashingLoadFactor {

    // 真实节点列表
    private static List<Machine> realNodes = new ArrayList<>();

    // 虚拟节点，key是Hash值，value是虚拟节点信息
    private static SortedMap<Integer, String> shards = new TreeMap<>();

    static {
        realNodes.add(new Machine("192.168.1.1", LoadFactor.Memory8G));
        realNodes.add(new Machine("192.168.1.2", LoadFactor.Memory16G));
        realNodes.add(new Machine("192.168.1.3", LoadFactor.Memory32G));
        realNodes.add(new Machine("192.168.1.4", LoadFactor.Memory16G));
        for (Machine node : realNodes) {
            for (int i = 0; i < node.getMemory().getVrNum(); i++) {
                String server = node.getHost();
                String virtualNode = server + "&&VN" + i;
                int hash = getHash(virtualNode);
                shards.put(hash, virtualNode);
            }
        }
    }

    /**
     * 获取被分配的节点名
     *
     * @param node
     * @return
     */
    public static Machine getServer(String node) {
        int hash = getHash(node);
        Integer key;
        SortedMap<Integer, String> subMap = shards.tailMap(hash);
        if (subMap.isEmpty()) {
            key = shards.lastKey();
        } else {
            key = subMap.firstKey();
        }
        String virtualNode = shards.get(key);
        String realNodeName = virtualNode.substring(0, virtualNode.indexOf("&&"));
        for (Machine machine : realNodes) {
            if (machine.getHost().equals(realNodeName)) {
                return machine;
            }
        }
        return null;
    }

    /**
     * 添加节点
     *
     * @param node
     */
    public static void addNode(Machine node) {
        if (!realNodes.contains(node)) {
            realNodes.add(node);
            System.out.println("真实节点[" + node + "] 上线添加");
            for (int i = 0; i < node.getMemory().getVrNum(); i++) {
                String virtualNode = node.getHost() + "&&VN" + i;
                int hash = getHash(virtualNode);
                shards.put(hash, virtualNode);
                System.out.println("虚拟节点[" + virtualNode + "] hash:" + hash + "，被添加");
            }
        }
    }

    /**
     * 删除节点
     *
     * @param node
     */
    public static void delNode(Machine node) {
        String host = node.getHost();
        Iterator<Machine> it = realNodes.iterator();
        while (it.hasNext()) {
            Machine machine = it.next();
            if (machine.getHost().equals(host)) {
                it.remove();
                System.out.println("真实节点[" + node + "] 下线移除");
                for (int i = 0; i < node.getMemory().getVrNum(); i++) {
                    String virtualNode = node.getHost() + "&&VN" + i;
                    int hash = getHash(virtualNode);
                    shards.remove(hash);
                    System.out.println("虚拟节点[" + virtualNode + "] hash:" + hash + "，被移除");
                }
            }
        }
    }

    /**
     * FNV1_32_HASH算法
     */
    private static int getHash(String str) {
        final int p = 16777619;
        int hash = (int) 2166136261L;
        for (int i = 0; i < str.length(); i++)
            hash = (hash ^ str.charAt(i)) * p;
        hash += hash << 13;
        hash ^= hash >> 7;
        hash += hash << 3;
        hash ^= hash >> 17;
        hash += hash << 5;
        // 如果算出来的值为负数则取其绝对值
        if (hash < 0)
            hash = Math.abs(hash);
        return hash;
    }

    public static void main(String[] args) {

        // 模拟客户端的请求
        String[] nodes = {"127.0.0.1", "10.9.3.253", "192.168.10.1"};

        for (String node : nodes) {
            System.out.println("[" + node + "]的hash值为" + getHash(node) + ", 被路由到结点[" + getServer(node) + "]");
        }

        // 添加一个节点(模拟服务器上线)
        addNode(new Machine("192.168.1.7", LoadFactor.Memory16G));
        // 删除一个节点（模拟服务器下线）
        delNode(new Machine("192.168.1.1", LoadFactor.Memory8G));

        for (String node : nodes) {
            System.out.println("[" + node + "]的hash值为" + getHash(node) + ", 被路由到结点[" + getServer(node) + "]");
        }
    }
}

/**
 * 机器类
 *
 * @author yangkuanjun
 */
class Machine {

    private String host;

    private LoadFactor memory;

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public LoadFactor getMemory() {
        return memory;
    }

    public void setMemory(LoadFactor memory) {
        this.memory = memory;
    }

    public Machine(String host, LoadFactor memory) {
        super();
        this.host = host;
        this.memory = memory;
    }

    @Override
    public String toString() {
        return "Machine [host=" + host + ", memory=" + memory + "]";
    }
}

/**
 * 负载因子
 *
 * @author yangkuanjun
 */
enum LoadFactor {

    Memory8G(5), Memory16G(10), Memory32G(20);

    private int vrNum;

    LoadFactor(int vrNum) {
        this.vrNum = vrNum;
    }

    public int getVrNum() {
        return vrNum;
    }

}
一文带你了解Quartz
禅与计算机程序设计的艺术
01-08 1980
在调度进行任务争抢时先对数据库表上锁，只有拿到锁的节点才可以进行获取任务并调度，这种是常规情况下的解决方案，但这种实现方式有着很强的倾入性，且在高并发的场景性能表现也不是很出色，所以大部分情况下，我们不是很推荐通过数据表的形式实现分布式任务调度一致性。框架分布式任务调度的较好解决方案，通过在内存中进行任务争抢，大大提分布式调度性能，但还是存调度空跑问题，即先抢到锁的节点获取仅有的任务，而其他节点随后得锁后却没有执行任务，造成一次空跑。为工作内容，并按照触发器的安排进行任务的调度的任务定时被调度器执行。
重温数据结构：哈希 哈希函数 哈希表
weixin_34060299的博客
10-27 2811
点击查看 Java 集合框架深入理解 系列， - ( ゜- ゜)つロ 乾杯~ 在学习 HashMap 前，我们先来温习下 Hash(哈希) 的概念。 什么是 Hash Hash（哈希），又称“散列”。 散列（hash）英文原意是“混杂”、“拼凑”、“重新表述”的意思。 在某种程度上，散列是与排序相反的一种操作，排序是将集合中的元素按照某种方式比如字典顺...
到底什么是Hash？
weixin_44672956的博客
05-12 1003
Hash: 一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。 这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。 HASH主要用于信...
真正的理解Hash
von_Qi
08-15 601
先来了解一下Hash的基本思路： 设要存储对象的个数为num, 那么我们就用len个内存单元来存储它们(len>=num); 以每个对象ki的关键字为自变量，用一个函数h(ki)来映射出ki的内存地址，也就是ki 的下标，将ki对象的元素内容全部存入这个地址中就行了。这个就是Hash的基本思路。   Hash为什么这么想呢？换言之，为什么要用一个函
C++--哈希
最新发布
Tanecious的博客
07-15 257
哈希是一种通过哈希函数建立关键字与存储位置映射关系的数据组织方式，可实现快速查找。关键概念包括负载因子（衡量空间利用率与冲突概率）、哈希函数设计原则（如直接定址法、除留余数法等）以及哈希冲突解决方法（闭散列的线性/二次探测和开散列的链地址法）。闭散列通过探测空位解决冲突，而开散列通过链表链接冲突元素。文中还探讨了不同哈希函数的适用场景及其优缺点，强调设计高效哈希函数以减少冲突的重要性。
Hash 算法原理及应用探讨
xiangbole的博客
12-06 2523
1、什么是Hash Hash也称散列、哈希，对应的英文都是Hash。基本原理就是把任意长度的输入，通过Hash算法变成固定长度的输出。这个映射的规则就是对应的Hash算法，而原始数据映射后的二进制串就是哈希值。活动开发中经常使用的MD5和SHA都是历史悠久的Hash算法。 echo md5(“这是一个测试文案”); // 输出结果：2124968af757ed51e71e6abeac04f98d ...
怎么理解 Hash
罗罗的1024
07-15 532
什么是Hash 参考自链接: https://www.cnblogs.com/s-b-b/p/6208565.html. 哈希（hash）表的定义 哈希表是一种根据关键码去寻找值的数据映射结构，该结构通过把关键码映射的位置去寻找存放值的地方。就是通过key值然后按照某种哈希函数 hash() 计算hash(key)，得到的就是哈希值。 什么是hash冲突呢？ 我们知道不同的数字通过一个函数结果可能会一样，那么不同的值通过hash()计算得到的hash值也可能是一样的，假如数组中的3号位有对象占着，此时 ，又
详解--Hash（中文也称散列、哈希）
qq_37233070的博客
11-07 4886
Hash 也称散列、哈希，对应的英文都是 Hash。基本原理就是把任意长度的输入，通过 Hash 算法变成固定长度的输出。这个映射的规则就是对应的 Hash 算法，而原始数据映射后的二进制串就是哈希值。hash 算法理论上会出现 不同数据通过 hash 算法计算出相同的 hash 值，叫做碰撞。活动开发中经常使用的 MD5 和 SHA 都是历史悠久的 Hash 算法。好的 hash 算法至少应计算 hash 值迅速且hash 值冲突概率要小。两个知识抗碰撞能力。
一文了解vue-router之hash模式和history模式
10-16
首先，让我们详细了解一下hash模式。在hash模式中，路由的路径中包含一个“#”符号，例如：***，其中“#/hello”是hash值。Hash的历史由来已久，hash值的存在不会影响服务器接收到的HTTP请求，因此在hash发生变化时...
一文读懂 Geohash 算法：原理、案例、优缺点
专注大数据、云计算、人工智能、机器人领域技术传播
06-17 1179
平台数据库中存储了所有商家和订单的 Geohash 编码，当用户查看订单状态时，平台会根据用户位置的 Geohash 编码和骑手位置的 Geohash 编码，快速判断两者是否在相近区域。例如，长度为 8 的 Geohash 字符串表示的区域大小约为 3.7 平方米，而长度为 5 的 Geohash 字符串表示的区域大小约为 92 平方公里。这个过程融合了二进制编码和 Base32 编码，通过不断地对地球的经纬度区间进行二分，逐步缩小范围，最终确定一个特定的区域，并将其编码为一串字符。
一文了解MQ
架构师小吴的博客
06-08 1052
死 信交换机和正常的交换机没有什么不同 , 如果一个包含死信的队列配置了属性，指定了一个交换机，那么队列中的死信就会投递到这个交换机中，而这个交换机称为死信交换机为队列绑定死信交换机 , 只需要设置队列属性即可。
HASH是什么
zlh164382152的专栏
01-05 665
百科说法： hash是一种散列算法，是将不同的输入散列程特定长度的输出；不同的输入可能会得到相同的输出，所以不能从散列值来判断出输入值。 散列表：给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数。 所有散列函数都有如下一个基本特性:如果两个散列值是不相同的(根据...
哈希（hash）理解
weixin_30748995的博客
05-09 2545
转载自https://www.cnblogs.com/mingaixin/p/4318837.html 一、什么是哈希？（一种更复杂的映射） Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入，通过散列算法（哈希函数），变换成固定长度的输出，该输出就是散列值（哈希值）。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输...
【数据结构】哈希（Hash）
秋之回忆Alex的博客
09-02 8731
数据结构：哈希函数
hash(哈希)是什么
09-06 4034
hash(哈希)是什么 一、什么是哈希 hash，一般翻译为散列、杂凑，或者音译为哈希，是把任意长度的输入（又叫做预映射pre-image）通过散列算法变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间。 它其实就是一个算法，最简单的算法就是加减乘除，比方，我设计个数字算法，输入+7=输出，比如我输入1，输出为8；输入2，输出为9。 ...
hash原理的理解
人不能两次走进同一条河流
11-01 441
1.Hash原理的理解 哈希：翻译是 散列 意思是分散的意思，通常我们在查找某个数据的时候，我们想快速定位到某条数据，我们会采用哈希算法来解决这个问题。 JAVA哈希的底层实现：其实是基于桶结构来处理的，也就是一个数组结构，然后里面的元素是NODE元素，这个数据结构是链表来实现的，里面的变量有 hash,key,value,next,通过这种方式，我们能够大大减少数据的范围，Eg：ha
Hash
Muti-Agent
08-04 2390
Hash:     hash算法解决冲突的方法常用的有开放定址法、再哈希法、链地址法、 建立公共溢出区。 哈希表：     哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 1.开放定址法     开放定址...
hash
齐枫的博客
07-17 1302
#后面出现的任何字符，都会被浏览器解读为位置标识符。这意味着，这些字符都不会被发送到服务器端。 改变#后的内容不会触发页面重载 改变#会改变浏览器的访问历史 每一次改变#后的部分，都会在浏览器的访问历史中增加一个记录，使用”后退”按钮，就可以回到上一个位置。 这对于ajax应用程序特别有用，可以用不同的#值，表示不同的访问状态，然后向用户给出可以访问某个状态的链接。 值得注意的是，上述规则...
Hash64与Hash计算工具：深入了解与应用
标题“Hash计算工具”和描述“Hash,Hash64计算工具”以及标签“Hash,Hash64”均指向了一类计算机程序，这些程序能够执行哈希算法以生成数据的哈希值。哈希算法是一种将任意长度的数据转换为固定长度摘要信息（通常为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值