一、简介
Bloom Filter（BF）是一种空间效率很高的随机数据结构，它利用位数组很简洁地表示一个集合，并能判断一个元素是否属于这个集合。它是一个判断元素是否存在集合的快速的概率算法。Bloom Filter有可能会出现错误判断，但不会漏掉判断。因此，Bloom Filter不适合那些“零错误”的应用场合。而在能容忍低错误率的应用场合下，Bloom Filter比其他常见的算法（如hash，折半查找）极大节省了空间。它的优点是空间效率和查询时间都远远超过一般的算法，缺点是有一定的误识别率和删除困难。
二、算法思想
Bloom-Filter算法的核心思想就是利用多个不同的Hash函数来解决“冲突”。
计算某元素x是否在一个集合中，首先能想到的方法就是将所有的已知元素保存起来构成一个集合R，然后用元素x跟这些R中的元素一一比较来判断是否存在于集合R中；我们可以采用链表等数据结构来实现。但是，随着集合R中元素的增加，其占用的内存将越来越大。试想，如果有几千万个不同网页需要下载，所需的内存将足以占用掉整个进程的内存地址空间。即使用MD5，UUID这些方法将URL转成固定的短小的字符串，内存占用也是相当巨大的。
于是，我们会想到用Hash table的数据结构，运用一个足够好的Hash函数将一个URL映射到二进制位数组（位图数组）中的某一位。如果该位已经被置为1，那么表示该URL已经存在。
但是Hash存在一个冲突（碰撞）的问题，用同一个Hash得到的两个URL的值有可能相同。为了减少冲突，我们可以多引入几个Hash，如果通过其中的一个Hash值我们得出某元素不在集合中，那么该元素肯定不在集合中。只有在所有的Hash函数告诉我们该元素在集合中时，才能确定该元素存在于集合中。这便是Bloom-Filter的基本思想。
三、过程
工具：一个位数组、K个独立hash函数
1）位数组：
假设Bloom Filter使用一个m比特的数组来保存信息，初始状态时，Bloom Filter是一个包含m位的位数组，每一位都置为0，即BF整个数组的元素都设置为0。
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
2）添加元素，k个独立hash函数
为了表达S={x1, x2,…,xn}这样一个n个元素的集合，Bloom Filter使用k个相互独立的哈希函数（Hash Function），它们分别将集合中的每个元素映射到{1,…,m}的范围中。
当我们往Bloom Filter中增加任意一个元素x时候，我们使用k个哈希函数得到k个哈希值（可以对应数组下标），然后将数组中对应的比特位设置为1。即第i个哈希函数映射的位置hashi(x)就会被置为1（1≤i≤k）。
注意，如果一个位置多次被置为1，那么只有第一次会起作用，后面几次将没有任何效果。在下图中，k=3，且有两个哈希函数选中同一个位置（从左边数第五位，即第二个“1“处）。
3）判断元素是否存在集合
在判断y是否属于这个集合时，我们只需要对y使用k个哈希函数得到k个哈希值，如果所有hashi(y)的位置都是1（1≤i≤k），即k个位置都被设置为1了，那么我们就认为y是集合中的元素，否则就认为y不是集合中的元素。下图中y1就不是集合中的元素（因为y1有一处指向了“0”位）。y2或者属于这个集合，或者刚好是一个false positive。
很显然这个判断并不能保证查找的结果是100%正确的。
四、数学理论
参数：
m:bit数组的宽度（bit数）
n:加入其中的key的数量
k：使用的hash函数的个数
f:false positive的比率
则BF满足下面的数学公式：
在给定m和n时，能够使f最小化的k值为：
此时给出的f为：
根据上述的理论可以推出：
a、对于给定的f，则有：n = m ln(0.6185) / ln(f)
b、同时需要用k个hash函数来实现目标：k = - ln(f) / ln(2)
c、k必须取整，那么需要f = (1 – e-kn/m)k 求实际值
五、缺陷
1）Bloom Filter无法从Bloom Filter集合中删除一个元素。因为该元素对应的位会牵动到其他的元素。所以一个简单的改进就是 counting Bloom filter，用一个counter数组代替位数组，就可以支持删除了。 此外，Bloom Filter的hash函数选择会影响算法的效果。
2）还有一个比较重要的问题，如何根据输入元素个数n，确定位数组m的大小及hash函数个数，即hash函数选择会影响算法的效果。当hash函数个数k=(ln2)*(m/n)时错误率最小。在错误率不大于E的情况 下，m至少要等于n*lg(1/E) 才能表示任意n个元素的集合。但m还应该更大些，因为还要保证bit数组里至少一半为0，则m应 该>=nlg(1/E)*lge ，大概就是nlg(1/E)1.44倍(lg表示以2为底的对数)。
举个例子我们假设错误率为0.01，则此时m应大概是n的13倍。这样k大概是8个。（PS：这里m与n的单位不同，m是bit为单位，而n则是以元素个数为单位(准确的说是不同元素的个数)。通常单个元素的长度都是有很多bit的。所以使用bloom filter内存上通常都是节省的。 ）
一般BF可以与一些key-value的数据库（如redis）一起使用，来加快查询。由于BF所用的空间非常小，所有BF可以常驻内存。这样子的话，对于大部分不存在的元素，我们只需要访问内存中的BF就可以判断出来了，只有一小部分，我们需要访问在硬盘上的key-value数据库。从而大大地提高了效率。
六、应用
1、垃圾邮件过滤
像网易、腾讯等公众电子邮件（email）提供商，总是需要过滤来自发送垃圾邮件的人（spamer）的垃圾邮件。一个办法就是记录下那些发垃圾邮件的 email地址。由于那些发送者不停地在注册新的地址，全世界少说也有几十亿个发送垃圾邮件的地址，将他们都存起来则需要大量的网络服务器。如果用哈希表，每存储一亿个 email地址，就需要 1.6GB的内存（用哈希表实现的具体办法是将每一个 email地址对应成一个八字节的信息指纹，然后将这些信息指纹存入哈希表，由于哈希表的存储效率一般只有 50%，因此一个 email地址需要占用十六个字节。一亿个地址大约要 1.6GB，即十六亿字节的内存）。因此存贮几十亿个邮件地址可能需要上百GB的内存。而Bloom Filter只需要哈希表 1/8到 1/4 的大小就能解决同样的问题。BloomFilter决不会漏掉任何一个在黑名单中的可疑地址。而至于误判问题，常见的补救办法是在建立一个小的白名单，存储那些可能别误判的邮件地址
2、网络应用
1）P2P网络中查找资源操作，可以对每条网络通路保存Bloom Filter，当命中时，则选择该通路访问。
2）广播消息时，可以检测某个IP是否已发包。
3）检测广播消息包的环路，将Bloom Filter保存在包里，每个节点将自己添加入Bloom Filter。
4）信息队列管理，使用Counter Bloom Filter管理信息流量。
3、Hbase底层
Hbase也使用了Bloom Filter，以减少不存在的行或列在磁盘上的查询，大大提高了数据库的查询操作的性能。
七、java实现
package fuyunnet.com;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.List;
public class Bloomfilter {
private BitSet bitSet;
private int bitSetSize;
private int addedElements;
private int hashFunctionNumber;
/**
* 构造一个布隆过滤器，过滤器的容量为c * n 个bit.
* @param c 当前过滤器预先开辟的最大包含记录,通常要比预计存入的记录多一倍.
* @param n 当前过滤器预计所要包含的记录.
* @param k 哈希函数的个数，等同每条记录要占用的bit数.
*/
public Bloomfilter(int c, int n, int k) {
this.hashFunctionNumber = k;
this.bitSetSize = (int) Math.ceil(c * k);
this.addedElements = n;
this.bitSet = new BitSet(this.bitSetSize);
}
/**
* 通过文件初始化过滤器.
* @param file
*/
public void init(String file) {
BufferedReader reader = null;
try {
reader = new BufferedReader(new FileReader(file));
String line = reader.readLine();
while (line != null && line.length() > 0) {
this.put(line);
line = reader.readLine();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (reader != null) reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public void put(String str) {
int[] positions = createHashes(str.getBytes(), hashFunctionNumber);
for (int i = 0; i < positions.length; i++) {
int position = Math.abs(positions[i] % bitSetSize);
bitSet.set(position, true);
}
}
public boolean contains(String str) {
byte[] bytes = str.getBytes();
int[] positions = createHashes(bytes, hashFunctionNumber);
for (int i : positions) {
int position = Math.abs(i % bitSetSize);
if (!bitSet.get(position)) {
return false;
}
}
return true;
}
/**
* 得到当前过滤器的错误率.
* @return
*/
public double getFalsePositiveProbability() {
// (1 - e^(-k * n / m)) ^ k
return Math.pow((1 - Math.exp(-hashFunctionNumber * (double) addedElements / bitSetSize)),
hashFunctionNumber);
}
/**
* 将字符串的字节表示进行多哈希编码.
* @param bytes 待添加进过滤器的字符串字节表示.
* @param hashNumber 要经过的哈希个数.
* @return 各个哈希的结果数组.
*/
public static int[] createHashes(byte[] bytes, int hashNumber) {
int[] result = new int[hashNumber];
int k = 0;
while (k < hashNumber) {
result[k] = HashFunctions.hash(bytes, k);
k++;
}
return result;
}
public static void main(String[] args) throws Exception {
Bloomfilter bloomfilter = new Bloomfilter(30000000, 10000000, 8);
System.out.println("Bloom Filter Initialize ... ");
bloomfilter.init("data/base.txt");
System.out.println("Bloom Filter Ready");
System.out.println("False Positive Probability : "
+ bloomfilter.getFalsePositiveProbability());
// 查找新数据
List<String> result = new ArrayList<String>();
long t1 = System.currentTimeMillis();
BufferedReader reader = new BufferedReader(new FileReader("data/input.txt"));
String line = reader.readLine();
while (line != null && line.length() > 0) {
if (!bloomfilter.contains(line)) {
result.add(line);
}
line = reader.readLine();
}
reader.close();
long t2 = System.currentTimeMillis();
System.out.println("Parse 9900000 items, Time : " + (t2 - t1) + "ms , find "
+ result.size() + " new items.");
System.out.println("Average : " + 9900000 / ((t2 - t1) / 1000) + " items/second");
}
}
class HashFunctions {
public static int hash(byte[] bytes, int k) {
switch (k) {
case 0:
return RSHash(bytes);
case 1:
return JSHash(bytes);
case 2:
return ELFHash(bytes);
case 3:
return BKDRHash(bytes);
case 4:
return APHash(bytes);
case 5:
return DJBHash(bytes);
case 6:
return SDBMHash(bytes);
case 7:
return PJWHash(bytes);
}
return 0;
}
public static int RSHash(byte[] bytes) {
int hash = 0;
int magic = 63689;
int len = bytes.length;
for (int i = 0; i < len; i++) {
hash = hash * magic + bytes[i];
magic = magic * 378551;
}
return hash;
}
public static int JSHash(byte[] bytes) {
int hash = 1315423911;
for (int i = 0; i < bytes.length; i++) {
hash ^= ((hash << 5) + bytes[i] + (hash >> 2));
}
return hash;
}
public static int ELFHash(byte[] bytes) {
int hash = 0;
int x = 0;
int len = bytes.length;
for (int i = 0; i < len; i++) {
hash = (hash << 4) + bytes[i];
if ((x = hash & 0xF0000000) != 0) {
hash ^= (x >> 24);
hash &= ~x;
}
}
return hash;
}
public static int BKDRHash(byte[] bytes) {
int seed = 131;
int hash = 0;
int len = bytes.length;
for (int i = 0; i < len; i++) {
hash = (hash * seed) + bytes[i];
}
return hash;
}
public static int APHash(byte[] bytes) {
int hash = 0;
int len = bytes.length;
for (int i = 0; i < len; i++) {
if ((i & 1) == 0) {
hash ^= ((hash << 7) ^ bytes[i] ^ (hash >> 3));
} else {
hash ^= (~((hash << 11) ^ bytes[i] ^ (hash >> 5)));
}
}
return hash;
}
public static int DJBHash(byte[] bytes) {
int hash = 5381;
int len = bytes.length;
for (int i = 0; i < len; i++) {
hash = ((hash << 5) + hash) + bytes[i];
}
return hash;
}
public static int SDBMHash(byte[] bytes) {
int hash = 0;
int len = bytes.length;
for (int i = 0; i < len; i++) {
hash = bytes[i] + (hash << 6) + (hash << 16) - hash;
}
return hash;
}
public static int PJWHash(byte[] bytes) {
long BitsInUnsignedInt = (4 * 8);
long ThreeQuarters = ((BitsInUnsignedInt * 3) / 4);
long OneEighth = (BitsInUnsignedInt / 8);
long HighBits = (long) (0xFFFFFFFF) << (BitsInUnsignedInt - OneEighth);
int hash = 0;
long test = 0;
for (int i = 0; i < bytes.length; i++) {
hash = (hash << OneEighth) + bytes[i];
if ((test = hash & HighBits) != 0) {
hash = (int) ((hash ^ (test >> ThreeQuarters)) & (~HighBits));
}
}
return hash;
}
}
八、问题抛出
最后抛出搜索引擎领域的一个问题：
给你A,B两个文件，各存放50亿条URL，每条URL占用64字节，内存限制是4G，让你找出A,B文件共同的URL。如果是三个乃至n个文件呢？