10.哈希表、哈希映射
1.HashMap,HashSet
基本概念
-
若关键字为k ,则其值存放在f(k)的存储位置上。由此,不需比较便可直接取得所查记录。称这个对应关系f为散列函数,按这个思想建立的表为散列表。
-
对不同的关键字可能得到同一散列地址,即k1≠k2 ,而f(k1)=f(k2) ,这种现象称为冲突(英语: Collision)。具有相同函数值的关键字对该散列函数来说称做同义词。综上所述,根据散列函数f(k)和处理冲突的方法将一组关键字映射到一个有限的连续的地址集(区间).上,并以关键字在地址集中的“像”作为记录在表中的存储位置,这种表便称为散列表,这一映射过程称为散列造表或散列,所得的存储位置称散列地址。
压缩映射
两个关键
-
散列函数
-
直接定址法
-
数字分析法
-
平方取中法
-
折叠法
-
随机数法
-
除留余数法
-
-
冲突解决
-
开放定址法
-
拉链法
-
双散列
-
再散列
-
Java的HashMap
public class HashMapTest {
public static void main(String[] args) {
testHashMapAPIs();
}
private static void testHashMapAPIs() {
// 初始化随机种子
Random r = new Random();
// 新建HashMap
HashMap map = new HashMap();
// 添加操作
map.put("one", r.nextInt(10));
map.put("one", r.nextInt(10));
map.put("two", r.nextInt(10));
map.put("three", r.nextInt(10));
// 打印出map
System.out.println("map:" + map);
// 通过Iterator遍历key-value
Iterator iter = map.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry entry = (Map.Entry) iter.next();
System.out.println("next : " + entry.getKey() + " - " + entry.getValue());
}
// HashMap的键值对个数
System.out.println("size:" + map.size());
// containsKey(Object key) :是否包含键key
System.out.println("contains key two : " + map.containsKey("two"));
System.out.println("contains key five : " + map.containsKey("five"));
// containsValue(Object value) :是否包含值value
System.out.println("contains value 0 : " + map.containsValue(new Integer(0)));
// remove(Object key) ： 删除键key对应的键值对
map.remove("three");
System.out.println("map:" + map);
// clear() ： 清空HashMap
map.clear();
// isEmpty() : HashMap是否为空
System.out.println((map.isEmpty() ? "map is empty" : "map is not empty"));
}
}
map:{one=9, two=0, three=9}
next : one - 9
next : two - 0
next : three - 9
size:3
contains key two : true
contains key five : false
contains value 0 : true
map:{one=9, two=0}
map is empty
- 扩容负载因子
- 拉链边长，转为红黑树
- 优化hash函数
2.布隆过滤器
基本概念
-
布隆过滤器(英语:Bloom Filter)是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都远远超过一般的算法，缺点是有一定的误识别率和删除困难。
-
如果想判断一个元素是不是在一个集合里，一般想到的是将集合中所有元素保存起来，然后通过比较确定。链表、树、散列表(又叫哈希表,Hash table)等数据结构都是这种思路。但是随着集合中元素的增加，我们需要的存储空间越来越大。同时检索速度也越来越慢，上述三种结构的检索时间复杂度分别为O(n),O(logn),O(n/k)。布隆过滤器的原理是，当一个元素被加入集合时，通过K个散列函数将这个元素映射成一个位数组中的K个点，把它们置为1。检索时，我们只要看看这些点是不是都是1就(大约)知道集合中有没有它了:如果这些点有任何一个0，则被检元素一定不在;如果都是1，则被检元素很可能在。这就是布隆过滤器的基本思想。
-
一个Bloom Filter是基于一个m位的位向量(1...bm) ，这些位向量的初始值为0。另外，还有一
系列的hash函数(h...hk)，这些hash函数的值域属于1~m。下图是一个bloom filter插入x,y,z并
判断基个值w是否在该数据集的示意图:
不用保存原始的数据，只存储位图
简化版实现
import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;
/**简化版本的布隆过滤器的实现*/
public class BloomFilter {
public static final int NUM_SLOTS = 1024 * 1024 * 8;//位图的长度
public static final int NUM_HASH = 8;//hash函数的个数，一个hash函数的结果用于标记一个位
private BigInteger bitmap = new BigInteger("0");//位图
public static void main(String[] args) {
//测试代码
BloomFilter bf = new BloomFilter();
ArrayList<String> contents = new ArrayList<>();
contents.add("sldkjelsjf");
contents.add("ggl;ker;gekr");
contents.add("wieoneomfwe");
contents.add("sldkjelsvrnlkjf");
contents.add("ksldkflefwefwefe");
for (int i = 0; i < contents.size(); i++) {
bf.addElement(contents.get(i));
}
System.out.println(bf.check("sldkjelsvrnlkjf"));
System.out.println(bf.check("sldkjelnlkjf"));
System.out.println(bf.check("ggl;ker;gekr"));
}
/**将message+n映射到0~NUM_SLOTS-1之间的一个值*/
private int hash(String message, int n) {
message = message + String.valueOf(n);
try {
MessageDigest md5 = MessageDigest.getInstance("md5");//将任意输入映射成128位（16个字节）整数的hash函数
byte[] bytes = message.getBytes();
md5.update(bytes);
byte[] digest = md5.digest();
BigInteger bi = new BigInteger(digest);//至此，获得message+n的md5结果（128位整数）
return Math.abs(bi.intValue()) % NUM_SLOTS;
} catch (NoSuchAlgorithmException ex) {
Logger.getLogger(BloomFilter.class.getName()).log(Level.SEVERE, null, ex);
}
return -1;
// return (int)Math.abs(HashFunctions.bernstein(message,NUM_SLOTS));
}
/*处理原始数据
* 1.hash1(msg)标注一个位…… hash的值域0~NUM_SLOTS-1
* */
public void addElement(String message) {
for (int i = 0; i < NUM_HASH; i++) {
int hashcode = hash(message, i);//代表了hash1，hash2……hash8
//结果，用于标注位图的该位为1
if (!bitmap.testBit(hashcode)) {//如果还不为1
//标注位图的该位为1
bitmap = bitmap.or(new BigInteger("1").shiftLeft(hashcode));
}
}
}
public boolean check(String message) {
for (int i = 0; i < NUM_HASH; i++) {
int hashcode = hash(message, i);
//hashcode代表一个位置
if (!this.bitmap.testBit(hashcode)) {
//如果位图的该位为0，那么message一定不存在
return false;
}
}
return true;//不精确，有可能误判
}
}
3.一致性hash
缓存集群/负载均衡
基本思路
先构造一个长度为232的整数环(这个环被称为一致性Hash环),根据节点名称的Hash值(其分布为[0, 232-1])将缓存服务器节点放置在这个Hash环上,然后根据需要缓存的数据的Key值计算得到其Hash值(其分布也为[0, 232-1]),然后在Hash环上顺时针查找距离这个Key值的Hash值最近的服务器节点,完成Key到服务器的映射查找。
增加/删除节点
-
如果往集群中添加一个新的节点NODE4，通过对应的哈希算法得到KEY4，并映射到环中
-
按顺时针迁移的规则，那么被分割的对象被迁移到了NODE4中其它对象还保持这原有的存储位置。
数据倾斜
- 如果机器较少，很有可能造成机器在整个环上的分布不均匀，从而导致机器之间的负载不均衡
虚拟节点
代码实现
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.*;
/*不考虑数据倾斜*/
public class ConsistentHashing1 {
//hash算法，将关键字映射到2^32的环状空间里面
static long hash(String key) {
ByteBuffer buf = ByteBuffer.wrap(key.getBytes());
int seed = 0x1234ABCD;
ByteOrder byteOrder = buf.order();
buf.order(ByteOrder.LITTLE_ENDIAN);
long m = 0xc6a4a7935bd1e995L;
int r = 47;
long h = seed ^ (buf.remaining() * m);
long k;
while (buf.remaining() >= 8) {
k = buf.getLong();
k *= m;
k ^= k >>> r;
k *= m;
h ^= k;
h *= m;
}
if (buf.remaining() > 0) {
ByteBuffer finish = ByteBuffer.allocate(8).order(
ByteOrder.LITTLE_ENDIAN);
// for big-endian version, do this first:
// finish.position(8-buf.remaining());
finish.put(buf).rewind();
h ^= finish.getLong();
h *= m;
}
h ^= h >>> r;
h *= m;
h ^= h >>> r;
buf.order(byteOrder);
return Math.abs(h);
}
//机器节点==网络节点
static class Node implements HashNode {
String name;
String ip;
public Node(String name, String ip) {
this.name = name;
this.ip = ip;
}
@Override
public String toString() {
return this.name + "-" + this.ip;
}
@Override
public String getName() {
return name;
}
}
interface HashNode {
String getName();
}
// 节点列表
List<Node> nodes;
TreeMap<Long, Node> hashAndNode = new TreeMap<>();
TreeMap<Long, Node> keyAndNode = new TreeMap<>();
public ConsistentHashing1(List<Node> nodes) {
this.nodes = nodes;
init();
}
private void init() {
for (int i = 0; i < nodes.size(); i++) {
Node node = nodes.get(i);
long hash = hash(node.ip);
hashAndNode.put(hash, node);
}
}
private void add(String key) {
long hash = hash(key);
SortedMap<Long, Node> subMap = hashAndNode.tailMap(hash);//找到map中key比fromKey大的所有的键值对，组成一个子Map
if (subMap.size() == 0) {//hash值大于所有机器的hash归属于第一台机器
keyAndNode.put(hash, hashAndNode.firstEntry().getValue());
} else {//在大于hash中找到最小，
Node node = subMap.get(subMap.firstKey());//第一个节点，key应该归属的节点
keyAndNode.put(hash, node);
}
}
/**
* 增加一个新的机器节点
* @param newNode
*/
private void add(Node newNode) {
long hash = hash(newNode.ip);
hashAndNode.put(hash, newNode);
// 数据迁移
SortedMap<Long, Node> pre = hashAndNode.headMap(hash);//key小于hash的子map
if (pre.size() == 0) {
SortedMap<Long, Node> between = keyAndNode.subMap(0L, hash);
for (Map.Entry<Long, Node> e : between.entrySet()) {
e.setValue(newNode);
}
between = keyAndNode.tailMap(hashAndNode.lastKey());
for (Map.Entry<Long, Node> e : between.entrySet()) {
e.setValue(newNode);
}
} else {
long from = pre.lastKey();
long to = hash;
SortedMap<Long, Node> between = keyAndNode.subMap(from, to);
for (Map.Entry<Long, Node> e : between.entrySet()) {
e.setValue(newNode);
}
}
}
public static void main(String[] args) {
List<Node> nodes = new ArrayList<>();
nodes.add(new Node("node1", "192.168.1.2"));
nodes.add(new Node("node2", "192.168.1.3"));
nodes.add(new Node("node3", "192.168.1.4"));
nodes.add(new Node("node4", "192.168.1.5"));
nodes.add(new Node("node5", "192.168.1.6"));
ConsistentHashing1 obj = new ConsistentHashing1(nodes);
for (Map.Entry<Long, Node> entry :
obj.hashAndNode.entrySet()) {
System.out.println(entry.getKey() + ":" + entry.getValue().getName());
}
obj.add("a");
obj.add("b");
obj.add("c");
obj.add("e");
obj.add("zhangsan");
obj.add("lisi");
obj.add("wangwu");
obj.add("zhaoliu");
obj.add("wangchao");
obj.add("mahan");
obj.add("zhanglong");
obj.add("zhaohu");
obj.add("baozheng");
obj.add("gongsun");
obj.add("zhanzhao");
for (Map.Entry<Long, Node> entry :
obj.keyAndNode.entrySet()) {
System.out.println(entry.getKey() + " ,归属到:" + entry.getValue().getName());
}
System.out.println("===========");
obj.add(new Node("node6", "192.168.1.77"));
for (Map.Entry<Long, Node> entry :
obj.keyAndNode.entrySet()) {
System.out.println(entry.getKey() + " ,归属到:" + entry.getValue().getName());
}
}
}
4.题解
1、位（bit） 来自英文bit，音译为“比特”，表示二进制位。
2、字节（byte） 字节来自英文Byte，音译为“拜特”，习惯上用大写的“B”表示
题1:出现次数最多的数
有一个包含20亿个全是32位整数的大文件，在其中找到出现次数最多的数
通常的做法是使用hashmap
（4字节int型）key---具体的某一种数
（4字节int型）value---这种数出现的次数
那么一条key-value记录占有8字节
当记录数为2亿时，大约占用1.6G内存
那么如果20亿数据全部不相同，明显内存会溢出
优化解决方法：
使用哈希函数进行分流成16个小文件，由于哈希函数的性质，同一种数不会被分流到不同文件，而且对于不同的数，因为哈希函数分流是比较均匀的分配的，所以一般不会出现一个文件含有2亿个不同的整数情况，每个文件含有的种树也几乎一样
然后分别计算出每个文件中出现次数的第一名。
然后对这些第一名全部拿出来进行排序即可
题2:所有没出现过的数
32位无符号整数的范围是0~4294967295，现在有一个正好包含40亿个无符号整数的文件，所以在整个范围中必然有没出现过的数。可以使用最多1G的内存，怎么找到所有没出现过的数。
申请一个bit数组，数组大小为4294967295，大概为40亿bit，40亿/8 = 5亿字节，那么需要0.5G空间， bit数组的每个位置有两种状态0和1，那么怎么使用这个bit数组呢？呵呵，数组的长度刚好满足我们整数的个数范围，那么数组的每个下标值对应4294967295中的一个数，逐个遍历40亿个无符号数，例如，遇到100，则bitArray[100] = 1,遇到9999，则bitArray[9999] = 1,遍历完所有的数，将数组相应位置变为1。
题3:重复的URL
找到100亿个URL中重复的URL以及搜索词汇的topK问题。使用哈希函数进行分流成n个机器，n个机器又分流成n个小文件。利用小根堆排序选出每个文件top100，然后再进行整理选出每台机器的top100,最终再次整理得到总的top100(利用堆排序处理topK 的问题比较方便，时间复杂度为nlogn)