布隆过滤器+CBF scala实现+代码详解

简介

布隆过滤器可以说是在大数据的处理算法方面经常使用的基础算法。
在这方面我看了很多的博客，确实看到了很多很详细的解释和总结，但是都是零散的，没有很全面的在原理和实现，以及实现代码的解析等方面做的很全面的。所以我将我自己整理的东西很完整的和大家分享。

其中在实际的使用和实现方面，我会增加spark的实现，以及scala的BF和CBF的两个简单的demo。

BloomFilter

使用范围：可以用来实现数据字典，进行数据的判重，或者集合求交

原理：位数组+k个独立hash函数。将hash函数对应的值的位数组置1，查找时如果发现所有hash函数对应位都是1说明存在，很明显这个过程并不保证查找的结果是100%正确的。

缺点：首先就是会存在错误率，但是为什么有错误率还是仍然被大量使用呢？这个也很简单理解，毕竟在真正的业务场景中那可以处理上十亿条数据，那么假如说有0.001的错误率那看在时间高效的优点下，还是会选择BF的。同时也不支持删除一个已经插入的关键字，因为修改关键字对应的位会牵动到其他的关键字。

上面的缺点我们提到了就是存在错误率，那么好消息是这个错误率其实是可以被开发人员根据应用场景的要求来调整的。

那么上面我们解释一下参数的意思：
p代表错误率，一般设置的参数0.01或者更小。
n是输入的元素的个数。
m代表bit数组长度。
然后k代表hash函数的个数。

举个例子我们假设错误率为0.01，则此时m应大概是n的13倍。这样k大概是8个。

通常单个元素的长度都是有很多bit的。所以使用bloom filter内存上通常都是节省的。

可见我们能得到一个规律：
那就是你想要的错误率越低，m就需要的位数越大。
然后m越大就需要的hash函数的个数越多。
仔细一想 没毛病。当然时间也会越长，但是和其他的遍历相等的方法也快了不止一点半点。

BloomFilter的简单优化

我们知道只要你使用了BloomFilter就会存在一点点的错误率，那么既然你使用布隆过滤器来加速查找和判断是否存在，那么性能很低的哈希函数不是个好选择，推荐 MurmurHash这类的高性能hash函数。

在后面的代码部分我会实现一个scala的使用MurmurHash的BloomFilter。

改进BloomFilter

Bloom filter将集合中的元素映射到位数组中，用k（k为哈希函数个数）个映射位是否全1表示元素在不在这个集合中。Counting bloom filter（CBF）将位数组中的每一位扩展为一个counter，从而支持了元素的删除操作。Spectral Bloom Filter（SBF）将其与集合元素的出现次数关联。SBF采用counter中的最小值来近似表示元素的出现频率。

spark 的布隆过滤器

其实spark框架下有很好的封装，所以即使你不知道原理，也可以使用。

bloomFilter(colName:String,expectedNumItems:Long,fpp:Double)
//param(使用的数据列，数据量期望，损失精度)
//损失精度越低生成的布隆数组长度越长，占用的空间越多，计算过程越长。

然后我用scala实现了一个spark中的BF

import day0215.schema_info
import org.apache.spark.sql.SparkSession

/**
  * @Author: Braylon
  * @Date: 2020/2/18 17:02
  * @Description: BF in Spark
  */
object BloomFilter {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().master("local").appName("spark sql2").getOrCreate()

    val data = spark.sparkContext.textFile("D:\\idea\\projects\\scalaDemo\\src\\resources\\node.txt").map(_.split(" "))

    val df_ = data.map(s => schema_info(s(0).toInt, s(1).trim(), s(2).toInt))

    import spark.sqlContext.implicits._
    var df = df_.toDF
    df.show()

    val df1 = spark.sparkContext.parallelize(Seq(
      Worker("Braylon",30000), Worker("Tim",1000), Worker("Jackson",20000)
    )).toDF
    df1.show(false)

    val rdd = spark.sparkContext.parallelize(Seq("Braylon","J.C","Neo"))

    // 生成bloomFilter
    val bf = df1.stat.bloomFilter("name",20L,0.01)
    val res = rdd.map(x=>(x,bf.mightContainString(x)))
    res.foreach(println)
  }
}
case class Worker(name:String,Sal:Int)

scala实现BF、CBF

package BigDataAlgorithm

import java.util.BitSet

import scala.util.hashing.MurmurHash3


/**
  * @Author: Braylon
  * @Date: 2020/2/19 10:44
  * @Description: scala BF
  */
object BloomFilter {
  //定义映射位数组长度
  val BitArr = 1 << 16
  //定义Bit数组
  val bitSet = new BitSet(BitArr)

  /**
    * 一个名为seed的值代表盐。向其提供任何随机但私有的（对您的应用而言）数据，因此哈希函数将为相同数据提供不同的结果。
    * 例如，使用此功能提取您的数据摘要，以检测第三人对原始数据的修改。在知道您使用的盐之前，他们几乎无法复制有效的哈希值。
    * final def stringHash(str: String, seed: Int): Int
    * Compute the hash of a string
    */
  val seed = 2

  def hash(str:String):Unit = {
    //null是用来判断有没有这个容器，而isEmpty是有这个容器，来判断这个容器中的内容有没有东西是不是空的
    if (str != null && !str.isEmpty) {
      for (seed_tmp <- 1 to seed) bitSet.set(Math.abs(MurmurHash3.stringHash(str, seed_tmp)) % BitArr, true)
    }
    else
      println("error input")
  }

  /**
    * 判断存在
    */
  def checkIfExisted(str:String):Boolean = {
    def existsRecur(str: String,seed_tmp:Int):Boolean = {
      if (str == null && str.isEmpty) false
      else if (seed_tmp > seed) true
      else if (!bitSet.get(Math.abs(MurmurHash3.stringHash(str, seed_tmp)) % BitArr)) false
      /**
      * boolean get(int index)
      * 返回指定索引处的位值。
      */
      else existsRecur(str, seed + 1)
    }
    if (str == null || str.isEmpty)
      false
    else
      existsRecur(str, 1)
  }

  def main(args: Array[String]): Unit = {
    val str1 = "timeStamp"
    val str2 = "what are you up to"
    val str3 = "back to WHU as soon as possible"
    val str4 = "i love WHU"

    BloomFilter.hash(str1)
    BloomFilter.hash(str2)
    BloomFilter.hash(str3)
    BloomFilter.hash(str4)

    println(BloomFilter.checkIfExisted(str1))
    println(BloomFilter.checkIfExisted(str3))
    println(BloomFilter.checkIfExisted("neo"))
    println(BloomFilter.checkIfExisted("ksjdfhwiebxdkjfskf"))
  }
}

CBF

package BigDataAlgorithm

import scala.util.hashing.MurmurHash3

/**
  * @Author: Braylon
  * @Date: 2020/2/19 12:08
  * @Description: scala CBF
  */
object CountingBloomFilter {
  val totalNum = 1 << 16
  val CBFArr = new Array[Int](totalNum)

  //我们仍然使用MurmurHash，定义seedNum
  val seedNum = 2

  def hash(str:String):Unit = {
    if (str != null && !str.isEmpty){
      for (seed_tmp <- 1 to seedNum) CBFArr(Math.abs(MurmurHash3.stringHash(str, seed_tmp)) % totalNum) += 1
    }
    else
      println("error input")
  }

  def checkIfExisted(str:String):Boolean = {
    def existed(str:String, seed_tmp:Int):Boolean = {
      if (str == null && str.isEmpty) false
      else if (seed_tmp > seedNum) true
      else if (CBFArr(Math.abs(MurmurHash3.stringHash(str, seed_tmp)) % totalNum) < 0 )  false
      /**
        * boolean get(int index)
        * 返回指定索引处的位值。
        */
      else existed(str, seed_tmp + 1)
    }
    if (str==null || str.isEmpty) false
    else existed(str, 1)
  }

  def main(args: Array[String]): Unit = {
    val str1 = "www.baidu.com"
    val str2 = "Tom and Jerry"
    val str3 = "Tim is a good girl"
    val str4 = "Braylon is a good student"

    BloomFilter.hash(str1)
    BloomFilter.hash(str2)
    BloomFilter.hash(str3)
    BloomFilter.hash(str4)

    println(BloomFilter.checkIfExisted(str1))
    println(BloomFilter.checkIfExisted(str3))
    println(BloomFilter.checkIfExisted("neo"))
    println(BloomFilter.checkIfExisted("ksjdfhwiebxdkjfskf"))
  }
}

大家共勉~~
有不好的地方欢迎指正