布隆过滤器

简介

它实际上是一个很长的二进制向量(位图)和一系列随机映射函数（哈希函数）。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都远远超过一般的算法，
缺点是有一定的误识别率和删除困难。

主要作用就是判断是否存在，常用的方法有：

Map判断：效率慢，占用内存大

list判断：效率高，占用内存大

布隆过滤器：效率高，占用内存小，有误判。数据量巨大时，优先选用，因为占用内存小

原理

实际上布隆过滤器就是一个bit数组bit[m]，现在我们新建一个长度为16的布隆过滤器，默认值都是0，就像下面这样：

元素比如字符串baidu通过k个hash函数计算出k个数字，然后将k个数字所在的下标都标注为1。

现在需要添加一个数据：

我们通过某种计算方式，比如Hash1，计算出了Hash1(数据)=5，我们就把下标为5的格子改成1，就像下面这样：

我们又通过某种计算方式，比如Hash2，计算出了Hash2(数据)=9，我们就把下标为9的格子改成1，就像下面这样：

还是通过某种计算方式，比如Hash3，计算出了Hash3(数据)=2，我们就把下标为2的格子改成1，就像下面这样：

这样，刚才添加的数据就占据了布隆过滤器“5”，“9”，“2”三个格子。

我们只需要将元素通过同样的hash函数计算出k个数字，然后在bit数组钟判断下标是否都为1就可以在误报率p内判断出该元素是否在布隆过滤器中存在了。

通过原理可以推导出布隆过滤器的优缺点：

优点：由于存放的不是完整的数据，所以占用的内存很少，而且新增，查询速度够快；
缺点：随着数据的增加，误判率随之增加；无法做到删除数据；只能判断数据是否一定不存在，而无法判断数据是否一定存在。

当存入的数据量越来越大时，因为布隆过滤器中大部分位置都被标注为1，这个时候误判率就会增加，根据原理可以很容易的判断出可以增加hash函数k来增大成功几率。

布隆过滤器中的参数：k 为哈希函数个数，m 为布隆过滤器长度，n 为插入的元素个数，p 为误报率。

计算公式：

应用场景

redis缓存击穿，通过布隆过滤器判断key是否存在，不存在则直接返回，避免查库
url判断
秒杀判断是否重复购买

实现

guava实现布隆过滤器

引包

      <dependency>
          <groupId>com.google.guava</groupId>
          <artifactId>guava</artifactId>
          <version>19.0</version>
      </dependency>

然后就可以测试啦：

import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;

public class Test {
  //预计要插入多少数据
  private static int size = 1000000;
  //期望的误判率
  private static double fpp = 0.01;
  private static BloomFilter<Integer> bloomFilter = BloomFilter.create(Funnels.integerFunnel(), size, fpp);
  public static void main(String[] args) {
      //插入数据
      for (int i = 0; i < 1000000; i++) {
          bloomFilter.put(i);
      }
      int count = 0;
      // 简单测算误判率 是否在设定范围内
      for (int i = 1000000; i < 2000000; i++) {
          if (bloomFilter.mightContain(i)) {
              count++;
              System.out.println(i + "误判了");
          }
      }
      System.out.println("总共的误判数:" + count);
      System.out.println("误判率:" + count/1000000D);
  }
}

上面这种方法存在缺点：

每次项目重启都需要重新将数据加入布隆过滤器中
分布式时需要每个集群节点都存储一份相同数据到布隆过滤器中
随着数据量加大，占用jvm内存

为解决这些问题，可以考虑使用redis作为布隆过滤器

redis实现布隆过滤器

上面使用guava实现布隆过滤器是把数据放在本地内存中，无法实现布隆过滤器的共享，我们还可以把数据放在redis中，用 redis来实现布隆过滤器，我们要使用的数据结构是bitmap，你可能会有疑问，redis支持五种数据结构：String，List，Hash，Set，ZSet，没有bitmap呀。没错，实际上bitmap的本质还是String。

可能有小伙伴会说，纳尼，布隆过滤器还没介绍完，怎么又出来一个bitmap，没事，你可以把bitmap就理解为一个二进制向量。

要用redis来实现布隆过滤器，我们需要自己设计映射函数，自己度量二进制向量的长度，这对我来说，无疑是一个不可能完成的任务，只能借助搜索引擎，下面直接放出代码把。

public class RedisMain {
  static final int expectedInsertions = 1000;//要插入多少数据
  static final double fpp = 0.01;//期望的误判率

  //bit数组长度
  private static long numBits;

  //hash函数数量
  private static int numHashFunctions;

  static {
      numBits = optimalNumOfBits(expectedInsertions, fpp);
      numHashFunctions = optimalNumOfHashFunctions(expectedInsertions, numBits);
  }

  public static void main(String[] args) {
      Jedis jedis = new Jedis("localhost", 6379);
      for (int i = 0; i < 1000; i++) {
          long[] indexArray = getIndexArray(String.valueOf(i));
          for (long index : indexArray) {
              jedis.setbit("codebear:bloom", index, true);
          }
      }
      int num = 0;
      for (int i = 1000; i < 2000; i++) {
          long[] indexArray = getIndexArray(String.valueOf(i));
          for (long index : indexArray) {
              if (!jedis.getbit("codebear:bloom", index)) {
                  System.out.println(i + "一定不存在");
                  num++;
                  break;
              }
          }
      }
      System.out.println("一定不存在的有" + num + "个");
  }

  /**
   * 根据key获取bitmap下标
   */
  private static long[] getIndexArray(String key) {
      long hash1 = hash(key);
      long hash2 = hash1 >>> 16;
      long[] result = new long[numHashFunctions];
      for (int i = 0; i < numHashFunctions; i++) {
          long combinedHash = hash1 + i * hash2;
          if (combinedHash < 0) {
              combinedHash = ~combinedHash;
          }
          result[i] = combinedHash % numBits;
      }
      return result;
  }

  private static long hash(String key) {
      return Hashing.MURMUR_HASH.hash(key);
  }

  //计算hash函数个数
  private static int optimalNumOfHashFunctions(long n, long m) {
      return Math.max(1, (int) Math.round((double) m / n * Math.log(2)));
  }

  //计算bit数组长度
  private static long optimalNumOfBits(long n, double p) {
      if (p == 0) {
          p = Double.MIN_VALUE;
      }
      return (long) (-n * Math.log(p) / (Math.log(2) * Math.log(2)));
  }
}

扩展 BitMap

bitmap也是利用bit数组来存储数据，因为bit只能为0，1,所以在只有true|false的存储场景可以使用bitmap实现。或者利用bit数组下标来存储特定的数据
使用bitMap最大的优势就是可以节约大量内存
比如典型场景：打卡签到

将打卡处设为1，未打卡处设为0，1年的打卡记录只需要365个bit位就可以存储

示例实现：

public class BitMap {
    //保存数据的
    private byte[] bits;
    
    //能够存储多少数据
    private int capacity;
    
    
    public BitMap(int capacity){
        this.capacity = capacity;
        
        //1bit能存储8个数据，那么capacity数据需要多少个bit呢，capacity/8+1,右移3位相当于除以8
        bits = new byte[(capacity >>3 )+1];
    }
    
    public void add(int num){
        // num/8得到byte[]的index
        int arrayIndex = num >> 3; 
        
        // num%8得到在byte[index]的位置
        int position = num & 0x07; 
        
        //将1左移position后，那个位置自然就是1，然后和以前的数据做|，这样，那个位置就替换成1了。
        bits[arrayIndex] |= 1 << position; 
    }
    
    public boolean contain(int num){
        // num/8得到byte[]的index
        int arrayIndex = num >> 3; 
        
        // num%8得到在byte[index]的位置
        int position = num & 0x07; 
        
        //将1左移position后，那个位置自然就是1，然后和以前的数据做&，判断是否为0即可
        return (bits[arrayIndex] & (1 << position)) !=0; 
    }
    
    public void clear(int num){
        // num/8得到byte[]的index
        int arrayIndex = num >> 3; 
        
        // num%8得到在byte[index]的位置
        int position = num & 0x07; 
        
        //将1左移position后，那个位置自然就是1，然后对取反，再与当前值做&，即可清除当前的位置了.
        bits[arrayIndex] &= ~(1 << position); 

    }
    
    public static void main(String[] args) {
        BitMap bitmap = new BitMap(100);
        bitmap.add(7);
        System.out.println("插入7成功");
        
        boolean isexsit = bitmap.contain(7);
        System.out.println("7是否存在:"+isexsit);
        
        bitmap.clear(7);
        isexsit = bitmap.contain(7);
        System.out.println("7是否存在:"+isexsit);
    }
}