布隆过滤器内容完善

docs/dataStructures-algorithms/data-structure/bloom-filter.md

@@ -6,22 +6,23 @@
 2. 布隆过滤器的原理介绍。
 3. 布隆过滤器使用场景。
 4. 通过 Java 编程手动实现布隆过滤器。
-5. 利用Google开源的guava中自带的布隆过滤器。
-6. 总结。
+5. 利用Google开源的Guava中自带的布隆过滤器。
+6. Redis 中的布隆过滤器。
+7. 总结。
 
 ### 1.什么是布隆过滤器？
 
 首先，我们需要了解布隆过滤器的概念。
 
-布隆过滤器（Bloom Filter）是一个叫做 Bloom 的老哥于1970年提出的。我们可以把它看作由二进制向量（或者说位数组）和一系列随机映射函数（哈希函数）两部分组成的数据结构。相比于我们平时常用的的 List、Map 、Set 等数据结构，它占用空间更少并且效率更高，但是缺点是其返回的结果是概率性的，而不是非常准确的。并且理论情况下添加到集合中的元素越多，误报的可能性就越大。
+布隆过滤器（Bloom Filter）是一个叫做 Bloom 的老哥于1970年提出的。我们可以把它看作由二进制向量（或者说位数组）和一系列随机映射函数（哈希函数）两部分组成的数据结构。相比于我们平时常用的的 List、Map 、Set 等数据结构，它占用空间更少并且效率更高，但是缺点是其返回的结果是概率性的，而不是非常准确的。理论情况下添加到集合中的元素越多，误报的可能性就越大。并且，存放在布隆过滤器的数据不容易删除。
 
 ![布隆过滤器示意图](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-11/布隆过滤器-bit数组.png)
 
 位数组中的每个元素都只占用 1 bit ，并且每个元素只能是 0 或者 1。这样申请一个 100w 个元素的位数组只占用  1000000 / 8 = 125000 B = 15625 byte ≈ 15.3kb 的空间。
 
 总结：**一个名叫 Bloom 的人提出了一种来检索元素是否在给定大集合中的数据结构，这种数据结构是高效且性能很好的，但缺点是具有一定的错误识别率和删除难度。并且，理论情况下，添加到集合中的元素越多，误报的可能性就越大。**
 
-### 2.布隆过滤器的原理介绍。
+### 2.布隆过滤器的原理介绍
 
 **当一个元素加入布隆过滤器中的时候，会进行如下操作：**
 
@@ -43,9 +44,194 @@
 
 如果我们需要判断某个字符串是否在布隆过滤器中时，只需要对给定字符串再次进行相同的哈希计算，得到值之后判断位数组中的每个元素是否都为 1，如果值都为 1，那么说明这个值在布隆过滤器中，如果存在一个值不为 1，说明该元素不在布隆过滤器中。
 
-存在的问题是：**不同的字符串可能哈希出来的位置相同，这种情况我们可以适当增加位数组大小或者调整我们的哈希函数。**
+**不同的字符串可能哈希出来的位置相同，这种情况我们可以适当增加位数组大小或者调整我们的哈希函数。**
+
+综上，我们可以得出：**布隆过滤器说某个元素存在，小概率会误判。布隆过滤器说某个元素不在，那么这个元素一定不在。**
 
 ### 3.布隆过滤器使用场景
 
-1. 判断给定数据是否存在：比如判断 防止缓存穿透
-2. 去重：比如爬给定网址的时候对已经爬取过的 URL 去重。
+1. 判断给定数据是否存在：比如判断一个数字是否在于包含大量数字的数字集中（数字集很大，5亿以上！）、 防止缓存穿透（判断请求的数据是否有效避免直接绕过缓存请求数据库）等等、邮箱的垃圾邮件过滤、黑名单功能等等。
+2. 去重：比如爬给定网址的时候对已经爬取过的 URL 去重。
+
+### 4.通过 Java 编程手动实现布隆过滤器
+
+我们上面已经说了布隆过滤器的原理，知道了布隆过滤器的原理之后就可以自己手动实现一个了。
+
+如果你想要手动实现一个的话，你需要：
+
+1. 一个合适大小的位数组保存数据
+2. 几个不同的哈希函数
+3. 添加元素到位数组（布隆过滤器）的方法实现
+4. 判断给定元素是否存在于位数组（布隆过滤器）的方法实现。
+
+下面给出一个我觉得写的还算不错的代码（参考网上已有代码改进得到，对于所有类型对象皆适用）：
+
+```java
+import java.util.BitSet;
+
+public class MyBloomFilter {
+
+    /**
+     * 位数组的大小
+     */
+    private static final int DEFAULT_SIZE = 2 << 24;
+    /**
+     * 通过这个数组可以创建 6 个不同的哈希函数
+     */
+    private static final int[] SEEDS = new int[]{3, 13, 46, 71, 91, 134};
+
+    /**
+     * 位数组。数组中的元素只能是 0 或者 1
+     */
+    private BitSet bits = new BitSet(DEFAULT_SIZE);
+
+    /**
+     * 存放包含 hash 函数的类的数组
+     */
+    private SimpleHash[] func = new SimpleHash[SEEDS.length];
+
+    /**
+     * 初始化多个包含 hash 函数的类的数组，每个类中的 hash 函数都不一样
+     */
+    public MyBloomFilter() {
+        // 初始化多个不同的 Hash 函数
+        for (int i = 0; i < SEEDS.length; i++) {
+            func[i] = new SimpleHash(DEFAULT_SIZE, SEEDS[i]);
+        }
+    }
+
+    /**
+     * 添加元素到位数组
+     */
+    public void add(Object value) {
+        for (SimpleHash f : func) {
+            bits.set(f.hash(value), true);
+        }
+    }
+
+    /**
+     * 判断指定元素是否存在于位数组
+     */
+    public boolean contains(Object value) {
+        boolean ret = true;
+        for (SimpleHash f : func) {
+            ret = ret && bits.get(f.hash(value));
+        }
+        return ret;
+    }
+
+    /**
+     * 静态内部类。用于 hash 操作！
+     */
+    public static class SimpleHash {
+
+        private int cap;
+        private int seed;
+
+        public SimpleHash(int cap, int seed) {
+            this.cap = cap;
+            this.seed = seed;
+        }
+
+        /**
+         * 计算 hash 值
+         */
+        public int hash(Object value) {
+            int h;
+            return (value == null) ? 0 : Math.abs(seed * (cap - 1) & ((h = value.hashCode()) ^ (h >>> 16)));
+        }
+
+    }
+}
+```
+
+测试：
+
+```java
+        String value1 = "https://javaguide.cn/";
+        String value2 = "https://github.com/Snailclimb";
+        MyBloomFilter filter = new MyBloomFilter();
+        System.out.println(filter.contains(value1));
+        System.out.println(filter.contains(value2));
+        filter.add(value1);
+        filter.add(value2);
+        System.out.println(filter.contains(value1));
+        System.out.println(filter.contains(value2));
+```
+
+Output:
+
+```
+false
+false
+true
+true
+```
+
+测试：
+
+```java
+        Integer value1 = 13423;
+        Integer value2 = 22131;
+        MyBloomFilter filter = new MyBloomFilter();
+        System.out.println(filter.contains(value1));
+        System.out.println(filter.contains(value2));
+        filter.add(value1);
+        filter.add(value2);
+        System.out.println(filter.contains(value1));
+        System.out.println(filter.contains(value2));
+```
+
+Output:
+
+```java
+false
+false
+true
+true
+```
+
+### 5.利用Google开源的 Guava中自带的布隆过滤器
+
+自己实现的目的主要是为了让自己搞懂布隆过滤器的原理，Guava 中布隆过滤器的实现算是比较权威的，所以实际项目中我们不需要手动实现一个布隆过滤器。
+
+首先我们需要在项目中引入 Guava 的依赖：
+
+```java
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>28.0-jre</version>
+        </dependency>
+```
+
+实际使用如下：
+
+我们创建了一个最多存放 最多 1500个整数的布隆过滤器，并且我们可以容忍误判的概率为百分之（0.01）
+
+```java
+        // 创建布隆过滤器对象
+        BloomFilter<Integer> filter = BloomFilter.create(
+                Funnels.integerFunnel(),
+                1500,
+                0.01);
+        // 判断指定元素是否存在
+        System.out.println(filter.mightContain(1));
+        System.out.println(filter.mightContain(2));
+        // 将元素添加进布隆过滤器
+        filter.put(1);
+        filter.put(2);
+        System.out.println(filter.mightContain(1));
+        System.out.println(filter.mightContain(2));
+```
+
+在我们的示例中，当`mightContain（）` 方法返回*true*时，我们可以99％确定该元素在过滤器中，当过滤器返回*false*时，我们可以100％确定该元素不存在于过滤器中。
+
+### 6.Redis 中的布隆过滤器
+
+- https://juejin.im/post/5bc7446e5188255c791b3360
+
+### 8.其他推荐阅读
+
+1. 详解布隆过滤器的原理，使用场景和注意事项：https://zhuanlan.zhihu.com/p/43263751
+2.