布隆过滤器

布隆过滤器

如果经常判断一个元素是否存在, 可以使用以下数据结构存储

哈希表HashSet, HashMap, 将元素作为key 查找

时间复杂度O(1), 但是空间利用率不高, 占用较多的内存资源

如果是网络爬虫10 亿网站数据, 占用内存可想而知

可以使用布隆过滤器, 来降低内存的占用, 时间复杂度也较低

布隆过滤器

是一个空间效率高的概率性数据结构, 一个元素一定不存在或者可能存在

优点: 空间效率和查询时间都远超过一般的算法

缺点: 有一定的误判率, 删除难

实质上是一个很长的二进制向量和一系列随机映射函数

常见用于, 网页黑名单系统, 垃圾邮件过滤系统, 爬虫的网址判重, 解决缓存穿透问题

原理

假设遍历过滤器由20 位二进制, 3 个哈希函数组成, 每个元素经过好像函数处理都能生成一个索引位置

• 添加元素, 将每一个哈希函数生成的索引位置都设置为1
• 查询元素是否存在
  • 如果有一个哈希函数生成的索引位置不为1, 就代表不存在
  • 如果每一个哈希函数生成的索引位置都为1, 就代表存在, 但是存在一定的误判率

添加设置二进制位为1

添加, 查询的时间复杂度都是O(k), k 是哈希函数的个数, 空间复杂度是O(m), m 是二进制位的个数

误判率

误判率p 受3 个因素影响, 二进制位的个数m, 哈希函数的个数k, 数据规模n

误判率的影响因素

二进制位个数m,哈希函数个数

public class BloomFilter {
    /**
     * 二进制向量的长度, 一共有多少个二进制位
     */
    private int bitSize;
    
    /**
     * 二进制向量
     */
    private long[] bits;
    
    /**
     * 哈希函数个数
     */
    private int hashSize;

    /**
     * 构造函数
     * @param n 数据规模
     * @param p 误判率, 取值范围
     */
    public BloomFilter(int n, double p) {
        if (n <= 0 || p <= 0 || p >= 1) {
            throw new IllegalArgumentException("wrong n or g");
        }
        // 根据公式计算对应数据
        double ln2 = Math.log(2);
        // 二进制向量长度
        bitSize = (int)(-(n * Math.log(p)) / (ln2 * ln2));
        hashSize = (int)(bitSize * ln2 / n);
        // bits 长度
        bits = new long[(bitSize + Long.SIZE - 1) / Long.SIZE];
        
    }
    
    /**
     * 添加元素
     */
    public boolean put(T value) {
        nullCheck(value);
        // 利用value 生成2 个整数
        int hash1 = value.hashCode();
        int hash2 = hash1 >>> 16;
        
        boolean result = false;
        for (int i = 0; i < hashSize; i++) {
            int combinedHash = hash1 + (i * hash2);
            if (combinedHash < 0) {
                combinedHash = ~combinedHash;
            }   
            // 生成一个二进制的索引
            int index = combinedHash % bitSize;
            // 设置第index位置的二进制为1
            if (set(index)) result = true;
        }
        
        return result;
    }
    
    /**
     * 判断一个元素是否存在
     */
    public boolean contains(T value) {
        return false;
    }
    
    /**
     * 设置index 位置二进制为1
     */
    private boolean set(int index) {
        // 对应的long 值
        long value = bits[index / Long.SIZE];
        int bitValue = 1 << (index % Long.SIZE);
        bits[index / Long.SIZE] = value | bitValue;
        return (value & bitValue) == 0;
    }
    
    /**
     * 查看index 位置的二进制的值
     */
    private boolean get(int index) {
        long value = bits[index / Long.SIZE];
        return (value & (1 << (index % Long.SIZE))) != 0;
    }
    
    private void nullCheck(T value) {
        if (value == null) {
            throw new IllegalArgumentException("Value must not be null ");
        }
    }
    
}