修正若干错别字

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

@@ -39,7 +39,7 @@
 
 ![布隆过滤器hash计算](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-11/布隆过滤器-hash运算.png)
 
-如图所示，当字符串存储要加入到布隆过滤器中时，该字符串首先由多个哈希函数生成不同的哈希值，然后在对应的位数组的下表的元素设置为 1（当位数组初始化时 ，所有位置均为0）。当第二次存储相同字符串时，因为先前的对应位置已设置为 1，所以很容易知道此值已经存在（去重非常方便）。
+如图所示，当字符串存储要加入到布隆过滤器中时，该字符串首先由多个哈希函数生成不同的哈希值，然后将对应的位数组的下标设置为 1（当位数组初始化时，所有位置均为0）。当第二次存储相同字符串时，因为先前的对应位置已设置为 1，所以很容易知道此值已经存在（去重非常方便）。
 
 如果我们需要判断某个字符串是否在布隆过滤器中时，只需要对给定字符串再次进行相同的哈希计算，得到值之后判断位数组中的每个元素是否都为 1，如果值都为 1，那么说明这个值在布隆过滤器中，如果存在一个值不为 1，说明该元素不在布隆过滤器中。
 
@@ -147,15 +147,15 @@ public class MyBloomFilter {
 测试：
 
 ```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));
+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:
@@ -170,15 +170,15 @@ 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));
+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:
@@ -190,61 +190,61 @@ true
 true
 ```
 
-### 5.利用Google开源的 Guava中自带的布隆过滤器
+### 5.利用 Google 开源的 Guava 中自带的布隆过滤器
 
 自己实现的目的主要是为了让自己搞懂布隆过滤器的原理，Guava 中布隆过滤器的实现算是比较权威的，所以实际项目中我们不需要手动实现一个布隆过滤器。
 
 首先我们需要在项目中引入 Guava 的依赖：
 
 ```java
-        <dependency>
-            <groupId>com.google.guava</groupId>
-            <artifactId>guava</artifactId>
-            <version>28.0-jre</version>
-        </dependency>
+<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));
+// 创建布隆过滤器对象
+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％确定该元素不存在于过滤器中。
+在我们的示例中，当`mightContain()` 方法返回 *true* 时，我们可以99％确定该元素在过滤器中，当过滤器返回 *false* 时，我们可以100％确定该元素不存在于过滤器中。
 
 **Guava 提供的布隆过滤器的实现还是很不错的（想要详细了解的可以看一下它的源码实现），但是它有一个重大的缺陷就是只能单机使用（另外，容量扩展也不容易），而现在互联网一般都是分布式的场景。为了解决这个问题，我们就需要用到 Redis 中的布隆过滤器了。**
 
 ### 6.Redis 中的布隆过滤器
 
-#### 6.1介绍
+#### 6.1 介绍
 
 Redis v4.0 之后有了 Module（模块/插件） 功能，Redis Modules 让 Redis 可以使用外部模块扩展其功能 。布隆过滤器就是其中的 Module。详情可以查看 Redis 官方对 Redis Modules 的介绍 ：https://redis.io/modules
 
-另外，官网推荐了一个 RedisBloom  作为 Redis 布隆过滤器的 Module,地址：https://github.com/RedisBloom/RedisBloom. 其他还有：
+另外，官网推荐了一个 RedisBloom  作为 Redis 布隆过滤器的 Module，地址：https://github.com/RedisBloom/RedisBloom。其他还有：
 
-- redis-lua-scaling-bloom-filter （lua 脚本实现）：https://github.com/erikdubbelboer/redis-lua-scaling-bloom-filter
+- redis-lua-scaling-bloom-filter（lua 脚本实现）：https://github.com/erikdubbelboer/redis-lua-scaling-bloom-filter
 - pyreBloom（Python中的快速Redis 布隆过滤器） ：https://github.com/seomoz/pyreBloom
 - ......
 
 RedisBloom 提供了多种语言的客户端支持，包括：Python、Java、JavaScript 和 PHP。
 
-#### 6.2使用Docker安装
+#### 6.2 使用Docker安装
 
-如果我们需要体验 Redis 中的布隆过滤器非常简单，通过 Docker  就可以了！我们直接在 Google 搜索**docker redis bloomfilter** 然后在排除广告的第一条搜素结果就找到了我们想要的答案（这是我平常解决问题的一种方式，分享一下），具体地址：https://hub.docker.com/r/redislabs/rebloom/ （介绍的很详细 ）。
+如果我们需要体验 Redis 中的布隆过滤器非常简单，通过 Docker  就可以了！我们直接在 Google 搜索 **docker redis bloomfilter** 然后在排除广告的第一条搜素结果就找到了我们想要的答案（这是我平常解决问题的一种方式，分享一下），具体地址：https://hub.docker.com/r/redislabs/rebloom/ （介绍的很详细 ）。
 
 **具体操作如下：**
 
@@ -257,7 +257,7 @@ root@21396d02c252:/data# redis-cli
 
 #### 6.3常用命令一览
 
->  注意：   key:布隆过滤器的名称，item : 添加的元素。
+>  注意：   key : 布隆过滤器的名称，item : 添加的元素。
 
 1. **`BF.ADD `**：将元素添加到布隆过滤器中，如果该过滤器尚不存在，则创建该过滤器。格式：`BF.ADD {key} {item}`。
 2. **`BF.MADD `** : 将一个或多个元素添加到“布隆过滤器”中，并创建一个尚不存在的过滤器。该命令的操作方式`BF.ADD`与之相同，只不过它允许多个输入并返回多个值。格式：`BF.MADD {key} {item} [item ...]` 。

docs/database/Redis/Redis持久化.md

@@ -7,7 +7,7 @@
 
 **很多时候我们需要持久化数据也就是将内存中的数据写入到硬盘里面，大部分原因是为了之后重用数据（比如重启机器、机器故障之后回复数据），或者是为了防止系统故障而将数据备份到一个远程位置。**
 
-Redis不同于Memcached的很重一点就是，**Redis支持持久化**，而且支持两种不同的持久化操作。Redis的一种持久化方式叫**快照（snapshotting，RDB）**,另一种方式是**只追加文件（append-only file,AOF）**.这两种方法各有千秋，下面我会详细这两种持久化方法是什么，怎么用，如何选择适合自己的持久化方法。
+Redis不同于Memcached的很重要一点就是，**Redis支持持久化**，而且支持两种不同的持久化操作。Redis的一种持久化方式叫**快照（snapshotting，RDB）**，另一种方式是**只追加文件（append-only file,AOF）**。这两种方法各有千秋，下面我会详细这两种持久化方法是什么，怎么用，如何选择适合自己的持久化方法。
 
 ## 快照（snapshotting）持久化
 
@@ -16,8 +16,8 @@ Redis可以通过创建快照来获得存储在内存里面的数据在某个时
 ![春夏秋冬又一春](https://user-gold-cdn.xitu.io/2018/6/13/163f97568281782a?w=600&h=329&f=jpeg&s=88616)
 
 **快照持久化是Redis默认采用的持久化方式**，在redis.conf配置文件中默认有此下配置：
-```
 
+```
 save 900 1              #在900秒(15分钟)之后，如果至少有1个key发生变化，Redis就会自动触发BGSAVE命令创建快照。
 
 save 300 10            #在300秒(5分钟)之后，如果至少有10个key发生变化，Redis就会自动触发BGSAVE命令创建快照。
@@ -39,8 +39,6 @@ save 60 10000        #在60秒(1分钟)之后，如果至少有10000个key发生
 
 如果系统真的发生崩溃，用户将丢失最近一次生成快照之后更改的所有数据。因此，快照持久化只适用于即使丢失一部分数据也不会造成一些大问题的应用程序。不能接受这个缺点的话，可以考虑AOF持久化。
 
-
-
 ## **AOF（append-only file）持久化**
 与快照持久化相比，AOF持久化 的实时性更好，因此已成为主流的持久化方案。默认情况下Redis没有开启AOF（append only file）方式的持久化，可以通过appendonly参数开启：
 
@@ -55,7 +53,6 @@ appendonly yes
 **在Redis的配置文件中存在三种同步方式，它们分别是：**
 
 ```
-
 appendfsync always     #每次有数据修改发生时都会写入AOF文件,这样会严重降低Redis的速度
 appendfsync everysec  #每秒钟同步一次，显示地将多个写命令同步到硬盘
 appendfsync no      #让操作系统决定何时进行同步
@@ -65,7 +62,6 @@ appendfsync no      #让操作系统决定何时进行同步
 
 为了兼顾数据和写入性能，用户可以考虑 **appendfsync everysec选项** ，让Redis每秒同步一次AOF文件，Redis性能几乎没受到任何影响。而且这样即使出现系统崩溃，用户最多只会丢失一秒之内产生的数据。当硬盘忙于执行写入操作的时候，Redis还会优雅的放慢自己的速度以便适应硬盘的最大写入速度。
 
-
 **appendfsync no**  选项一般不推荐，这种方案会使Redis丢失不定量的数据而且如果用户的硬盘处理写入操作的速度不够的话，那么当缓冲区被等待写入的数据填满时，Redis的写入操作将被阻塞，这会导致Redis的请求速度变慢。
 
 **虽然AOF持久化非常灵活地提供了多种不同的选项来满足不同应用程序对数据安全的不同要求，但AOF持久化也有缺陷——AOF文件的体积太大。**
@@ -100,7 +96,7 @@ auto-aof-rewrite-min-size 64mb
 
 无论是AOF持久化还是快照持久化，将数据持久化到硬盘上都是非常有必要的，但除了进行持久化外，用户还必须对持久化得到的文件进行备份（最好是备份到不同的地方），这样才能尽量避免数据丢失事故发生。如果条件允许的话，最好能将快照文件和重新重写的AOF文件备份到不同的服务器上面。
 
-随着负载量的上升，或者数据的完整性变得 越来越重要时，用户可能需要使用到复制特性。
+随着负载量的上升，或者数据的完整性变得越来越重要时，用户可能需要使用到复制特性。
 
 ## Redis 4.0 对于持久化机制的优化
 Redis 4.0 开始支持 RDB 和 AOF 的混合持久化（默认关闭，可以通过配置项 `aof-use-rdb-preamble` 开启）。
@@ -113,4 +109,3 @@ Redis 4.0 开始支持 RDB 和 AOF 的混合持久化（默认关闭，可以通
 
 [深入学习Redis（2）：持久化](https://www.cnblogs.com/kismetv/p/9137897.html)
 
-