哈希开奖源码（哈希走势）

今天给各位分享哈希开奖源码的知识，其中也会对哈希走势进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、哈希算法从原理到实战
• 2、redis hashtag一文搞懂，源码解析
• 3、HashMap源码分析
• 4、哈希表C++实现电话号码查询系统源代码
• 5、Hash哈希竞猜游戏系统开发详解原理丨hash哈希竞猜游戏开发成熟源码
• 6、哈希函数的本质及生成方式

哈希算法从原理到实战

引言 

       将任意长度的二进制字符串映射为定长二进制字符串的映射规则我们称为散列（hash）算法，又叫哈希（hash）算法，而通过原始数据映射之后得到的二进制值称为哈希值。哈希表（hash表）结构是哈希算法的一种应用，也叫散列表。用的是数组支持按照下标随机访问数据的特性扩展、演化而来。可以说没有数组就没有散列表。

哈希算法主要特点

        从哈希值不能反向推导原始数据，也叫单向哈希。

        对输入数据敏感，哪怕只改了一个Bit，最后得到的哈希值也大不相同。

        散列冲突的概率要小。

        哈希算法执行效率要高，散列结果要尽量均衡。

哈希算法的核心应用

         安全加密 ：对于敏感数据比如密码字段进行MD5或SHA加密传输。

         唯一标识 ：比如图片识别，可针对图像二进制流进行摘要后MD5，得到的哈希值作为图片唯一标识。

         散列函数 :是构造散列表的关键。它直接决定了散列冲突的概率和散列表的性质。不过相对哈希算法的其他方面应用，散列函数对散列冲突要求较低，出现冲突时可以通过开放寻址法或链表法解决冲突。对散列值是否能够反向解密要求也不高。反而更加关注的是散列的均匀性，即是否散列值均匀落入槽中以及散列函数执行的快慢也会影响散列表性能。所以散列函数一般比较简单，追求均匀和高效。

        *负载均衡 ：常用的负载均衡算法有很多，比如轮询、随机、加权轮询。如何实现一个会话粘滞的负载均衡算法呢？可以通过哈希算法，对客户端IP地址或会话SessionID计算哈希值，将取得的哈希值与服务器列表大小进行取模运算，最终得到应该被路由到的服务器编号。这样就可以把同一IP的客户端请求发到同一个后端服务器上。

        *数据分片 ：比如统计1T的日志文件中“搜索关键词”出现次数该如何解决？我们可以先对日志进行分片，然后采用多机处理，来提高处理速度。从搜索的日志中依次读取搜索关键词，并通过哈希函数计算哈希值，然后再跟n(机器数)取模，最终得到的值就是应该被分到的机器编号。这样相同哈希值的关键词就被分到同一台机器进行处理。每台机器分别计算关键词出现的次数，再进行合并就是最终结果。这也是MapReduce的基本思想。再比如图片识别应用中给每个图片的摘要信息取唯一标识然后构建散列表，如果图库中有大量图片，单机的hash表会过大，超过单机内存容量。这时也可以使用分片思想，准备n台机器，每台机器负责散列表的一部分数据。每次从图库取一个图片，计算唯一标识，然后与机器个数n求余取模，得到的值就是被分配到的机器编号，然后将这个唯一标识和图片路径发往对应机器构建散列表。当进行图片查找时，使用相同的哈希函数对图片摘要信息取唯一标识并对n求余取模操作后，得到的值k，就是当前图片所存储的机器编号，在该机器的散列表中查找该图片即可。实际上海量数据的处理问题，都可以借助这种数据分片思想，突破单机内存、CPU等资源限制。

        *分布式存储 ：一致性哈希算法解决缓存等分布式系统的扩容、缩容导致大量数据搬移难题。

         JDK集合工具实现 ：HashMap、 LinkedHashMap、ConcurrentHashMap、TreeMap等。Map实现类源码分析，详见 

总结

        本文从哈希算法的原理及特点，总结了哈希算法的常见应用场景。

        其中基于余数思想和同余定理实现的哈希算法（除留取余法），广泛应用在分布式场景中（散列函数、数据分片、负载均衡）。由于组合数学中的“鸽巢”原理，理论上不存在完全没有冲突的哈希算法。（PS:“鸽巢”原理是指有限的槽位，放多于槽位数的鸽子时，势必有不同的鸽子落在同一槽内，即冲突发生。同余定理：如果a和b对x取余数操作时a%x = b%x，则a和b同余）

        构造哈希函数的常规方法有：数据分析法、直接寻址法、除留取余法、折叠法、随机法、平方取中法等  。

        常规的解决哈希冲突方法有开放寻址法（线性探测、再哈希）和链表法。JDK中的HashMap和LinkedHashMap均是采用链表法解决哈希冲突的。链表法适合大数据量的哈希冲突解决，可以使用动态数据结构（比如：跳表、红黑树等）代替链表，防止链表时间复杂度过度退化导致性能下降；反之开放寻址法适合少量数据的哈希冲突解决。

redis hashtag一文搞懂，源码解析

仅仅花括号中间的部分参与hash，hash结果为slot编号。

强制多个key写入同一个slot，也就是同一个节点（假设没有正在进行分片）。

在redis cluster中有16384个slot。

slot编号：0～16383。

cluster中存储每个节点负责哪些slot。

cluster中存储每个slot对应哪一个节点。

源码有2处。

第一处：

line：3282

方法：clusterManagetKeyHashSlot

第二处：

line：749

方法：keyHashSlot

仅{...}里的部分参与hash。

如果有多个花括号，从左向右，取第一个花括号中的内容进行hash。

若第一个花括号中内容为空如：a{}c{d}，则整个key参与hash。

相同的hashtag被分配到相同的节点，相同的槽。

hash算法采用crc16。crc16算法为redis自己封装的，源码位置： 。

HashMap源码分析

HashMap（jdk 1.8）

  使用哈希表存储键值对，底层是一个存储Node的table数组。其基本的运行逻辑是，table数组的每一个元素是一个槽，用于存储Node对象，向Hash表中插入键值对时，首先计算键的hash值，并对数组容量（即数组长度）取余，定位该键值对应放在哪个槽中，若槽中已经存在元素（即哈希冲突），将Node节点插入到冲突链表尾端，当该槽中结点超过一定数量（默认为8）并且哈希表容量超过一定值（默认为64）时，对该链表进行树化。低于一定数量（默认为6）后进行resize时，树形结构又会链表化。当哈希表的总节点数超过阈值时，对哈希表进行扩容，容量翻倍。

由于哈希表需要用到key的哈希函数，因此对于自定义类作为key使用哈希表时，需要重写哈希函数，保证相等的key哈希值相同。

由于扩容或树化过程Node节点的位置会发生改变，因此哈希表是无序的，不同时期遍历同一张哈希表，得到的节点顺序会不同。

成员变量

    Hash表的成员变量主要有存储键值对的table数组，size，装载因子loadFactory，阈值theshold，容量capacity。

table数组：

哈希表的实质就是table数组，它用来存储键值对。哈希表中内部定义了Node类来封装键值对。

 Node类实现了Map的Entry接口。包括key，value，下一个Node指针和key的hash值。

 容量Capacity：

HashMap中没有专门的属性存储容量，容量等于table.lenth，即数组的长度，默认初始化容量为16。初始化时，可以指定哈希表容量，但容量必须是2的整数次幂，在初始化过程中，会调用tableSizeFor函数，得到一个不小于指定容量的2的整数次幂，暂时存入到threshold中。

注意，若容量设置过大，那么遍历整个哈希表需要耗费更多的时间。

    阈值threshold：

指定当前hash表最多存储多少个键值对，当size超过阈值时，hash表进行扩容，扩容后容量翻倍。

   loadFactory：

threshold=capacity*loadFactory。

装填因子的大小决定了哈希表存储键值对数量的能力，它直接影响哈希表的查找性能。初始化时可以指定loadFactory的值，默认为0.75。

 初始化过程

哈希表有3个构造函数，用户可以指定哈希表的初始容量和装填因子，但初始化过程只是简单填入这两个参数，table数组并没有初始化。注意，这里的initialCapacity会向上取2的整数次幂并暂时保存到threshold中。

table数组的初始化是在第一次插入键值对时触发，实际在resize函数中进行初始化。

hash过程与下标计算

哈希表是通过key的哈希值决定Node放入哪个槽中， 在java8中 ，hash表没有直接用key的哈希值，而是自定义了hash函数。

哈希表中的key可以为null，若为null，哈希值为0，否则哈希值（一共32位）的高16位不变，低16位与高16位进行异或操作，得到新的哈希值。（h 16，表示无符号右移16位，高位补0，任何数跟0异或都是其本身，因此key的hash值高16位不变。）

之所以这样处理，是与table的下标计算有关

因为，table的长度都是2的幂，因此index仅与hash值的低n位有关（n-1为0000011111的形式），hash值的高位都被与操作置为0了，相当于hash值对n取余。

由于index仅与hash值的低n位有关，把哈希值的低16位与高16位进行异或处理，可以让Node节点能更随机均匀得放入哈希表中。

get函数：

V  get(Object key) 通过给定的key查找value

先计算key的哈希值，找到对应的槽，遍历该槽中所有结点，如果结点中的key与查找的key相同或相等，则返回value值，否则返回null。

注意，如果返回值是null，并不一定是没有这种KV映射，也有可能是该key映射的值value是null，即key-null的映射。也就是说，使用get方法并不能判断这个key是否存在，只能通过containsKey方法来实现。

put函数

V put(K key, V value) 存放键值对

计算key的哈希值，找到哈希表中对应的槽，遍历该链表，如果发现已经存在包含该key的Node，则把新的value放入该结点中，返回该结点的旧value值（旧value可能是null），如果没有找到，则创建新结点插入到 链表尾端 （java7使用的是头插法），返回null。插入结点后需要判断该链表是否需要树化，并且判断整个哈希表是否需要扩容。

由该算法可以看出，哈希表中不会有两个key相同的键值对。

resize函数

    resize函数用来初始化或扩容table数组。主要做了两件事。

1.根据table数组是否为空判断初始化还是扩容，计算出相应的newCap和newThr，新建table数组并设置新的threshold。

2.若是进行扩容，则需要将原数组中的Node移植到新的数组中。

由于数组扩容，原来键值对可能存储在新数组不同的槽中。但由于键值对位置是对数组容量取余（index=hash(key)(Capacity-1)）,由于Capacity固定为2的整数次幂，并新的Capacity（newCap）是旧的两倍（oldCap）。因此，只需要判断每个Node中的hash值在oldCap二进制那一位上是否为0(hasholdCap==0)，若为0，对newCap取余值与oldCap相同，Node在新数组中槽的位置不变，若为1，新的位置是就得位置加一个oldCap值。

因此hashMap的移植算法是，遍历旧的槽：

若槽为空，跳过。

若槽只有一个Node，计算该Node在新数组中的位置，放入新槽中。

若槽是一个链表，则遍历这个链表，分别用loHead，loTail,hiHead,hiTail两组指针建立两个链表，把hash值oldCap位为0的Node节点放入lo链表中，hash值oldCap位为1的节点放入hi链表中，之后将两个链表分别插入到新数组中，实现原键值对的移植。

lo链表放入新数组原来位置，hi链表放入新数组原来位置+oldCap中

树化过程 ：

当一个槽中结点过多时，哈希表会将链表转换为红黑树，此处挖个坑。

[总结] java8中hashMap的实现原理与7之间的区别：

1.hash值的计算方法不同 2.链表采用尾插法，之前是头插法 3.加入了红黑树结构

哈希表C++实现电话号码查询系统源代码

HASH_TABLE* create_hash_table()

{

HASH_TABLE* pHashTbl = (HASH_TABLE*)malloc(sizeof(HASH_TABLE));

memset(pHashTbl, 0, sizeof(HASH_TABLE));

return pHashTbl;

}

Hash哈希竞猜游戏系统开发详解原理丨hash哈希竞猜游戏开发成熟源码

哈希 Hash

Hash ，一般翻译做散列，也有直接音译为哈希，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。

这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。

数学表述为： h = H(M)  ，其中 H 单向散列函数， M 任意长度明文， h 固定长度散列值。

单向性(one-way)

单向性(one-way)，从预映射，能够简单迅速的得到散列值，而在计算上不可能构造一个预映射，使其散列结果等于某个特定的散列值，即构造相应的 M=J(h) 不可行。这样，散列值就能在统计上唯一的表征输入值，因此，密码学上的 Hash 又被称为”消息摘要(message digest)”，就是要求能方便的将”消息”进行”摘要”，但在”摘要”中无法得到比”摘要”本身更多的关于”消息”的信息。

抗冲突性(collision-resistant)

抗冲突性(collision-resistant)，即在统计上无法产生2个散列值相同的预映射。给定 M ，计算上无法找到 M’ ，满足 H(M)=H(M’)  ，此谓弱抗冲突性；计算上也难以寻找一对任意的 M 和 M’ ，使满足 H(M)=H(M’)  ，此谓强抗冲突性。要求”强抗冲突性”主要是为了防范所谓”生日攻击(birthday attack)”，在一个10人的团体中，你能找到和你生日相同的人的概率是4%，而在同一团体中，有2人生日相同的概率是7%。类似的，当预映射的空间很大的情况下，算法必须有足够的强度来保证不能轻易找到”相同生日”的人。

映射分布均匀性和差分分布均匀性

映射分布均匀性和差分分布均匀性，散列结果中，为 0 的 bit 和为 1 的 bit ，其总数应该大致相等；输入中一个 bit 的变化，散列结果中将有一半以上的 bit 改变，这又叫做”雪崩效应(avalanche effect)”；要实现使散列结果中出现 1bit 的变化，则输入中至少有一半以上的 bit 必须发生变化。其实质是必须使输入中每一个 bit 的信息，尽量均匀的反映到输出的每一个 bit 上去；输出中的每一个 bit，都是输入中尽可能多 bit 的信息一起作用的结果。

哈希 vs 加密

概括来说，哈希（Hash）是将目标文本转换成具有相同长度的、不可逆的杂凑字符串（或叫做消息摘要），而加密（Encrypt）是将目标文本转换成具有不同长度的、可逆的密文。从数学角度讲，哈希和加密都是一个映射。下面正式定义两者：

一个哈希算法 R=H(S) 是一个多对一映射，给定目标文本 S ， H 可以将其唯一映射为 R ，并且对于所有 S ， R 具有相同的长度。由于是多对一映射，所以 H 不存在逆映射 S=J(R) 使得 R 转换为唯一的 S 。

一个加密算法 R=E(S,KE) 是一个一一映射，其中第二个参数叫做加密密钥， E 可以将给定的明文 S 结合加密密钥KE唯一映射为密文 R ，并且存在另一个一一映射 S=D(R,KD) ，可以结合 KD 将密文 R 唯一映射为对应明文 S ，其中 KD 叫做解密密钥。

每一个时代都有属于每一个时代的底层技术。如果我们将PC互联网技术，看成是Web1.0时代的底层技术；将移动互联网技术，看成是Web2.0时代的底层技术的话；那么，区块链技术则是Web3.0时代的底层技术。

哈希函数的运用

错误校正

使用一个散列函数可以很直观的检测出数据在传输时发生的错误。在数据的发送方，对将要发送的数据应用散列函数，并将计算的结果同原始数据一同发送。在数据的接收方，同样的散列函数被再一次应用到接收到的数据上，如果两次散列函数计算出来的结果不一致，那么就说明数据在传输的过程中某些地方有错误了。这就叫做冗余校验。

语音识别

对于像从一个已知列表中匹配一个MP3文件这样的应用，一种可能的方案是使用传统的散列函数——例如MD5，但是这种方案会对时间平移、CD读取错误、不同的音频压缩算法或者音量调整的实现机制等情况非常敏感。使用一些类似于MD5的方法有利于迅速找到那些严格相同（从音频文件的二进制数据来看）的音频文件，但是要找到全部相同（从音频文件的内容来看）的音频文件就需要使用其他更高级的算法了。

信息安全

Hash算法在信息安全方面的应用主要体现在以下的3个方面：

文件校验：我们比较熟悉的校验算法有奇偶校验和CRC校验，这2种校验并没有抗数据篡改的能力，它们一定程度上能检测并纠正数据传输中的信道误码，但却不能防止对数据的恶意破坏。MD5 Hash算法的”数字指纹”特性，使它成为目前应用最广泛的一种文件完整性校验和(Checksum)算法。

数字签名：Hash 算法也是现代密码体系中的一个重要组成部分。由于非对称算法的运算速度较慢，所以在数字签名协议中，单向散列函数扮演了一个重要的角色。对 Hash 值，又称”数字摘要”进行数字签名，在统计上可以认为与对文件本身进行数字签名是等效的。而且这样的协议还有其他的优点。

鉴权协议：鉴权协议又被称作挑战–认证模式：在传输信道是可被侦听，但不可被篡改的情况下，这是一种简单而安全的方法。

为了提高数据的读取、写入的速度，一般采用缓存的方式。当遇到海量的数据时，我们可以结合分布式的方式来缓存数据。此时，访问的数据是在哪个机器上呢？我们同样可以采用哈希算法并取模的方式。最终得到的值就是应该缓存该数据的机器。

回顾Web1.0时代和Web2.0时代，我们可以看出，每一个时代都会有一种类型的底层技术，并且这种底层技术会触发一系列的产业变革。既然Web1.0时代和Web2.0时代是这样的，那么，到了Web3.0时代，同样是如此。

当区块链逐渐成熟，从仅仅只是一个局限于数字货币的存在，到金融、电商、物流、农业等诸多领域都出现了区块链的身影。区块链所展现出来的是成熟、完备和稳健的一面。当有了这些积淀之后，区块链需要在商业化上进行一个突破，才能真正把人们带入到以它为主导的Web3.0时代。

哈希函数的本质及生成方式

哈希表与哈希函数

说到哈希表，其实本质上是一个数组。通过前面的学习我们知道了，如果要访问一个数组中某个特定的元素，那么需要知道这个元素的索引。例如，我们可以用数组来记录自己好友的电话号码，索引 0 指向的元素记录着 A 的电话号码，索引 1 指向的元素记录着 B 的电话号码，以此类推。

而当这个数组非常大的时候，全凭记忆去记住哪个索引记录着哪个好友的号码是非常困难的。这时候如果有一个函数，可以将我们好友的姓名作为一个输入，然后输出这个好友的号码在数组中对应的索引，是不是就方便了很多呢？这样的一种函数，其实就是哈希函数。哈希函数的定义是将任意长度的一个对象映射到一个固定长度的值上，而这个值我们可以称作是哈希值（Hash Value）。

哈希函数一般会有以下三个特性：

任何对象作为哈希函数的输入都可以得到一个相应的哈希值；

两个相同的对象作为哈希函数的输入，它们总会得到一样的哈希值；

两个不同的对象作为哈希函数的输入，它们不一定会得到不同的哈希值。

对于哈希函数的前两个特性，比较好理解，但是对于第三种特性，我们应该如何解读呢？那下面就通过一个例子来说明。

我们按照 Java String 类里的哈希函数公式（即下面的公式）来计算出不同字符串的哈希值。String 类里的哈希函数是通过 hashCode 函数来实现的，这里假设哈希函数的字符串输入为 s，所有的字符串都会通过以下公式来生成一个哈希值：

这里为什么是“31”？下面会讲到哦~

注意：下面所有字符的数值都是按照 ASCII 表获得的，具体的数值可以在这里查阅。

如果我们输入“ABC”这个字符串，那根据上面的哈希函数公式，它的哈希值则为：

在什么样的情况下会体现出哈希函数的第三种特性呢？我们再来看看下面这个例子。现在我们想要计算字符串 "Aa" 和 "BB" 的哈希值，还是继续套用上面的的公式。

"Aa" 的哈希值为：

"Aa" = 'A' * 31 + 'a' = 65 * 31 + 97 = 2112

"BB" 的哈希值为：

"BB" = 'B' * 31 + 'B' = 66 * 31 + 66 = 2112

可以看到，不同的两个字符串其实是会输出相同的哈希值出来的，这时候就会造成哈希碰撞，具体的解决方法将会在第 07 讲中详细讨论。

需要注意的是，虽然 hashCode 的算法里都是加法，但是算出来的哈希值有可能会是一个负数。

我们都知道，在计算机里，一个 32 位 int 类型的整数里最高位如果是 0 则表示这个数是非负数，如果是 1 则表示是负数。

如果当字符串通过计算算出的哈希值大于 232-1 时，也就是大于 32 位整数所能表达的最大正整数了，则会造成溢出，此时哈希值就变为负数了。感兴趣的小伙伴可以按照上面的公式，自行计算一下“19999999999999999”这个字符串的哈希值会是多少。

hashCode 函数中的“魔数”（Magic Number）

细心的你一定发现了，上面所讲到的 Java String 类里的 hashCode 函数，一直在使用一个 31 这样的正整数来进行计算，这是为什么呢？下面一起来研究一下 Java Openjdk-jdk11 中 String.java 的源码（源码链接），看看这么做有什么好处。

public int hashCode() {

int h = hash;

if (h == 0 value.length 0) {

hash = h = isLatin1() ? StringLatin1.hashCode(value)

: StringUTF16.hashCode(value);

}

return

可以看到，String 类的 hashCode 函数依赖于 StringLatin1 和 StringUTF16 类的具体实现。而 StringLatin1 类中的 hashCode 函数（源码链接）和 StringUTF16 类中的 hashCode 函数（源码链接）所表达的算法其实是一致的。

StringLatin1 类中的 hashCode 函数如下面所示：

public static int hashCode(byte[] value) {

int h = 0;

for (byte v : value) {

h = 31 * h + (v 0xff);

}

return h

StringUTF16 类中的 hashCode 函数如下面所示：

public static int hashCode(byte[] value) {

int h = 0;

int length = value.length 1;

for (int i = 0; i length; i++) {

h = 31 * h + getChar(value, i);

}

return h

一个好的哈希函数算法都希望尽可能地减少生成出来的哈希值会造成哈希碰撞的情况。

Goodrich 和 Tamassia 这两位计算机科学家曾经做过一个实验，他们对超过 50000 个英文单词进行了哈希值运算，并使用常数 31、33、37、39 和 41 作为乘数因子，每个常数所算出的哈希值碰撞的次数都小于 7 个。但是最终选择 31 还是有着另外几个原因。

从数学的角度来说，选择一个质数（Prime Number）作为乘数因子可以让哈希碰撞减少。其次，我们可以看到在上面的两个 hashCode 源码中，都有着一条 31 * h 的语句，这条语句在 JVM 中其实都可以被自动优化成“(h 5) - h”这样一条位运算加上一个减法指令，而不必执行乘法指令了，这样可以大大提高运算哈希函数的效率。

所以最终 31 这个乘数因子就被一直保留下来了。

区块链挖矿的本质

通过上面的学习，相信你已经对哈希函数有了一个比较好的了解了。可能也发现了，哈希函数从输入到输出，我们可以按照函数的公式算法，很快地计算出哈希值。但是如果告诉你一个哈希值，即便给出了哈希函数的公式也很难算得出原来的输入到底是什么。例如，还是按照上面 String 类的 hashCode 函数的计算公式：

如果告诉了你哈希值是 123456789 这个值，那输入的字符串是什么呢？我们想要知道答案的话，只能采用暴力破解法，也就是一个一个的字符串去尝试，直到尝试出这个哈希值为止。

对于区块链挖矿来说，这个“矿”其实就是一个字符串。“矿工”，也就是进行运算的计算机，必须在规定的时间内找到一个字符串，使得在进行了哈希函数运算之后得到一个满足要求的值。

我们以比特币为例，它采用了 SHA256 的哈希函数来进行运算，无论输入的是什么，SHA256 哈希函数的哈希值永远都会是一个 256 位的值。而比特币的奖励机制简单来说是通过每 10 分钟放出一个哈希值，让“矿工们”利用 SHA256(SHA256(x)) 这样两次的哈希运算，来找出满足一定规则的字符串出来。

比方说，比特币会要求找出通过上面 SHA256(SHA256(x)) 计算之后的哈希值，这个 256 位的哈希值中的前 50 位都必须为 0 ，谁先找到满足这个要求的输入值 x，就等于“挖矿”成功，给予奖励一个比特币。我们知道，即便知道了哈希值，也很难算出这个 x 是什么，所以只能一个一个地去尝试。而市面上所说的挖矿机，其原理是希望能提高运算的速度，让“矿工”尽快地找到这个 x 出来。

关于哈希开奖源码和哈希走势的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。