diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/01.\345\205\213\351\232\206/01.\346\224\257\346\214\201\346\263\233\345\236\213\347\232\204\345\205\213\351\232\206\346\216\245\345\217\243\345\222\214\345\205\213\351\232\206\347\261\273.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/01.\345\205\213\351\232\206/01.\346\224\257\346\214\201\346\263\233\345\236\213\347\232\204\345\205\213\351\232\206\346\216\245\345\217\243\345\222\214\345\205\213\351\232\206\347\261\273.md"
index e93cefea5e946531c9c83afcfb4d769f99265e41..a310175784afbe84b5048ebec8b7c9bad9932586 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/01.\345\205\213\351\232\206/01.\346\224\257\346\214\201\346\263\233\345\236\213\347\232\204\345\205\213\351\232\206\346\216\245\345\217\243\345\222\214\345\205\213\351\232\206\347\261\273.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/01.\345\205\213\351\232\206/01.\346\224\257\346\214\201\346\263\233\345\236\213\347\232\204\345\205\213\351\232\206\346\216\245\345\217\243\345\222\214\345\205\213\351\232\206\347\261\273.md"
@@ -59,5 +59,5 @@ ObjectUtil.cloneByStream(obj)
 ```
 前提是对象必须实现Serializable接口。
 
-**ObjectUtil**同样提供一些静态方法：**clone(obj)**、**cloneIfPossible(obj)**用于简化克隆调用，详细的说明请查看核心类的相关文档。
+**ObjectUtil**同样提供一些静态方法：**clone(obj)**、**cloneIfPossible(obj)** 用于简化克隆调用，详细的说明请查看核心类的相关文档。
 
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/02.\347\261\273\345\236\213\350\275\254\346\215\242/01.\347\261\273\345\236\213\350\275\254\346\215\242\345\267\245\345\205\267\347\261\273-Convert.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/02.\347\261\273\345\236\213\350\275\254\346\215\242/01.\347\261\273\345\236\213\350\275\254\346\215\242\345\267\245\345\205\267\347\261\273-Convert.md"
index dbaf0c8123e21e09602ed3df43081ad1ad78dc93..557d6b2b995f7eb3e83ca8696354ddd3190eb865 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/02.\347\261\273\345\236\213\350\275\254\346\215\242/01.\347\261\273\345\236\213\350\275\254\346\215\242\345\267\245\345\205\267\347\261\273-Convert.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/02.\347\261\273\345\236\213\350\275\254\346\215\242/01.\347\261\273\345\236\213\350\275\254\346\215\242\345\267\245\345\205\267\347\261\273-Convert.md"
@@ -141,7 +141,7 @@ Assert.assertEquals(raw, a);
 ```
 
 > 注意
-> 经过测试，UTF-8编码后用GBK解码再用GBK编码后用UTF-8解码会存在某些中文转换失败的问题。
+> 经过测试，UTF-8编码后用GBK解码，再用GBK编码后用UTF-8解码会存在某些中文转换失败的问题。
 
 ### 时间单位转换
 `Convert.convertTime`方法主要用于转换时长单位，比如一个很大的毫秒，我想获得这个毫秒数对应多少分：
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/00.\346\246\202\350\277\260.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/00.\346\246\202\350\277\260.md"
index 615983deee8c1e3733414715141ef37e2914234c..afbbe8db7cf23a463ed8ae57cbbcf5c16c9367f2 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/00.\346\246\202\350\277\260.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/00.\346\246\202\350\277\260.md"
@@ -4,7 +4,7 @@ date: 2023-03-28 18:39:47
 permalink: /pages/io/
 ---
 ## 由来
-IO的操作包括**读**和**写**，应用场景包括网络操作和文件操作。IO操作在Java中是一个较为复杂的过程，我们在面对不同的场景时，要选择不同的`InputStream`和`OutputStream`实现来完成这些操作。而如果想读写字符流，还需要`Reader`和`Writer`的各种实现类。这些繁杂的实现类，一方面给我我们提供了更多的灵活性，另一方面也增加了复杂性。
+IO的操作包括**读**和**写**，应用场景包括网络操作和文件操作。IO操作在Java中是一个较为复杂的过程，我们在面对不同的场景时，要选择不同的`InputStream`和`OutputStream`实现来完成这些操作。而如果想读写字符流，还需要`Reader`和`Writer`的各种实现类。这些繁杂的实现类，一方面给我们提供了更多的灵活性，另一方面也增加了复杂性。
 
 ## 封装
 io包的封装主要针对流、文件的读写封装，主要以工具类为主，提供常用功能的封装，这包括：
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/01.IO\345\267\245\345\205\267\347\261\273-IoUtil.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/01.IO\345\267\245\345\205\267\347\261\273-IoUtil.md"
index b0aa06680b6b8672632f77e311fd788671e3b5be..069e06c908946efcfba38c36715ff208aebd5cc3 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/01.IO\345\267\245\345\205\267\347\261\273-IoUtil.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/01.IO\345\267\245\345\205\267\347\261\273-IoUtil.md"
@@ -9,7 +9,7 @@ IO工具类的存在主要针对InputStream、OutputStream、Reader、Writer封
 ## 方法
 
 ### 拷贝
-流的读写可以总结为从输入流读取，从输出流写出，这个过程我们定义为**拷贝**。这个是一个基本过程，也是文件、流操作的基础。
+流的读写可以总结为从输入流读取，从输出流写出，这个过程我们定义为**拷贝**。这是一个基本过程，也是文件、流操作的基础。
 
 以文件流拷贝为例：
 ```java
@@ -26,7 +26,7 @@ copy方法同样针对Reader、Writer、Channel等对象有一些重载方法，
 - `IoUtil.getReader`：将`InputStream`转为`BufferedReader`用于读取字符流，它是部分readXXX方法的基础。
 - `IoUtil.getWriter`：将`OutputStream`转为`OutputStreamWriter`用于写入字符流，它是部分writeXXX的基础。
 
-本质上这两个方法只是简单new一个新的Reader或者Writer对象，但是封装为工具方法配合IDE的自动提示可以大大减少查阅次数（例如你对BufferedReader、OutputStreamWriter不熟悉，是不需要搜索一下相关类？）
+本质上这两个方法只是简单new一个新的Reader或者Writer对象，但是封装为工具方法配合IDE的自动提示可以大大减少查阅次数（例如你对BufferedReader、OutputStreamWriter不熟悉，是不是需要搜索一下相关类？）
 
 ### 读取流中的内容
 读取流中的内容总结下来，可以分为read方法和readXXX方法。
@@ -63,5 +63,5 @@ copy方法同样针对Reader、Writer、Channel等对象有一些重载方法，
 
 `IoUtil.close`方法很好的解决了这两个问题。
 
-在JDK1.7中，提供了`AutoCloseable`接口，在`IoUtil`中同样提供相应的重载方法，在使用中并不能感觉到有哪些不同。
+在JDK1.7中，提供了`AutoCloseable`接口，在`IoUtil`中同样提供相应的重载方法，在使用中并不会感觉到有哪些不同。
 
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/02.\346\226\207\344\273\266\345\267\245\345\205\267\347\261\273-FileUtil.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/02.\346\226\207\344\273\266\345\267\245\345\205\267\347\261\273-FileUtil.md"
index 237643677365bcdf5b261fd28043705b180475aa..2b4ba0396add4111d1253b8dfa9449da45c5a4ee 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/02.\346\226\207\344\273\266\345\267\245\345\205\267\347\261\273-FileUtil.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/02.\346\226\207\344\273\266\345\267\245\345\205\267\347\261\273-FileUtil.md"
@@ -4,7 +4,7 @@ date: 2023-03-28 18:39:47
 permalink: /pages/FileUtil/
 ---
 ## 简介
-在IO操作中，文件的操作相对来说是比较复杂的，但也是使用频率最高的部分，我们几乎所有的项目中几乎都躺着一个叫做FileUtil或者FileUtils的工具类，我想Hutool应该将这个工具类纳入其中，解决用来解决大部分的文件操作问题。
+在IO操作中，文件的操作相对来说是比较复杂的，但也是使用频率最高的部分，我们几乎所有的项目中都躺着一个叫做FileUtil或者FileUtils的工具类，我想Hutool应该将这个工具类纳入其中，用来解决大部分的文件操作问题。
 
 总体来说，FileUtil类包含以下几类操作工具：
 1. 文件操作：包括文件目录的新建、删除、复制、移动、改名等
@@ -14,7 +14,7 @@ permalink: /pages/FileUtil/
 5. 读操作：包括类似IoUtil中的getReader、readXXX操作
 6. 写操作：包括getWriter和writeXXX操作 
 
-在FileUtil中，我努力将方法名与Linux相一致，例如创建文件的方法并不是createFile，而是`touch`，这种统一对于熟悉Linux的人来说，大大提高了上手速度。当然，如果你不熟悉Linux，那FileUtil工具类的使用则是在帮助你学习Linux命令。这些类Linux命令的方法包括：
+在FileUtil中，我努力让方法名与Linux相一致，例如创建文件的方法并不是createFile，而是`touch`，这种统一对于熟悉Linux的人来说，大大提高了上手速度。当然，如果你不熟悉Linux，那FileUtil工具类的使用则是在帮助你学习Linux命令。这些类Linux命令的方法包括：
 
 - `ls` 列出目录和文件
 - `touch` 创建文件，如果父目录不存在也自动创建
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/03.\346\226\207\344\273\266\347\233\221\345\220\254-WatchMonitor.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/03.\346\226\207\344\273\266\347\233\221\345\220\254-WatchMonitor.md"
index e0123c3d76a6aa756b47684db196e021877eef6c..3a0dd13c64449e7bf7e26c1db7e118c16d373bd7 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/03.\346\226\207\344\273\266\347\233\221\345\220\254-WatchMonitor.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/03.\346\226\207\344\273\266\347\233\221\345\220\254-WatchMonitor.md"
@@ -23,9 +23,9 @@ permalink: /pages/WatchMonitor/
 
 `WatchMonitor`提供的事件有：
 
-- `ENTRY_MODIFY` 文件修改的事件
-- `ENTRY_CREATE` 文件或目录创建的事件
-- `ENTRY_DELETE` 文件或目录删除的事件
+- `ENTRY_MODIFY` 文件或目录的修改事件
+- `ENTRY_CREATE` 文件或目录的创建事件
+- `ENTRY_DELETE` 文件或目录的删除事件
 - `OVERFLOW` 丢失的事件
 
 这些事件对应`StandardWatchEventKinds`中的事件。
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/04.\346\226\207\344\273\266\347\261\273\345\236\213\345\210\244\346\226\255-FileTypeUtil.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/04.\346\226\207\344\273\266\347\261\273\345\236\213\345\210\244\346\226\255-FileTypeUtil.md"
index 3f4d329b4db5f5ea3896c52673c89e84e94bdf5c..9af6ea1f9303b161b983dbd0cb6f20549a7a9c32 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/04.\346\226\207\344\273\266\347\261\273\345\236\213\345\210\244\346\226\255-FileTypeUtil.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/04.\346\226\207\344\273\266\347\261\273\345\236\213\345\210\244\346\226\255-FileTypeUtil.md"
@@ -4,7 +4,7 @@ date: 2023-03-28 18:39:47
 permalink: /pages/FileTypeUtil/
 ---
 ## 由来
-在文件上传时，有时候我们需要判断文件类型。但是又不能简单的通过扩展名来判断（防止恶意脚本等通过上传到服务器上），于是我们需要在服务端通过读取文件的首部几个二进制位来判断常用的文件类型。
+在文件上传时，有时候我们需要判断文件类型。但是又不能简单的通过扩展名来判断（防止恶意脚本等上传到服务器上），于是我们需要在服务端通过读取文件的首部几个字节值来判断常用的文件类型。
 
 ## 使用
 这个工具类使用非常简单，通过调用`FileTypeUtil.getType`即可判断，这个方法同时提供众多的重载方法，用于读取不同的文件和流。
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/05.\346\226\207\344\273\266/01.\346\226\207\344\273\266\350\257\273\345\217\226-FileReader.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/05.\346\226\207\344\273\266/01.\346\226\207\344\273\266\350\257\273\345\217\226-FileReader.md"
index 9bfd064e7a2673e697d76136e4f62eda31dadc95..48c74322544e213f0d7a384aa5327ab28da07b5a 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/05.\346\226\207\344\273\266/01.\346\226\207\344\273\266\350\257\273\345\217\226-FileReader.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/05.\346\226\207\344\273\266/01.\346\226\207\344\273\266\350\257\273\345\217\226-FileReader.md"
@@ -7,7 +7,7 @@ permalink: /pages/FileReader/
 在`FileUtil`中本来已经针对文件的读操作做了大量的静态封装，但是根据职责分离原则，我觉得有必要针对文件读取单独封装一个类，这样项目更加清晰。当然，使用FileUtil操作文件是最方便的。
 
 ## 使用
-在JDK中，同样有一个FileReader类，但是并不如想象中的那样好用，于是Hutool便提供了更加便捷FileReader类。
+在JDK中，同样有一个FileReader类，但是并不如想象中的那样好用，于是Hutool便提供了更加便捷的FileReader类。
 
 ```java
 //默认UTF-8编码，可以在构造中传入第二个参数做为编码
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/05.\346\226\207\344\273\266/02.\346\226\207\344\273\266\345\206\231\345\205\245-FileWriter.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/05.\346\226\207\344\273\266/02.\346\226\207\344\273\266\345\206\231\345\205\245-FileWriter.md"
index eca83878e4bd5060b13c818b83d5dfe838ea2e3d..a4084eb53807dcb6881f3767ab99f9466e0ee58a 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/05.\346\226\207\344\273\266/02.\346\226\207\344\273\266\345\206\231\345\205\245-FileWriter.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/05.\346\226\207\344\273\266/02.\346\226\207\344\273\266\345\206\231\345\205\245-FileWriter.md"
@@ -17,5 +17,5 @@ writer.write("test");
 - `getWriter`
 - `getPrintWriter`
 
-这些方法用于转换为相应的类提供更加灵活的写入操作。
+这些方法用于转换为相应的类，提供更加灵活的写入操作。
 
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/05.\346\226\207\344\273\266/03.\346\226\207\344\273\266\350\277\275\345\212\240-FileAppender.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/05.\346\226\207\344\273\266/03.\346\226\207\344\273\266\350\277\275\345\212\240-FileAppender.md"
index 8c3b573745edfbf3fb1cbdf3d08f602ff8fafe9a..7429461bfe51182c09f67bb9cf7de8176a0be33b 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/05.\346\226\207\344\273\266/03.\346\226\207\344\273\266\350\277\275\345\212\240-FileAppender.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/05.\346\226\207\344\273\266/03.\346\226\207\344\273\266\350\277\275\345\212\240-FileAppender.md"
@@ -5,11 +5,11 @@ permalink: /pages/FileAppender/
 ---
 ## 由来
 
-顾名思义，`FileAppender`类表示文件追加器。此对象持有一个一个文件，在内存中积累一定量的数据后统一追加到文件，此类只有在写入文件时打开文件，并在写入结束后关闭之。因此此类不需要关闭。
+顾名思义，`FileAppender`类表示文件追加器。此对象持有一个文件，在内存中积累一定量的数据后统一追加到文件，此类只有在写入文件时打开文件，并在写入结束后关闭之。因此此类不需要关闭。
 
 在调用append方法后会缓存于内存，只有超过容量后才会一次性写入文件，因此内存中随时有剩余未写入文件的内容，在最后必须调用flush方法将剩余内容刷入文件。
 
-也就是说，这是一个支持缓存的文件内容追加器。此类主要用于类似于日志写出这类需求所用。
+也就是说，这是一个支持缓存的文件内容追加器。此类主要用于类似于日志写出这类需求。
 
 ## 使用
 
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/06.\350\265\204\346\272\220/00.\346\246\202\350\277\260.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/06.\350\265\204\346\272\220/00.\346\246\202\350\277\260.md"
index e6457654e3fc9e041fa3d51b9cfdb53fded5251e..7ca308bd34f5c0abc2b53daa5f1efacd33a8ac6f 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/06.\350\265\204\346\272\220/00.\346\246\202\350\277\260.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/04.IO\346\265\201\347\233\270\345\205\263/06.\350\265\204\346\272\220/00.\346\246\202\350\277\260.md"
@@ -41,7 +41,7 @@ public interface Resource {
 }
 ```
 
-> 关于Resource的详细定义见：[Resource.java](https://gitee.com/loolly/hutool/blob/v5-master/hutool-core/src/main/java/cn/hutool/core/io/resource/Resource.java)
+> 关于Resource的详细定义见：[Resource.java](https://gitee.com/dromara/hutool/blob/v5-master/hutool-core/src/main/java/cn/hutool/core/io/resource/Resource.java)
 
 定义了Resource，我们就可以预定义一些特别的资源：
 
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/03.\345\215\225\344\276\213\345\267\245\345\205\267-Singleton.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/03.\345\215\225\344\276\213\345\267\245\345\205\267-Singleton.md"
index f0740c80dc5b975f1ce5a653b9009c22bd21ce4e..e7f1c86a5b2e900aeae58dd02a08346aa54eedc1 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/03.\345\215\225\344\276\213\345\267\245\345\205\267-Singleton.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/03.\345\215\225\344\276\213\345\267\245\345\205\267-Singleton.md"
@@ -71,4 +71,4 @@ public class SingletonDemo {
 
 ## 总结
 
-大家如果有兴趣可以看下这个类，实现非常简单，一个HashMap用于做为单例对象池，通过newInstance()实例化对象（不支持带参数的构造方法），无论取还是创建对象都是线程安全的（在单例对象数量非常庞大且单例对象实例化非常耗时时可能会出现瓶颈），考虑到在get的时候使双重检查锁，但是并不是线程安全的，故直接加了`synchronized`做为修饰符，欢迎在此给出建议。
+大家如果有兴趣可以看下这个类，实现非常简单，用一个安全的`ConcurrentHashMap`作为单例对象池，通过newInstance()实例化对象（支持带参数的构造方法），无论取还是创建对象都是线程安全的。
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/04.\346\226\255\350\250\200-Assert.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/04.\346\226\255\350\250\200-Assert.md"
index 75311d0546ea0861ce91ef1bd2b17d1190e47c6f..f74a43f2561f3699618378feaa3ccd767b2774ec 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/04.\346\226\255\350\250\200-Assert.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/04.\346\226\255\350\250\200-Assert.md"
@@ -5,7 +5,7 @@ permalink: /pages/Assert/
 ---
 ## 由来
 Java中有`assert`关键字，但是存在许多问题：
-1. assert关键字需要在运行时候显式开启才能生效，否则你的断言就没有任何意义。
+1. assert关键字需要在运行时显式开启才能生效，否则你的断言就没有任何意义。
 2. 用assert代替if是陷阱之二。assert的判断和if语句差不多，但两者的作用有着本质的区别：assert关键字本意上是为测试调试程序时使用的，但如果不小心用assert来控制了程序的业务流程，那在测试调试结束后去掉assert关键字就意味着修改了程序的正常的逻辑。
 3. assert断言失败将面临程序的退出。
 
@@ -22,14 +22,13 @@ cn.hutool.lang.Assert.isNull(a);
 ```
 
 ## 更多方法
-- isTrue 是否True
-- isNull 是否是null值，不为null抛出异常
-- notNull 是否非null值
-- notEmpty 是否非空
-- notBlank 是否非空白符
-- notContain 是否为子串
-- notEmpty 是否非空
-- noNullElements 数组中是否包含null元素
-- isInstanceOf 是否类实例
-- isAssignable 是子类和父类关系
+- isTrue 必须为true，否则抛出IllegalArgumentException异常
+- isNull 必须是null值
+- notNull 不能是null值
+- notEmpty 不能为空，支持字符串，数组，集合等
+- notBlank 不能是空白字符串
+- notContain 不能包含指定的子串
+- noNullElements 数组中不能包含null元素
+- isInstanceOf 必须是指定类的实例
+- isAssignable 必须是子类和父类关系
 - state 会抛出IllegalStateException异常
\ No newline at end of file
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/05.\344\272\214\350\277\233\347\240\201\345\215\201\350\277\233\346\225\260-BCD.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/05.\344\272\214\350\277\233\347\240\201\345\215\201\350\277\233\346\225\260-BCD.md"
index 83a76ec2f61caeefad80fa5a8451962f4204516e..b93ce827706d24236fa1540998c5dcab1963f14d 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/05.\344\272\214\350\277\233\347\240\201\345\215\201\350\277\233\346\225\260-BCD.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/05.\344\272\214\350\277\233\347\240\201\345\215\201\350\277\233\346\225\260-BCD.md"
@@ -7,9 +7,9 @@ permalink: /pages/BCD/
 
 BCD码（Binary-Coded Decimal）亦称二进码十进数或二-十进制代码，BCD码这种编码形式利用了四个位元来储存一个十进制的数码，使二进制和十进制之间的转换得以快捷的进行。
 
-这种编码技巧最常用于会计系统的设计里，因为会计制度经常需要对很长的数字串作准确的计算。相对于一般的浮点式记数法，采用BCD码，既可保存数值的精确度，又可免却使电脑作浮点运算时所耗费的时间。此外，对于其他需要高精确度的计算，BCD编码亦很常用。
+这种编码技巧最常用于会计系统的设计里，因为会计制度经常需要对很长的数字串作准确的计算。相对于一般的浮点式记数法，采用BCD码，既可保存数值的精确度，又可免却电脑作浮点运算时所耗费的时间。此外，对于其他需要高精确度的计算，BCD编码亦很常用。
 
-BCD码是四位二进制码, 也就是将十进制的数字转化为二进制, 但是和普通的转化有一点不同, 每一个十进制的数字0-9都对应着一个四位的二进制码,对应关系如下: 十进制0 对应 二进制0000 ;十进制1 对应二进制0001 ....... 9 1001 接下来的10就有两个上述的码来表示 10 表示为00010000 也就是BCD码是遇见1001就产生进位,不象普通的二进制码,到1111才产生进位10000
+BCD码是四位二进制码, 也就是将十进制的数字转化为二进制, 但是和普通的转化有一点不同, 每一个十进制的数字0-9都对应着一个四位的二进制码,对应关系如下: 十进制`0` 对应 二进制`0000`;十进制`1` 对应二进制`0001`.......`9`=>`1001` 接下来的`10`就由两个上述的码来表示，表示为`0001 0000`。也就是BCD码是遇见`1001`就产生进位,不象普通的二进制码,到`1111`才产生进位`10000`
 
 ## 方法
 
@@ -21,4 +21,7 @@ byte[] bcd = BCD.strToBcd(strForTest);
 //解码BCD
 String str = BCD.bcdToStr(bcd);
 Assert.assertEquals(strForTest, str);
-```
\ No newline at end of file
+```
+## 注意
+
+由于对ASCII的编码解码有缺陷，且这种BCD实现并不规范，因此会在6.0.0中移除
\ No newline at end of file
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/06.\346\216\247\345\210\266\345\217\260\346\211\223\345\215\260\345\260\201\350\243\205-Console.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/06.\346\216\247\345\210\266\345\217\260\346\211\223\345\215\260\345\260\201\350\243\205-Console.md"
index 5d5b06371235d8b2f5c0cf017ca1941ecfe6675c..2c090a6678843b3da0f248e3790236057d4d3ed1 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/06.\346\216\247\345\210\266\345\217\260\346\211\223\345\215\260\345\260\201\350\243\205-Console.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/06.\346\216\247\345\210\266\345\217\260\346\211\223\345\215\260\345\260\201\350\243\205-Console.md"
@@ -35,4 +35,4 @@ Console.log("This is Console log for {}.", "test");
 //控制台输出：This is Console log for test.
 ```
 
-2. `Console.error` 这个方法基本等同于`System.err.println`，,但是支持类似于Slf4j的字符串模板语法，同时也会自动将对象（包括数组）转为字符串形式。
\ No newline at end of file
+2. `Console.error` 这个方法基本等同于`System.err.println`，但是支持类似于Slf4j的字符串模板语法，同时也会自动将对象（包括数组）转为字符串形式。
\ No newline at end of file
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/07.\345\255\227\346\256\265\351\252\214\350\257\201\345\231\250-Validator.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/07.\345\255\227\346\256\265\351\252\214\350\257\201\345\231\250-Validator.md"
index c973845077fcb0c5e0ed04ea42c6380b66517fed..6735b0cc7f1b345182d6a8d877c53cb75c33d8e5 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/07.\345\255\227\346\256\265\351\252\214\350\257\201\345\231\250-Validator.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/07.\345\255\227\346\256\265\351\252\214\350\257\201\345\231\250-Validator.md"
@@ -29,7 +29,7 @@ boolean isEmail = Validator.isEmail("loolly@gmail.com")
 Validator.isMatchRegex("需要验证字段的正则表达式", "被验证内容")
 ```
 
-来通过正则表达式灵活的验证内容。
+通过正则表达式来灵活的验证内容。
 
 ### 异常验证
 除了手动判断，我们有时需要在判断未满足条件时抛出一个异常，Validator同样提供异常验证机制：
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/09.\346\240\221\347\273\223\346\236\204/10.\346\240\221\347\273\223\346\236\204\345\267\245\345\205\267-TreeUtil.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/09.\346\240\221\347\273\223\346\236\204/10.\346\240\221\347\273\223\346\236\204\345\267\245\345\205\267-TreeUtil.md"
index 7f316f5e839325031588ec6dbc196f1d7d0a5127..07157ebff80302ca00ec0c5c65e21e16ebd718c8 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/09.\346\240\221\347\273\223\346\236\204/10.\346\240\221\347\273\223\346\236\204\345\267\245\345\205\267-TreeUtil.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/06.\350\257\255\350\250\200\347\211\271\346\200\247/09.\346\240\221\347\273\223\346\236\204/10.\346\240\221\347\273\223\346\236\204\345\267\245\345\205\267-TreeUtil.md"
@@ -73,7 +73,7 @@ List<Tree<String>> treeList = TreeUtil.build(nodeList, "0");
 ```java
 //配置
 TreeNodeConfig treeNodeConfig = new TreeNodeConfig();
-// 自定义属性名 都要默认值的
+// 自定义属性名 都有默认值的
 treeNodeConfig.setWeightKey("order");
 treeNodeConfig.setIdKey("rid");
 // 最大递归深度
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/01.\346\246\202\350\277\260.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/01.\346\246\202\350\277\260.md"
index c23e84734b3d7f526b8016903e1bff29f9624965..fa9f89249083078a566868fe47155ffea63c8fe0 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/01.\346\246\202\350\277\260.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/01.\346\246\202\350\277\260.md"
@@ -7,7 +7,7 @@ permalink: /pages/javaBean/
 
 针对JavaBean已经有BeanUtil的工具封装，我认为这还不够。最近看了Apache Commons BeanUtils的DynaBean源码和Nuts中Mirror类的文档（请看这里 -> [增强反射](http://nutzam.com/core/lang/mirror.html)），启发颇多，于是我决定在Hutool中加入DynaBean。
 
-Dyna既Dynamic，顾名思义，通过Java反射机制操作JavaBean，以达到动态语言的某些特性。
+Dyna即Dynamic，顾名思义，通过Java反射机制操作JavaBean，以达到动态语言的某些特性。
 
 bean包的另一个改进是针对PropertyDescriptor提供缓存。BeanInfoCache类缓存了通过内省获取到的PropertyDescriptor，以提高反射性能。
 
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/02.Bean\345\267\245\345\205\267-BeanUtil.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/02.Bean\345\267\245\345\205\267-BeanUtil.md"
index 39f1ad6b03706435448d7894535544320566426c..a054e0720ed7645eb274310f804a98e745c25889 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/02.Bean\345\267\245\345\205\267-BeanUtil.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/02.Bean\345\267\245\345\205\267-BeanUtil.md"
@@ -4,7 +4,7 @@ date: 2023-03-28 18:39:47
 permalink: /pages/BeanUtil/
 ---
 ## 什么是Bean
-把一个拥有对属性进行set和get方法的类，我们就可以称之为JavaBean。实际上JavaBean就是一个Java类，在这个Java类中就默认形成了一种规则——对属性进行设置和获得。而反之将说Java类就是一个JavaBean，这种说法是错误的，因为一个java类中不一定有对属性的设置和获得的方法（也就是不一定有set和get方法）。
+一个拥有对属性进行set和get方法的类，我们就可以称之为JavaBean。实际上JavaBean就是一个Java类，在这个Java类中默认形成了一种规则——对属性进行设置和获得。而反之，说Java类就一定是JavaBean，这种说法是错误的，因为一个java类中不一定有对属性的设置和获得的方法（也就是不一定有set和get方法）。
 
 通常Java中对Bean的定义是包含setXXX和getXXX方法的对象，在Hutool中，采取一种简单的判定Bean的方法：是否存在只有一个参数的setXXX方法。
 
@@ -20,7 +20,7 @@ boolean isBean = BeanUtil.isBean(HashMap.class);//false
 ```
 
 ### 内省 Introspector
-把一类中需要进行设置和获得的属性访问权限设置为private（私有的）让外部的使用者看不见摸不着，而通过public（共有的）set和get方法来对其属性的值来进行设置和获得，而内部的操作具体是怎样的？外界使用的人不用知道，这就称为内省。
+把一个类中需要进行设置和获得的属性的访问权限设置为private（私有的），让外部的使用者看不见摸不着，只能通过public（共有的）set和get方法对其属性的值进行设置和获得，而内部的操作具体是怎样的？外界使用的人不用知道，这就称为内省。
 
 Hutool中对内省的封装包括：
 
@@ -31,16 +31,16 @@ PropertyDescriptor[] propertyDescriptors = BeanUtil.getPropertyDescriptors(SubPe
 ```
 
 2. `BeanUtil.getFieldNamePropertyDescriptorMap` 获得字段名和字段描述Map
-3. `BeanUtil.getPropertyDescriptor` 获得Bean类指定属性描述
+3. `BeanUtil.getPropertyDescriptor` 获得指定字段的描述
 
 ### Bean属性注入
 `BeanUtil.fillBean`方法是bean注入的核心方法，此方法传入一个ValueProvider接口，通过实现此接口来获得key对应的值。CopyOptions参数则提供一些注入属性的选项。
 
 CopyOptions的配置项包括：
-1. `editable` 限制的类或接口，必须为目标对象的实现接口或父类，用于限制拷贝的属性，例如一个类我只想复制其父类的一些属性，就可以将editable设置为父类。
+1. `editable` 限制拷贝的属性必须为指定类中的属性，例如我只想从源对象中拷贝目标对象父类中的属性，就可以将editable设置为目标对象父类的Class。
 2. `ignoreNullValue` 是否忽略空值，当源对象的值为null时，true: 忽略而不注入此值，false: 注入null
 3. `ignoreProperties` 忽略的属性列表，设置一个属性列表，不拷贝这些属性值
-4. `ignoreError` 是否忽略字段注入错误
+4. `ignoreError` 是否忽略字段注入中发生的错误
 
 可以通过`CopyOptions.create()`方法创建一个默认的配置项，通过setXXX方法设置每个配置项。
 
@@ -96,7 +96,6 @@ Assert.assertEquals(person.getName(), "张三");
 Assert.assertEquals(person.getAge(), 18);
 ```
 
-同时，Hutool还提供了`BeanUtil.toBean`方法，此处并不是传Bean对象，而是Bean类，Hutool会自动调用默认构造方法创建对象。
 
 基于`BeanUtil.fillBean`方法Hutool还提供了Map对象键值对注入Bean，其方法有：
 
@@ -121,7 +120,7 @@ map.put("openId", "DFDFSDFWERWER");
 SubPerson person = BeanUtil.fillBeanWithMapIgnoreCase(map, new SubPerson(), false);
 ```
 
-同时提供了map转bean的方法，与fillBean不同的是，此处并不是传Bean对象，而是Bean类，Hutool会自动调用默认构造方法创建对象。当然，前提是Bean类有默认构造方法（空构造），这些方法有：
+同时，Hutool还提供了`BeanUtil.toBean`方法，用于map转bean，与fillBean不同的是，此处并不是传Bean对象，而是Bean类，Hutool会自动调用默认构造方法创建对象。当然，前提是Bean类有默认构造方法（空构造），这些方法有：
 
 1. `BeanUtil.toBean`
 
@@ -175,7 +174,7 @@ Map<String, Object> map = MapUtil.newHashMap();
 BeanUtil.copyProperties(p1, map);
 ```
 
-5.6.6+加入 复制集合中的Bean属性 List的转化可使用 `copyToList`
+5.6.6+加入 `copyToList`方法，遍历集合中每个Bean，复制其属性到另一个类型的对象中，最后返回一个新的List。
 
 ```java
 
@@ -223,7 +222,7 @@ Map<String, Object> map = BeanUtil.beanToMap(person);
 map.get("aliasSubName")
 ```
 
-同样Alias注解支持注入Bean时的别名：
+同样Alias注解支持注入Bean时使用别名：
 
 ```java
 Map<String, Object> map = MapUtil.newHashMap();
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/03.DynaBean.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/03.DynaBean.md"
index 417c090c573255ccc4a7a3b5e7047eec7add7465..47d38d13509d6383d645a0dcb9f4f5b68cbf6a55 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/03.DynaBean.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/03.DynaBean.md"
@@ -5,7 +5,7 @@ permalink: /pages/DynaBean/
 ---
 ## 介绍
 
-DynaBean是使用反射机制动态操作JavaBean的一个封装类，通过这个类，可以通过字符串传入name方式动态调用get和set方法，也可以动态创建JavaBean对象，亦或者执行JavaBean中的方法。
+DynaBean是使用反射机制动态操作JavaBean的一个封装类，通过这个类，可以通过传入字段名称的方式动态调用get和set方法，也可以动态创建JavaBean对象，亦或者执行JavaBean中的方法。
 
 ## 使用
 
@@ -58,5 +58,5 @@ Assert.assertEquals("test for 李华", invoke);
 ```
 
 >说明:
-> DynaBean默认实现了hashCode、equals和toString三个方法，这三个方法也是默认调用原对象的相应方法操作。
+> DynaBean默认实现了hashCode、equals和toString三个方法，这三个方法也是默认调用原对象的相应方法。
 
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/04.\350\241\250\350\276\276\345\274\217\350\247\243\346\236\220-BeanPath.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/04.\350\241\250\350\276\276\345\274\217\350\247\243\346\236\220-BeanPath.md"
index 482e8e5efde0a95d2e29164edb9d6c1b7cb98511..898077c0d73e85c8a69c156437a0c275878e1a52 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/04.\350\241\250\350\276\276\345\274\217\350\247\243\346\236\220-BeanPath.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/04.\350\241\250\350\276\276\345\274\217\350\247\243\346\236\220-BeanPath.md"
@@ -5,11 +5,11 @@ permalink: /pages/BeanPath/
 ---
 ## 由来
 
-很多JavaBean嵌套有很多层对象，这其中还夹杂着Map、Collection等对象，因此获取太深的嵌套对象会让代码变得冗长不堪。因此我们可以考虑使用一种表达式还获取指定深度的对象，于是BeanResolver应运而生。
+很多JavaBean嵌套着很多层对象，这其中还夹杂着Map、Collection等对象，因此获取太深的嵌套对象会让代码变得冗长不堪。因此我们可以考虑使用一种表达式来获取指定深度的对象，于是BeanResolver应运而生。
 
 ## 原理
 
-通过传入一个表达式，按照表达式的规则获取bean下指定的对象。
+通过传入一个表达式，按照表达式的规则获取bean中指定的字段值。
 
 表达式分为两种：
 - `.`表达式，可以获取Bean对象中的属性（字段）值或者Map中key对应的值
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/05.Bean\346\217\217\350\277\260-BeanDesc.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/05.Bean\346\217\217\350\277\260-BeanDesc.md"
index 2922993af206f6c3468a21a418ab68de17f7257e..c897433e806d4c07e85a41a7c516cc2442820bcb 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/05.Bean\346\217\217\350\277\260-BeanDesc.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/05.Bean\346\217\217\350\277\260-BeanDesc.md"
@@ -7,14 +7,14 @@ permalink: /pages/BeanDesc/
 
 Hutool封装了Bean的信息描述来将一个Bean的相关信息全部通过反射解析出来，此类类似于JDK的`BeanInfo`，也可以理解为是这个类的强化版本。
 
-BeanDesc包含所有字段（属性）及对应的Getter方法和Setter方法，与`BeanInfo`不同的是，`BeanDesc`要求属性和getter、setter必须严格对应，即如果有非public属性，没有getter，则不能获取属性值，没有setter也不能注入属性值。
+BeanDesc包含所有字段（属性）及对应的Getter方法和Setter方法，与`BeanInfo`不同的是，`BeanDesc`要求属性和getter、setter必须严格对应，即如果有非public属性，它没有对应的getter，则不能获取属性值，没有setter则不能注入属性值。
 
 属性和getter、setter关联规则如下：
 
 1. 忽略字段和方法名的大小写（匹配时）
 2. 字段名是XXX，则Getter查找getXXX、isXXX、getIsXXX
 3. 字段名是XXX，Setter查找setXXX、setIsXXX
-4. Setter忽略参数值与字段值不匹配的情况，因此有多个参数类型的重载时，会调用首次匹配的
+4. Setter忽略参数值与字段值类型不匹配的情况，因此有多个参数类型的重载时，会调用首次匹配的
 
 ## 使用
 
diff --git "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/06.\347\251\272\346\243\200\346\237\245\345\261\236\346\200\247\350\216\267\345\217\226-Opt.md" "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/06.\347\251\272\346\243\200\346\237\245\345\261\236\346\200\247\350\216\267\345\217\226-Opt.md"
index 7c07b4e4b495a0e8ae4e4fcd52edb6b418ed19be..1708ed133af63d99adb6b3f52a7f78f59457fcb0 100644
--- "a/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/06.\347\251\272\346\243\200\346\237\245\345\261\236\346\200\247\350\216\267\345\217\226-Opt.md"
+++ "b/docs/01.\346\214\207\345\215\227/02.\346\240\270\345\277\203\357\274\210Hutool-core\357\274\211/07.JavaBean/06.\347\251\272\346\243\200\346\237\245\345\261\236\346\200\247\350\216\267\345\217\226-Opt.md"
@@ -5,7 +5,7 @@ permalink: /pages/Opt/
 ---
 ## 介绍
 
-在嵌套对象的属性获取中，由于子对象无法得知是否为`null`，每次获取属性都要检查属性兑现是否为null，使得代码会变得特备臃肿，因此使用`Opt`来优雅的链式获取属性对象值。
+在嵌套对象的属性获取中，由于子对象无法得知是否为`null`，每次获取属性都要检查属性对象是否为null，使得代码会变得特备臃肿，因此使用`Opt`来优雅的链式获取属性对象值。
 
 > 声明：此类的作者：[阿超](https://gitee.com/VampireAchao) ，PR来自：https://gitee.com/dromara/hutool/pulls/426
 
@@ -49,25 +49,21 @@ String addressValue = Opt.ofNullable(user)
 String hutool = Opt.ofBlankAble("").orElse("hutool");
 Assert.equals("hutool", hutool);
 ```
-- 原版Optional有区别的是，get不会抛出NoSuchElementException
-- 如果想使用原版Optional中的get这样，获取一个一定不为空的值，则应该使用orElseThrow
+- 和原版`Optional`有区别的是，`Opt.get()`不会抛出NoSuchElementException
+- 如果想像原版Optional中的get那样，获取一个一定不为空的值，则应该使用orElseThrow
 ```java
-// 和原版Optional有区别的是，get不会抛出NoSuchElementException
-// 如果想使用原版Optional中的get这样，获取一个一定不为空的值，则应该使用orElseThrow
 Object opt = Opt.ofNullable(null).get();
 Assert.isNull(isEmpty);
 ```
 - 这是参考了jdk11 Optional中的新函数isEmpty，用于判断不存在值的情况
 ```java
-// 这是参考了jdk11 Optional中的新函数
 // 判断包裹内元素是否为空，注意并没有判断空字符串的情况
 boolean isEmpty = Opt.empty().isEmpty();
 Assert.isTrue(isEmpty);
 ```
 - 灵感来源于jdk9 Optional中的新函数ifPresentOrElse，用于 存在值时执行某些操作，不存在值时执行另一个操作，支持链式编程
 ```java
-// 灵感来源于jdk9 Optional中的新函数ifPresentOrElse
-// 存在就打印对应的值，不存在则用{@code System.err.println}打印另一句字符串
+// 存在就打印对应的值，不存在则用System.err.println打印另一句字符串
 Opt.ofNullable("Hello Hutool!").ifPresentOrElse(System.out::println, () -> System.err.println("Ops!Something is wrong!"));
 Opt.empty().ifPresentOrElse(System.out::println, () -> System.err.println("Ops!Something is wrong!"));
 ```
@@ -85,7 +81,6 @@ Assert.equals("hutool", name);
 ```
 - 灵感来源于jdk11 Optional中的新函数or，用于值不存在时，用别的Opt代替
 ```java
-// 灵感来源于jdk11 Optional中的新函数or
 // 给一个替代的Opt
 String str = Opt.<String>ofNullable(null).or(() -> Opt.ofNullable("Hello hutool!")).map(String::toUpperCase).orElseThrow();
 Assert.equals("HELLO HUTOOL!", str);
@@ -96,11 +91,13 @@ Opt<User> userOpt = Opt.of(user);
 String name = userOpt.map(User::getNickname).or(() -> userOpt.map(User::getUsername)).get();
 Assert.equals("hutool", name);
 ```
-- 对orElseThrow进行了重载，支持 双冒号+自定义提示语 写法，比原来的
+- 对orElseThrow进行了重载，支持 双冒号+自定义提示语 写法，比原来的更加优雅。
+
+原来的写法：
 ```java
 orElseThrow(() -> new IllegalStateException("Ops!Something is wrong!"))
 ```
-更加优雅,修改后写法为：
+修改后写法：
 ```java
 orElseThrow(IllegalStateException::new, "Ops!Something is wrong!")
 ```
@@ -113,13 +110,13 @@ orElseThrow(IllegalStateException::new, "Ops!Something is wrong!")
 
 对于这种情况，我们依靠我们强大的`idea`即可
 
-例如此处我写到这里写不会了
+例如此处我写到这里不会写了
 
 ```java
 User user = new User();
-// idea提示下方参数，如果没显示，光标放到括号里按ctrl+p主动呼出            
-         |Function<? super User,?> mapper|
-Opt.ofNullable(user).map()
+Opt.ofNullable(user).map(|光标停在此处)
+// idea会提示方法参数，如果没显示，光标放到括号里按ctrl+p主动呼出            
+        |Function<? super User,?> mapper|
 ```
 
 这里`idea`为我们提示了参数类型，可这个`Function`我也不知道它是个什么
@@ -190,7 +187,7 @@ Opt.ofNullable(user).map(new Function<User, String>() {
 })
 ```
 
-这里重写的方法里面就写你自己的逻辑(别忘了补全后面的分号)
+这里重写的方法里面就写你自己的逻辑(别忘了补全最后小括号后面的分号)
 
 ```java
 Opt.ofNullable(user).map(new Function<User, String>() {
@@ -203,7 +200,7 @@ Opt.ofNullable(user).map(new Function<User, String>() {
 
 我们可以看到，上边的`new Function<User, String>()`变成了灰色
 
-我们在它上面按一下`alt`+`enter`(回车)
+我们让光标移动到灰色字符上面，按一下`alt`+`enter`(回车)
 
 ```java
 Opt.ofNullable(user).map(new Function<User, String>() {