布隆过滤器简单实现 --- Java 版

布隆过滤器，简单来说就是判断是否存在，可以应用于爬虫项目中判断是否存在该url，还有Redis缓存穿透中，做布隆过滤器校验等等

布隆过滤器是如何判断的呢？

假设现在来了一个元素1，你要判断他否存在集合中，看图及文字：

我们有{x,y,z}假设这是三个哈希函数，实际上可以更多，我将这个元素1进行三个哈希函数转化得到三个下标值，假设为{3,18,234};那么我们将布隆过滤器这三个集合的下标为{3,18,234}的值设为1（其实这个集合是位为单位占1/8个字节，也就是只有0和1,1代表存在，0代表不存在），假设来了一个相同的元素1，那么你通过{x,y,z}进行哈希时得到的值也会是{3,18,234}，那么此时集合中三个位置的值都为1，代表存在，如果你来的元素2进行哈希得到的是{3,19,234}则代表此元素没有出现过在集合中，因为下标为19的元素为0；

故：当你进行多个HASH得到集合上位置都为1，则代表存在，有一个为0，则代表不存在；

这个时候你会说了，如果我要删除元素3它的哈希结果为{3,20,234},那么下次元素1和元素2请求岂不是都会被判断成不存在了，但是我明明只删除了元素3；

对了，实际上依赖于{3,234}的不仅仅只有元素3，还有元素1和元素2，所以这种操作的不合理的，故我将下面delete代码注释了；

聪明的你又会提问了：如果元素1得到的HASH为{2,4,7}，元素2为{3,4,18},此时集合中有元素1和元素2,并且{2,3,4,7,18}上的位置都为1，那如果我元素3的得到的哈希为{2,7,18}那岂不是也被判断为存在了

对了，这就是布隆过滤器中的误判，也就是存在误判率的，实际上当我们查询哈希结果的位置上均为1时，只能说这个元素可能在集合中。

代码实现：

import java.util.BitSet;

public class SimpleBloomFilter {

    // 布隆过滤器大小
    private static final int DEFAULT_SIZE = 1 << 25;

    // 布隆过滤器数组
    private static BitSet set = new BitSet(DEFAULT_SIZE);

    // 哈希函数种子
    private static int[] seeds = {5,12,45};

    // 自定义HASH 函数 （仅仅是hash 相当于图中的 x y z）
    private static innerHash[] Hash = new innerHash[seeds.length];

    public SimpleBloomFilter() {
        for (int i = 0; i < seeds.length; i++) {
            Hash[i] = new innerHash(DEFAULT_SIZE, seeds[i]);
        }
    }
//    static {
//        for (int i = 0; i < seeds.length; i ++){
//            Hash[i] = new innerHash(DEFAULT_SIZE,seeds[i]);
//        }
//    }

    // 根据不同的种子 做不同的hash算法
    private static class innerHash{
        private int capacity;
        private int seed;

        public innerHash(int capacity,int seed){
            this.capacity = capacity;
            this.seed = seed;
        }

        public int hash(String value){
            int res = 0;
            char[] values = value.toCharArray();
            for (char v : values){
                res = res * seed + v;
            }

            return res & (DEFAULT_SIZE - 1);
        }
    }

    public boolean contain(String value){
        if(value == null){
            return false;
        }
        boolean res = true;
        // 如果 三个HASH 函数的结构 set上都为 1 则代表 此 URL在里面
        for (int i = 0; i < seeds.length; i ++){
            res = res && set.get(Hash[i].hash(value));
        }
        return res;
    }

    /**
     * 如果添加成功返回true 否则返回false
     * @param value
     * @return
     */
    public boolean add(String value){
        if(value == null){
            return false;
        }
        // 将哈希后的值 set 设置为1
        for (int i = 0; i < seeds.length; i ++){
            if(set.get(Hash[i].hash(value))){
                return false;
            }else{
                set.set(Hash[i].hash(value));
            }
        }
        return true;
    }
    // 将三个位置上的 set都置位0
//    public boolean delete(String value){
//        if(value == null){
//            return false;
//        }
//        boolean flag = true;
//        for (int i = 0; i < seeds.length; i ++){
//            if(set.get(Hash[i].hash(value)))
//                set.clear(Hash[i].hash(value));
//            else flag = false;
//        }
//        return flag;
//    }

    public static void main(String[] args) {
        String url = "https://blog.csdn.net/foolishpichao";
        String url1 = "https://gobyexample-cn.github.io/";
        SimpleBloomFilter simpleBloomFilter = new SimpleBloomFilter();
        simpleBloomFilter.add(url);
        simpleBloomFilter.add(url1);

//        simpleBloomFilter.delete(url);
        System.out.println(SimpleBloomFilter.set);

        System.out.println(simpleBloomFilter.contain(url));

    }

}

本文地址：https://blog.csdn.net/foolishpichao/article/details/110929926