2020-06-09 21:13:00

docs/misc2/100.md

@@ -262,8 +262,8 @@ Model- LUXURY built in ASIA
 
 您已经可以更深入地研究 JDK 分发中的抽象工厂的不同*实时示例：*
 
-*   [DocumentBuilderFactory＃newInstance（）](https://docs.oracle.com/javase/6/docs/api/javax/xml/parsers/DocumentBuilderFactory.html#newInstance%28%29 "DocumentBuilderFactory newinstance")
-*   [TransformerFactory＃newInstance（）](https://docs.oracle.com/javase/6/docs/api/javax/xml/transform/TransformerFactory.html#newInstance%28%29 "TransformerFactory newInstance")
+*   [DocumentBuilderFactory＃newInstance()](https://docs.oracle.com/javase/6/docs/api/javax/xml/parsers/DocumentBuilderFactory.html#newInstance%28%29 "DocumentBuilderFactory newinstance")
+*   [TransformerFactory＃newInstance()](https://docs.oracle.com/javase/6/docs/api/javax/xml/transform/TransformerFactory.html#newInstance%28%29 "TransformerFactory newInstance")
 
 还有其他类似的示例，但是需要对**抽象工厂设计模式**有所了解，这是您到目前为止必须已经掌握的。
 

docs/misc2/103.md

@@ -406,7 +406,7 @@ Exception in thread "main" java.lang.IllegalArgumentException: You problem is no
 
 ## **JDK 中的参考实现**
 
-*   [javax.servlet.Filter＃doFilter（）](https://docs.oracle.com/javaee/6/api/javax/servlet/Filter.html#doFilter%28javax.servlet.ServletRequest,%20javax.servlet.ServletResponse,%20javax.servlet.FilterChain%29 "dofilter chain")
+*   [javax.servlet.Filter＃doFilter()](https://docs.oracle.com/javaee/6/api/javax/servlet/Filter.html#doFilter%28javax.servlet.ServletRequest,%20javax.servlet.ServletResponse,%20javax.servlet.FilterChain%29 "dofilter chain")
 
 每当客户端对链末端的资源提出请求时，每次通过链传递请求/响应对时，容器都会调用 Filter 的`doFilter`方法。 传入此方法的 FilterChain 允许 Filter 将请求和响应传递给链中的下一个实体。
 

docs/misc2/104.md

@@ -384,7 +384,7 @@ Fan stopped..
 2.  在命令模式中，对象用于封装在任何时间执行操作或触发事件所需的所有信息，从而使开发人员能够分散业务逻辑。 它称为命令。
 3.  客户端与调用程序对话并传递命令对象。
 4.  每个命令对象都有对其接收者的引用。
-5.  Command 的 execute（）方法调用接收器中定义的实际业务操作。
+5.  Command 的 execute()方法调用接收器中定义的实际业务操作。
 6.  接收者执行业务操作。
 
 这是此模式的一些利弊。 它可以帮助您就使用命令模式做出正确的决定。

docs/misc2/11.md

@@ -2,11 +2,11 @@
 
 > 原文： [https://howtodoinjava.com/learningpaths/gson/](https://howtodoinjava.com/learningpaths/gson/)
 
-通常，所有现代应用都从远程服务（例如 [REST](https://restfulapi.net) 或 SOAP）中获取数据。 数据大部分为 XML 或 JSON 格式。 Gson 自动（在必要时使用简单的`toJson()`和`fromJson()`方法手动或手动）帮助 *Java-JSON 序列化和反序列化*中的应用。
+通常，所有现代应用都从远程服务（例如 [REST](https://restfulapi.net) 或 SOAP）中获取数据。 数据大部分为 XML 或 JSON 格式。 Gson 自动（在必要时使用简单的`toJson()`和`fromJson()`方法手动或手动）帮助应用进行 *Java-JSON 序列化和反序列化*。
 
 Gson 可以处理任意 Java 对象，包括我们没有源代码的现有对象。
 
-Gson 的最佳**好处是，在我们为某些成员字段进行非常特定的操作之前，不必强制将注释添加到 Java 类中。**
+Gson 的最佳**好处是**，在我们为某些成员字段进行非常特定的操作之前，不必强制将注释添加到 Java 类中。
 
 请注意，`Gson`实例在调用 Json 操作时不会保持任何状态。 因此，您可以自由地将同一对象重用于多个 Json 序列化和反序列化操作。
 
@@ -24,9 +24,9 @@ Gson 的最佳**好处是，在我们为某些成员字段进行非常特定的
 
     学习如何使用 GSON 将简单的 Java 对象序列化为 JSON 表示，并将 JSON 字符串反序列化为等效的 Java 对象。
 
-*   #### [紧凑型 Vs。 JSON 输出格式](https://howtodoinjava.com/gson/pretty-print-json-output/)的精美打印
+*   #### [JSON 输出格式紧凑型 VS 精美打印](https://howtodoinjava.com/gson/pretty-print-json-output/)
 
-    Gson 提供的默认 JSON 输出是紧凑的 JSON 格式。 使用 Pretty Print 功能来格式化 JSON 以供读取。
+    Gson 提供的默认 JSON 输出是紧凑的 JSON 格式。 使用精美打印功能来格式化 JSON 以供读取。
 
 *   #### [数组和对象列表的映射](https://howtodoinjava.com/gson/gson-parse-json-array/)
 
@@ -34,17 +34,17 @@ Gson 的最佳**好处是，在我们为某些成员字段进行非常特定的
 
 *   #### [集的映射](https://howtodoinjava.com/gson/gson-serialize-deserialize-set/)
 
-    了解如何使用 Google GSON 库反序列化或解析 JSON 以在 Java 中进行设置（例如 HashSet）。
+    了解如何使用 Google GSON 库反序列化或解析 JSON 以在 Java 中进行设置（例如`HashSet`）。
 
 *   #### [地图的映射](https://howtodoinjava.com/gson/gson-serialize-deserialize-hashmap/)
 
-    学习使用 Google Gson 库序列化 HashMap。 还应学习使用 Gson 将 JSON 字符串反序列化为包含自定义对象的 HashMap，以便将字段值复制到适当的通用类型中。
+    学习使用 Google Gson 库序列化`HashMap`。 还应学习使用 Gson 将 JSON 字符串反序列化为包含自定义对象的`HashMap`，以便将字段值复制到适当的通用类型中。
 
 ## 2.提前用法
 
 第一部分中的基本示例足以应付默认用例。 我们可能需要自定义 Gson 的行为以支持特定要求。 了解如何执行此操作。
 
-*   #### [使用 GsonBuilder](https://howtodoinjava.com/gson/gson-gsonbuilder-configuration/) 自定义 Gson 对象
+*   #### [使用`GsonBuilder`自定义 Gson 对象](https://howtodoinjava.com/gson/gson-gsonbuilder-configuration/) 
 
     对于简单的用例，使用`'Gson gson = new Gson();'`就足够了。 学习使用 GsonBuilder 通过自定义配置创建新的 Gson 实例。
 
@@ -54,9 +54,9 @@ Gson 的最佳**好处是，在我们为某些成员字段进行非常特定的
 
 *   #### [版本支持](https://howtodoinjava.com/gson/gson-since-version-support/)
 
-    可以使用@Since 批注维护同一对象的多个版本。 Gson 将忽略任何大于配置的版本号的字段/对象。
+    可以使用`@Since`注解维护同一对象的多个版本。 Gson 将忽略任何大于配置的版本号的字段/对象。
 
-*   #### [使用@SerializedName 的自定义字段名称](https://howtodoinjava.com/gson/gson-serializedname/)
+*   #### [使用`@SerializedName`的自定义字段名称](https://howtodoinjava.com/gson/gson-serializedname/)
 
     了解如何使用 Google GSON 库将 Java 对象序列化为其 JSON 表示形式，以及将 JSON 字符串反序列化为等效的 Java 对象。
 
@@ -64,17 +64,17 @@ Gson 的最佳**好处是，在我们为某些成员字段进行非常特定的
 
     Gson 支持多种机制来排除顶级类，字段和字段类型。 了解如何使用它们。
 
-*   #### [JsonReader – 流 JSON 解析器](https://howtodoinjava.com/gson/jsonreader-streaming-json-parser/) 
+*   #### [`JsonReader` – 流式 JSON 解析器](https://howtodoinjava.com/gson/jsonreader-streaming-json-parser/) 
 
     了解如何读取 JSON 字符串或文件作为 JSON 令牌流。
 
-*   #### [JsonParser，JsonElement 和 JsonObject](https://howtodoinjava.com/gson/gson-jsonparser/)
+*   #### [`JsonParser`，`JsonElement`和`JsonObject`](https://howtodoinjava.com/gson/gson-jsonparser/)
 
-    学习将 JSON 字符串解析或流化为 Java 对象的树形结构并转换为 JsonElement。
+    学习将 JSON 字符串解析或流化为 Java 对象的树形结构并转换为`JsonElement`。
 
 *   #### [自定义序列化和反序列化](https://howtodoinjava.com/gson/custom-serialization-deserialization/)
 
-    Learn to parse a JSON string or stream into a tree structure of Java objects into JsonElement.
+    学习将 JSON 字符串解析或流化为 Java 对象的树形结构并转换为`JsonElement`。
 
 *   #### [Gson 教程 - 回顾](https://howtodoinjava.com/gson/google-gson-tutorial/)
 

docs/misc2/110.md

@@ -247,7 +247,7 @@ Connecting with Lokesh through Orkut [not possible though :)]
 *   它允许添加新算法而无需修改使用算法或策略的现有算法或上下文类
 *   策略是“四个设计的帮派”列表中的一种行为模式。
 *   策略模式基于 SOLID 主体的开放式封闭设计原则。
-*   Collections.sort（）和 Comparator 接口的组合是 Strategy 模式的可靠示例。
+*   Collections.sort()和 Comparator 接口的组合是 Strategy 模式的可靠示例。
 
 这就是有关策略设计模式的全部内容。 将我的问题放在评论部分。
 

docs/misc2/112.md

@@ -54,15 +54,15 @@ Existing routers in application
 
 
 
-我们有以上 3 种类型的路由器，我们需要为它们编写代码。 **解决此问题的一种方法**是在 Router.java 接口中定义诸如 configureForWinodws（）和 configureForLinux（）之类的方法，并在不同的产品中实现它们，因为每种方法都有自己的配置设置和过程。
+我们有以上 3 种类型的路由器，我们需要为它们编写代码。 **解决此问题的一种方法**是在 Router.java 接口中定义诸如 configureForWinodws()和 configureForLinux()之类的方法，并在不同的产品中实现它们，因为每种方法都有自己的配置设置和过程。
 
 但是上述方法的问题在于，每次引入新环境时，都必须重新编译整个路由器的层次结构。 不可接受的解决方案。 那么什么可以预防这种情况呢？
 
 ## 使用访客模式的建议解决方案
 
-访客模式非常适合这些类型的问题，在这些类型的问题中，您希望对对象的层次结构引入新的操作，而无需更改其结构或对其进行修改。 在此解决方案中，我们将通过引入两种方法（即 accept（）和 visit（）方法）来实现**双调度技术。 方法 accept（），将在路由器的层次结构中定义，访问方法将在访问者级别。**
+访客模式非常适合这些类型的问题，在这些类型的问题中，您希望对对象的层次结构引入新的操作，而无需更改其结构或对其进行修改。 在此解决方案中，我们将通过引入两种方法（即 accept()和 visit()方法）来实现**双调度技术。 方法 accept()，将在路由器的层次结构中定义，访问方法将在访问者级别。**
 
-每当需要添加新环境时，都会将新的访问者添加到访问者层次结构中，这需要为所有可用的路由器实现 visit（）方法，仅此而已。
+每当需要添加新环境时，都会将新的访问者添加到访问者层次结构中，这需要为所有可用的路由器实现 visit()方法，仅此而已。
 
 ![Solution using visitor pattern](img/e6edffc1348f322b944f93c38e03d38c.png "Solution using visitor pattern")
 
@@ -70,7 +70,7 @@ Solution using visitor pattern
 
 
 
-在上面的类图中，我们为 Mac 和 Linux 操作系统配置了路由器。 如果我们还需要添加 Windows 功能，那么我不需要更改任何类，只需定义一个新的访问者 WindowsConfigurator 并实现 RouterVisitor 接口中定义的 visit（）方法。 它将提供所需的功能，而无需任何进一步的修改。
+在上面的类图中，我们为 Mac 和 Linux 操作系统配置了路由器。 如果我们还需要添加 Windows 功能，那么我不需要更改任何类，只需定义一个新的访问者 WindowsConfigurator 并实现 RouterVisitor 接口中定义的 visit()方法。 它将提供所需的功能，而无需任何进一步的修改。
 
 ## 实施代码
 

docs/misc2/114.md

@@ -108,7 +108,7 @@ Also note that if the Target and Adaptee are similar then the adapter has just t
 
 其他值得注意的例子如下：
 
-1） [java.util.Arrays＃asList（）](https://docs.oracle.com/javase/6/docs/api/java/util/Arrays.html#asList%28T...%29 "Arrays.asList")
+1） [java.util.Arrays＃asList()](https://docs.oracle.com/javase/6/docs/api/java/util/Arrays.html#asList%28T...%29 "Arrays.asList")
 
 此方法接受多个字符串并返回输入字符串的列表。 虽然这是非常基本的用法，但是它是适配器的功能，对不对？
 
@@ -122,7 +122,7 @@ writer.write("Hello World");
 
 ```
 
-3） [javax.xml.bind.annotation.adapters.XmlAdapter＃marshal（）和#unmarshal（）](https://docs.oracle.com/javaee/5/api/javax/xml/bind/annotation/adapters/XmlAdapter.html "XmlAdapter")
+3） [javax.xml.bind.annotation.adapters.XmlAdapter＃marshal()和#unmarshal()](https://docs.oracle.com/javaee/5/api/javax/xml/bind/annotation/adapters/XmlAdapter.html "XmlAdapter")
 
 使 Java 类型适应自定义封送处理。 将绑定类型转换为值类型。
 

docs/misc2/117.md

@@ -46,11 +46,11 @@ You have an instance, and you put another instance inside of it. They both suppo
 
 这两个报告**都必须具有第一列作为到原始报告的链接**，并且它们应具有**不同的颜色**。 可能应在**不同弹出窗口大小**中打开它们。 这些只是很少的事情，现实中可以实现很多。
 
-一种**可能的方法是扩展 Report 对象**，然后具有两个单独的类 ClientReport 和 SupportReport。 在这两种方法中，定义私有方法，例如 *makeAnchorLink（），designPopup（），applyColor（）*等。 现在，在第一列数据单元格的某些 getter 方法中调用这些方法。
+一种**可能的方法是扩展 Report 对象**，然后具有两个单独的类 ClientReport 和 SupportReport。 在这两种方法中，定义私有方法，例如 *makeAnchorLink()，designPopup()，applyColor()*等。 现在，在第一列数据单元格的某些 getter 方法中调用这些方法。
 
 ![SubClassing](img/e3350e23c83710cf42f9e861238905d7.png "SubClassing")
 
-如果您在此处停止并且不再修改系统，则它将起作用。 但是，假设几天后**，您被告知为两种报告应用不同的背景色**。 现在，您只有一种方法可以在两个类中定义方法 *colorBackground* （），并进行适当的调用。 将来系统中有更多报告时，问题将变得更加严重。
+如果您在此处停止并且不再修改系统，则它将起作用。 但是，假设几天后**，您被告知为两种报告应用不同的背景色**。 现在，您只有一种方法可以在两个类中定义方法 *colorBackground* ()，并进行适当的调用。 将来系统中有更多报告时，问题将变得更加严重。
 
 上面的解决方案明显违反了 [**SMART 类别设计**](//howtodoinjava.com/best-practices/5-class-design-principles-solid-in-java/ "SMART principles for class design") 中提到的**打开/关闭原则**。
 

docs/misc2/12.md

@@ -4,7 +4,7 @@
 
 学习使用诸如 maven，gradle 或简单 jar 文件之类的构建工具在 Java 应用中包括 **gson 依赖项**。
 
-## 1.在 Gradle / Android 上安装 Gson
+## 1. 在 Gradle / Android 上安装 Gson
 
 通过添加以下依赖项，将 gson 包含在应用或 android 项目中：
 
@@ -15,9 +15,9 @@ dependencies {
 
 ```
 
-## 2.用 Maven 安装 Gson
+## 2. 用 Maven 安装 Gson
 
-通过添加以下依赖项，在 Maven Central 中下载 *[最新的 Gson 版本](https://mvnrepository.com/artifact/com.google.code.gson/gson)* 或所需版本：
+通过添加以下依赖项，在 Maven 中心中下载[*最新的 Gson 版本*](https://mvnrepository.com/artifact/com.google.code.gson/gson)或所需版本：
 
 ```java
 <dependencies>
@@ -30,7 +30,7 @@ dependencies {
 
 ```
 
-## 3.将 Gson 安装为 Jar 文件
+## 3. 将 Gson 安装为 Jar 文件
 
 可以从此[位置](https://repo1.maven.org/maven2/com/google/code/gson/gson/)下载 jar 文件。
 

docs/misc2/124.md

@@ -58,7 +58,7 @@ public class EmployeeStore implements IEmployeeStore
 
 现在假设产品发布后，我们要求电子邮件内容可以是两种类型，即 HTML 和文本。 上课支持仅文本内容。 你会做什么？
 
-解决此问题的一种方法是创建另一种方法 **sendHtmlEmail（）**，但是当我们被要求支持为两种内容类型发送电子邮件的不同协议时会发生什么。 整体课程看起来非常丑陋，难以阅读和维护。
+解决此问题的一种方法是创建另一种方法 **sendHtmlEmail()**，但是当我们被要求支持为两种内容类型发送电子邮件的不同协议时会发生什么。 整体课程看起来非常丑陋，难以阅读和维护。
 
 而且总是有机会在修改期间，某些开发人员可以更改用于共享员工方法的获取/添加员工方法的逻辑。
 

docs/misc2/126.md

@@ -66,17 +66,17 @@
 
 了解如何使用 WatchService 在运行时重新加载日志记录配置。 也可以使用它们来重新加载其他配置。
 
-#### [使用 ToStringBuilder](//howtodoinjava.com/apache-commons/how-to-override-tostring-effectively-with-tostringbuilder/ "How to override toString() effectively with ToStringBuilder") 有效覆盖 toString（）
+#### [使用 ToStringBuilder](//howtodoinjava.com/apache-commons/how-to-override-tostring-effectively-with-tostringbuilder/ "How to override toString() effectively with ToStringBuilder") 有效覆盖 toString()
 
-ToStringBuilder 是 apache commons lang 库提供的实用程序类。 学习使用它编写高度自定义的 toString（）方法。
+ToStringBuilder 是 apache commons lang 库提供的实用程序类。 学习使用它编写高度自定义的 toString()方法。
 
-#### [在任何循环内使用数组代替 Vector.elementAt（）](//howtodoinjava.com/best-practices/use-array-instead-of-vector-elementat-inside-any-loop-for-better-performance/ "Use array instead of Vector.elementAt() inside any loop for better performance")
+#### [在任何循环内使用数组代替 Vector.elementAt()](//howtodoinjava.com/best-practices/use-array-instead-of-vector-elementat-inside-any-loop-for-better-performance/ "Use array instead of Vector.elementAt() inside any loop for better performance")
 
 从多个线程访问时，Vector 不需要额外的同步，但是由于相同的原因，它会降低其性能。 评估其影响。
 
-#### [在 Java 中始终使用 length（）而不是 equals（）来检查空字符串](//howtodoinjava.com/java/string/always-use-length-instead-of-equals-to-check-empty-string-in-java/ "Always use length() instead of equals() to check empty string in java")
+#### [在 Java 中始终使用 length()而不是 equals()来检查空字符串](//howtodoinjava.com/java/string/always-use-length-instead-of-equals-to-check-empty-string-in-java/ "Always use length() instead of equals() to check empty string in java")
 
-检查字符串是否为空的最好方法是使用 length（）方法而不是 equals（）。 为什么？ 让我们做一些推理。
+检查字符串是否为空的最好方法是使用 length()方法而不是 equals()。 为什么？ 让我们做一些推理。
 
 ## 3\. Java 性能最佳实践
 

docs/misc2/127.md

@@ -68,7 +68,7 @@
 
 如果使用 Eclipse 或 IntelliJ IDEA，请考虑合并 [Infinitest](https://infinitest.github.io/) 之类的工具。 在对系统进行更改时，Infinitest 会识别并运行（在后台）任何可能受到影响的测试。
 
-在更大范围内，您可以使用持续集成（CI）工具，例如 [Jenkins](https://jenkins.io/) 或 [TeamCity](https://www.jetbrains.com/teamcity/) 。 CI 工具会监视您的源存储库，并在识别到更改后启动构建/测试过程。
+在更大范围内，您可以使用持续集成（CI）工具，例如 [Jenkins](https://jenkins.io/) 或 [TeamCity](https://www.jetbrains.com/teamcity/) 。 CI 工具会监视您的源仓库，并在识别到更改后启动构建/测试过程。
 
 在评论部分中，将您与 **FIRST Principles** 相关的查询发送给我。
 

docs/misc2/128.md

@@ -195,7 +195,7 @@ public class TestEmployeeDAO
 
     ```
 
-3.  使用@Rollback（true）批注可恢复原始数据库状态。
+3.  使用@Rollback（true）注解可恢复原始数据库状态。
 
     ```java
     @Test

docs/misc2/129.md

@@ -102,7 +102,7 @@ Summary
 
 #### 7.首先编写对依赖关系最少的方法的测试，然后逐步进行
 
-该原则表明，如果要测试 Employee 模块，则应该首先测试 Create Employee 模块，因为它对外部测试用例的依赖性最小。 一旦完成，就开始编写 Modify Employee 测试用例，因为它们需要一些雇员在数据库中。
+该原则表明，如果要测试 Employee 模块，则应该首先测试 Create Employee 模块，因为它对外部测试用例的依赖项最小。 一旦完成，就开始编写 Modify Employee 测试用例，因为它们需要一些雇员在数据库中。
 
 要在数据库中拥有一些员工，您的创建员工测试用例必须先通过，然后才能继续。 这样，如果员工创建逻辑中存在一些错误，则可以更早地发现它。
 

docs/misc2/13.md

@@ -2,9 +2,9 @@
 
 > 原文： [https://howtodoinjava.com/gson/gson-serialize-deserialize-json/](https://howtodoinjava.com/gson/gson-serialize-deserialize-json/)
 
-了解如何使用 Google **GSON** 库将 Java 对象序列化为其 JSON 表示，并将 JSON 字符串反序列化为等效的 Java 对象。 GSON 提供了简单的 **toJson（）**和 **fromJson（）**方法，将 Java 对象转换为 JSON，反之亦然。
+了解如何使用 Google **GSON** 库将 Java 对象序列化为其 JSON 表示，并将 JSON 字符串反序列化为等效的 Java 对象。 GSON 提供了简单的`toJson()`和`fromJson()`方法，将 Java 对象转换为 JSON，反之亦然。
 
-使用 **GsonBuilder** 创建具有自定义配置的`Gson`对象，例如**漂亮打印**。
+使用`GsonBuilder`创建具有自定义配置的`Gson`对象，例如**精美打印**。
 
 ```java
 //Gson gson = new Gson();
@@ -20,7 +20,7 @@ Employee empObject = gson.fromJson(jsonString, Employee.class);
 
 ## 1.依赖
 
-Maven 依赖项。 访问 [maven 存储库](https://mvnrepository.com/artifact/com.google.code.gson/gson)以获取最新版本。
+Maven 依赖项。 访问 [maven 仓库](https://mvnrepository.com/artifact/com.google.code.gson/gson)以获取最新版本。
 
 ```java
 <dependency>
@@ -31,7 +31,7 @@ Maven 依赖项。 访问 [maven 存储库](https://mvnrepository.com/artifact/c
 
 ```
 
-Gradle 依赖性。
+Gradle 依赖项。
 
 ```java
 <dependency>
@@ -43,7 +43,7 @@ dependencies {
 
 ## 2.序列化 – 使用 Gson 编写 JSON
 
-[在 Gson 上下文中的序列化](https://howtodoinjava.com/java/serialization/a-mini-guide-for-implementing-serializable-interface-in-java/)意味着将 Java 对象转换为其 JSON 表示形式。 为了进行序列化，我们需要一个 **Gson** 对象，该对象可以处理转换。 接下来，我们需要调用函数 **toJson（）**，并传递`Employee`对象。
+[在 Gson 上下文中的序列化](https://howtodoinjava.com/java/serialization/a-mini-guide-for-implementing-serializable-interface-in-java/)意味着将 Java 对象转换为其 JSON 表示形式。 为了进行序列化，我们需要一个 **Gson** 对象，该对象可以处理转换。 接下来，我们需要调用函数`toJson()`，并传递`Employee`对象。
 
 ```java
 Employee emp = new Employee(1001, "Lokesh", "Gupta", "howtodoinjava@gmail.com");
@@ -70,7 +70,7 @@ System.out.println(jsonString);
 
 ## 2.反序列化 – 使用 Gson 读取 JSON
 
-在 Gson 上下文中，[反序列化](https://howtodoinjava.com/java/serialization/how-deserialization-process-happen-in-java/)意味着将 JSON 字符串转换为等效的 Java 对象。 为了进行反序列化，我们需要一个 **Gson** 对象，并从 Json（）调用函数**，并在解析完成后传递两个参数，即 JSON 字符串和所需的 Java 类型。**
+在 Gson 上下文中，[反序列化](https://howtodoinjava.com/java/serialization/how-deserialization-process-happen-in-java/)意味着将 JSON 字符串转换为等效的 Java 对象。 为了进行反序列化，我们需要一个 **Gson** 对象，并从`Json()`调用函数，并在解析完成后传递两个参数，即 JSON 字符串和所需的 Java 类型。
 
 ```java
 String jsonString = "{'id':1001, 'firstName':'Lokesh', 'lastName':'Gupta', 'email':'howtodoinjava@gmail.com'}";
@@ -83,14 +83,14 @@ System.out.println(empObject);
 
 ```
 
-Program output.
+程序输出：
 
 ```java
 Employee [id=1001, firstName=Lokesh, lastName=Gupta, email=howtodoinjava@gmail.com]
 
 ```
 
-请问您有关`Gson`对象及其`toJson()`和`fromJson()`方法的问题。
+向我提供有关`Gson`对象及其`toJson()`和`fromJson()`方法的问题。
 
 学习愉快！
 

docs/misc2/130.md

@@ -38,7 +38,7 @@ Test filling log files with load of texts
 
 相信我，我在以前的项目中看到过这样的测试用例，它们似乎在代码中做了很多工作，但实际上它们什么也没做。 他们正在向服务器发送请求，无论什么服务器响应，它们都在传递。 恐怖！
 
-通过严格的代码审查，当心将此类测试用例放在您的代码存储库中。 一旦它们进入您的代码库，它们将成为您承担责任，每次携带，构建和运行它们，但不增加任何价值。
+通过严格的代码审查，当心将此类测试用例放在您的代码仓库中。 一旦它们进入您的代码库，它们将成为您承担责任，每次携带，构建和运行它们，但不增加任何价值。
 
 ## 2）测试无关的东西
 

docs/misc2/131.md

@@ -166,7 +166,7 @@ try {
 
 ```
 
-只要 cleanUp（）永远不会抛出任何异常，就可以了。 在上面的示例中，如果 someMethod（）引发异常，并且在 finally 块中，cleanUp（）引发异常，则第二个异常将从方法中消失，原始的第一个异常（正确原因）将永远消失。 如果您在 finally 块中调用的代码可能会引发异常，请确保处理该异常或将其记录下来。 永远不要让它脱离最后的障碍。
+只要 cleanUp()永远不会抛出任何异常，就可以了。 在上面的示例中，如果 someMethod()引发异常，并且在 finally 块中，cleanUp()引发异常，则第二个异常将从方法中消失，原始的第一个异常（正确原因）将永远消失。 如果您在 finally 块中调用的代码可能会引发异常，请确保处理该异常或将其记录下来。 永远不要让它脱离最后的障碍。
 
 #### 3.8 始终仅捕获您可以实际处理的异常
 
@@ -179,9 +179,9 @@ catch (NoSuchMethodException e) {
 
 好吧，这是最重要的概念。 不要仅仅为了捕获异常就捕获任何异常。 仅在您要处理任何异常或要在该异常中提供其他上下文信息时才捕获任何异常。 如果您无法在捕获区中处理它，那么最好的建议就是不要仅将其重新抛出就捕获它。
 
-#### 3.9 不要使用 printStackTrace（）语句或类似方法
+#### 3.9 不要使用 printStackTrace()语句或类似方法
 
-完成代码后，切勿离开 printStackTrace（）。 很有可能是您的同事之一，最终将获得这些堆栈跟踪中的一个，并且对如何处理它的知识完全为零，因为它不会附加任何上下文信息。
+完成代码后，切勿离开 printStackTrace()。 很有可能是您的同事之一，最终将获得这些堆栈跟踪中的一个，并且对如何处理它的知识完全为零，因为它不会附加任何上下文信息。
 
 #### 3.10 如果您不打算处理异常，请使用 finally 块而不是 catch 块
 
@@ -243,7 +243,7 @@ LOGGER.debug("Using retry sector B");
 
 不要这样
 
-在测试用例中，将多行日志消息与多次调用 LOGGER.debug（）一起使用可能看起来不错，但是当它显示在并行运行 400 个线程的应用服务器的日志文件中时，所有信息都将转储到同一线程 日志文件中，即使两条日志消息出现在代码的后续行中，它们最终也可能在日志文件中以 1000 行隔开。
+在测试用例中，将多行日志消息与多次调用 LOGGER.debug()一起使用可能看起来不错，但是当它显示在并行运行 400 个线程的应用服务器的日志文件中时，所有信息都将转储到同一线程 日志文件中，即使两条日志消息出现在代码的后续行中，它们最终也可能在日志文件中以 1000 行隔开。
 
 像这样做：
 

docs/misc2/132.md

@@ -224,7 +224,7 @@ jdbc.password=password
 
 ```
 
-## 12）在开发阶段使用“依赖性检查”
+## 12）在开发阶段使用“依赖项检查”
 
 您应该将 Bean 定义上的`dependency-check`属性设置为`simple`，`objects`或`all`（默认值为`none`，即不检查），以便容器可以为您执行显式依赖项验证。 当必须显式地或通过自动装配来设置 Bean 的所有属性（或某些类别的属性）时，这很有用。
 

docs/misc2/14.md

-# Gson – JSON 输出的漂亮打印
+# Gson – JSON 输出的精美打印
 
 > 原文： [https://howtodoinjava.com/gson/pretty-print-json-output/](https://howtodoinjava.com/gson/pretty-print-json-output/)
 
@@ -15,7 +15,7 @@
 
 默认情况下，Gson *格式化输出 JSON* ，其默认行长为 80 个字符，2 个字符的缩进和 4 个字符的右边距。
 
-## 1.漂亮打印 JSON 的语法
+## 1.精美打印 JSON 的语法
 
 ```java
 Gson gson = new GsonBuilder()
@@ -76,7 +76,7 @@ public class Main
 
 ```
 
-请问您有关**的问题，以便在 Gson** 中实现漂亮的打印。
+向我提供有关**的问题，以便在 Gson** 中实现漂亮的打印。
 
 学习愉快！
 

docs/misc2/145.md

@@ -115,9 +115,9 @@ Hello, World!
 
 #### 7.2 弦乐
 
-[Python – 字符串 split（）示例](https://howtodoinjava.com/python/split-string/)
-[Python – 字符串 startswith（）示例](https://howtodoinjava.com/python/string-startswith/)
-[Python – 字符串 endswith（）示例](https://howtodoinjava.com/python/string-endswith-method/)
+[Python – 字符串 split()示例](https://howtodoinjava.com/python/split-string/)
+[Python – 字符串 startswith()示例](https://howtodoinjava.com/python/string-startswith/)
+[Python – 字符串 endswith()示例](https://howtodoinjava.com/python/string-endswith-method/)
 
 #### 7.3 馆藏
 

docs/misc2/149.md

@@ -183,7 +183,7 @@ print(z)	# <memory at 0x014CE328>
 
 ```
 
-## 3\. type（）函数
+## 3\. type()函数
 
 `type()`函数可用于获取任何对象的数据类型。
 

docs/misc2/15.md

@@ -107,7 +107,7 @@ for(User user : userArray) {
 
 ```
 
-Program output.
+程序输出：
 
 ```java
 User [id=1, name=Alex]
@@ -178,7 +178,7 @@ System.out.println(department);
 
 ```
 
-Program output.
+程序输出：
 
 ```java
 Department [id=1, name=HR, 
@@ -225,7 +225,7 @@ System.out.println(department);
 
 ```
 
-Program output.
+程序输出：
 
 ```java
 Department [id=1, name=HR, 
@@ -235,7 +235,7 @@ Department [id=1, name=HR,
 
 ```
 
-请问您有关 **gson 将 JSON 数组解析为 Java 列表和数组**的问题。
+向我提供有关 **gson 将 JSON 数组解析为 Java 列表和数组**的问题。
 
 学习愉快！
 

docs/misc2/151.md

@@ -71,7 +71,7 @@ print(str[20])	# IndexError: string index out of range
 
 ## 4.字符串长度
 
-len（）函数返回字符串的长度：
+len()函数返回字符串的长度：
 
 ```java
 str = 'hello world'
@@ -102,7 +102,7 @@ print(txt.format(name, age))	# My age is 36 and the name is Lokesh
 
 ## 6.字符串方法
 
-#### 6.1 大写（）
+#### 6.1 大写()
 
 它返回一个字符串，其中给定字符串的第一个字符被转换为大写。 当第一个字符为非字母时，它将返回相同的字符串。
 
@@ -117,7 +117,7 @@ print( txt.capitalize() )	# 38 yrs old lokesh gupta
 
 ```
 
-#### 6.2 casefold（）
+#### 6.2 casefold()
 
 它返回一个字符串，其中所有字符均为给定字符串的小写字母。
 
@@ -128,7 +128,7 @@ print( txt.casefold() )	# my name is lokesh gupta
 
 ```
 
-#### 6.3 中央（）
+#### 6.3 中央()
 
 使用指定的字符（默认为空格）作为填充字符，使字符串居中对齐。
 
@@ -143,7 +143,7 @@ print(x)	# '    hello world     '
 
 ```
 
-#### 6.4 计数（）
+#### 6.4 计数()
 
 它返回指定值出现在字符串中的次数。 它有两种形式：
 
@@ -160,7 +160,7 @@ print( txt.count("o", 4, 7) )	# 1
 
 ```
 
-#### 6.5 编码（）
+#### 6.5 编码()
 
 它使用指定的编码对字符串进行编码。 如果未指定编码，将使用`UTF-8`。
 
@@ -173,7 +173,7 @@ print(x)	# b'My name is \xc3\xa5mber'
 
 ```
 
-#### 6.6 [结尾于（）](https://howtodoinjava.com/python/string-endswith-method/)
+#### 6.6 [结尾于()](https://howtodoinjava.com/python/string-endswith-method/)
 
 如果字符串以指定值结尾，则返回`True`，否则返回`False`。
 
@@ -186,7 +186,7 @@ print( txt.endswith("planet") )		# False
 
 ```
 
-#### 6.7 expandtabs（）
+#### 6.7 expandtabs()
 
 它将制表符大小设置为指定的空格数。
 
@@ -201,7 +201,7 @@ print( txt.expandtabs(16) )		# 'hello           world'
 
 ```
 
-#### 6.8 找（）
+#### 6.8 找()
 
 它查找指定值的第一次出现。 如果指定的值不在字符串中，则返回`-1`。
 
@@ -216,7 +216,7 @@ print(x)		# 6
 
 ```
 
-#### 6.9 格式（）
+#### 6.9 格式()
 
 它格式化指定的字符串，并在字符串的占位符内插入参数值。
 
@@ -230,7 +230,7 @@ print( txt.format(name, age) )	# My name is Lokesh and my age is 36
 
 ```
 
-#### 6.10 format_map（）
+#### 6.10 format_map()
 
 它用于返回字典键的值，以格式化带有命名占位符的字符串。
 
@@ -245,7 +245,7 @@ print(x)		# My name is Lokesh Gupta and age is 38
 
 ```
 
-#### 6.11 指数（）
+#### 6.11 指数()
 
 *   它在给定的字符串中查找指定值的第一次出现。
 *   如果找不到要搜索的值，则会引发异常。
@@ -261,7 +261,7 @@ x = txt.index("z")	# ValueError: substring not found
 
 ```
 
-#### 6.12 isalnum（）
+#### 6.12 isalnum()
 
 它检查字母数字字符串。 如果所有字符均为字母数字，表示字母`(a-zA-Z)`和数字`(0-9)`，则返回`True`。
 
@@ -272,7 +272,7 @@ print("Lokesh Gupta".isalnum())		# False - Contains space
 
 ```
 
-#### 6.13 isalpha（）
+#### 6.13 isalpha()
 
 如果所有字符都是字母，则返回`True`，表示字母`(a-zA-Z)`。
 
@@ -285,7 +285,7 @@ print("LokeshGupta38".isalpha())		# False - Contains numbers
 
 ```
 
-#### 6.14 十进制（）
+#### 6.14 十进制()
 
 如果所有字符均为小数（0-9），则返回代码。 否则返回`False`。
 
@@ -300,7 +300,7 @@ print("1234 5678".isdecimal())		# False - Contains space
 
 ```
 
-#### 6.15 isdigit（）
+#### 6.15 isdigit()
 
 如果所有字符都是数字，则返回`True`，否则返回`False`。 指数也被认为是数字。
 
@@ -315,7 +315,7 @@ print("1234\u00B2".isdigit())		# True - unicode for square 2
 
 ```
 
-#### 6.16 标识符（）
+#### 6.16 标识符()
 
 如果字符串是有效的标识符，则返回`True`，否则返回`False`。
 
@@ -332,7 +332,7 @@ print( "Lokesh Gupta 38".isidentifier() )		# False - Contain spaces
 
 ```
 
-#### 6.17 islower（）
+#### 6.17 islower()
 
 如果所有字符均小写，则返回`True`，否则返回`False`。 不检查数字，符号和空格，仅检查字母字符。
 
@@ -347,7 +347,7 @@ print( "lokesh_gupta_38".islower() )	# True
 
 ```
 
-#### 6.18 isnumeric（）
+#### 6.18 isnumeric()
 
 如果所有字符都是数字（`0-9`），则此方法返回`True`，否则返回`False`。 指数也被认为是数值。
 
@@ -362,7 +362,7 @@ print("1234\u00B2".isnumeric())		# True - unicode for square 2
 
 ```
 
-#### 6.19 可打印（）
+#### 6.19 可打印()
 
 如果所有字符均可打印，则返回`True`，否则返回 False。 不可打印字符用于指示某些格式化操作，例如：
 
@@ -382,11 +382,11 @@ print("Lokesh\tGupta".isprintable())	# False
 
 ```
 
-#### 6.20 isspace（）
+#### 6.20 isspace()
 
 如果字符串中的所有字符都是空格，则返回`True`，否则返回`False`。
 
-#### 6:21。 istitl A（）
+#### 6:21。 istitl A()
 
 如果文本中的所有单词均以大写字母开头，而其余单词均为小写字母（即标题大小写），则返回`True`。 否则`False`。
 
@@ -397,7 +397,7 @@ print("Lokesh gupta".istitle())		# False
 
 ```
 
-#### 6.22 isupper（）
+#### 6.22 isupper()
 
 如果所有字符均大写，则返回`True`，否则返回`False`。 不检查数字，符号和空格，仅检查字母字符。
 
@@ -410,7 +410,7 @@ print("Lokesh Gupta".isupper())		# False
 
 ```
 
-#### 6.23 加入（）
+#### 6.23 加入()
 
 它以可迭代方式获取所有项目，并使用强制性指定的分隔符将它们连接为一个字符串。
 
@@ -423,7 +423,7 @@ print(x)	# Lokesh#Gupta#38
 
 ```
 
-#### 6.24 光（）
+#### 6.24 光()
 
 此方法将使用指定的字符（默认为空格）作为填充字符使字符串左对齐。
 
@@ -436,7 +436,7 @@ print(x)	# lokesh--------------
 
 ```
 
-#### 6.25 降低（）
+#### 6.25 降低()
 
 它返回一个字符串，其中所有字符均为小写。 符号和数字将被忽略。
 
@@ -449,7 +449,7 @@ print(x)	# lokesh gupta
 
 ```
 
-#### 6.26 lstrip（）
+#### 6.26 lstrip()
 
 它删除所有前导字符（默认为空格）。
 
@@ -462,7 +462,7 @@ print(x)	# Lokesh Gupta
 
 ```
 
-#### 6.27 maketrans（）
+#### 6.27 maketrans()
 
 它创建一个字符到其转换/替换的一对一映射。 当在`translate()`方法中使用时，此转换映射用于将字符替换为其映射的字符。
 
@@ -475,7 +475,7 @@ print(string.maketrans(dict))	# {97: '123', 98: '456', 99: '789'}
 
 ```
 
-#### 6.28 划分（）
+#### 6.28 划分()
 
 它在给定的文本中搜索指定的字符串，并将该字符串拆分为包含三个元素的元组：
 
@@ -496,7 +496,7 @@ print(x[2])	#  gupta
 
 ```
 
-#### 6.29 更换（）
+#### 6.29 更换()
 
 它将指定的短语替换为另一个指定的短语。 它有两种形式：
 
@@ -516,7 +516,7 @@ print(x)	# B B A A A
 
 ```
 
-#### 6.30 rfind（）
+#### 6.30 rfind()
 
 它查找指定值的最后一次出现。 如果在给定的文本中找不到该值，则返回`-1`。
 
@@ -533,7 +533,7 @@ print(x)		# -1
 
 ```
 
-#### 6.31 rindex（）
+#### 6.31 rindex()
 
 它查找指定值的最后一次出现，如果找不到该值，则会引发异常。
 
@@ -548,7 +548,7 @@ x = txt.rindex("amit")	# ValueError: substring not found
 
 ```
 
-#### 6.32 调整（）
+#### 6.32 调整()
 
 它将使用指定的字符（默认为空格）作为填充字符来右对齐字符串。
 
@@ -561,7 +561,7 @@ print(x, "is my name")	# ##############lokesh is my name
 
 ```
 
-#### 6.33 rpartition（）
+#### 6.33 rpartition()
 
 它搜索指定字符串的最后一次出现，并将该字符串拆分为包含三个元素的元组。
 
@@ -582,7 +582,7 @@ print(x[2])	#  gupta
 
 ```
 
-#### 6.34 rsplit（）
+#### 6.34 rsplit()
 
 它将字符串从右开始拆分为列表。
 
@@ -595,7 +595,7 @@ print(x)	# ['apple', 'banana', 'cherry']
 
 ```
 
-#### 6.35 rstrip（）
+#### 6.35 rstrip()
 
 它删除所有结尾字符（字符串末尾的字符），空格是默认的结尾字符。
 
@@ -608,7 +608,7 @@ print(x)	# '     lokesh'
 
 ```
 
-#### 6.36 [split（）](https://howtodoinjava.com/python/split-string/)
+#### 6.36 [split()](https://howtodoinjava.com/python/split-string/)
 
 它将字符串拆分为列表。 您可以指定分隔符。 默认分隔符为空格。
 
@@ -621,7 +621,7 @@ print(x)	# ['my', 'name', 'is', 'lokesh']
 
 ```
 
-#### 6.37 splitlines（）
+#### 6.37 splitlines()
 
 通过在换行符处进行拆分，它将字符串拆分为列表。
 
@@ -634,7 +634,7 @@ print(x)	# ['my name', 'is lokesh']
 
 ```
 
-#### 6.38 [startswith（）](https://howtodoinjava.com/python/string-startswith/)
+#### 6.38 [startswith()](https://howtodoinjava.com/python/string-startswith/)
 
 如果字符串以指定值开头，则返回`True`，否则返回`False`。 字符串比较区分大小写。
 
@@ -647,7 +647,7 @@ print( txt.startswith("My") )	# False
 
 ```
 
-#### 6.39 跳闸（）
+#### 6.39 跳闸()
 
 它将删除所有前导（开头的空格）和结尾（结尾的空格）字符（默认为空格）。
 
@@ -658,7 +658,7 @@ print( txt.strip() )	# 'my name is lokesh'
 
 ```
 
-#### 6.40 swapcase（）
+#### 6.40 swapcase()
 
 它返回一个字符串，其中所有大写字母均为小写字母，反之亦然。
 
@@ -669,7 +669,7 @@ print( txt.swapcase() )	# mY nAME iS lOKESH gUPTA
 
 ```
 
-#### 6.41 标题（）
+#### 6.41 标题()
 
 它返回一个字符串，其中每个单词的第一个字符均为大写。 如果单词开头包含数字或符号，则其后的第一个字母将转换为大写字母。
 
@@ -682,7 +682,7 @@ print( "1\. lokesh gupta".title() )	# Lokesh Gupta
 
 ```
 
-#### 6.42 翻译（）
+#### 6.42 翻译()
 
 它需要转换表根据映射表替换/转换给定字符串中的字符。
 
@@ -695,7 +695,7 @@ print( string.translate(translation) )	# idef
 
 ```
 
-#### 6.43 上（）
+#### 6.43 上()
 
 它返回一个字符串，其中所有字符均大写。 符号和数字将被忽略。
 
@@ -706,7 +706,7 @@ print( txt.upper() )	# LOKESH GUPTA
 
 ```
 
-#### 6.44 zfill（）
+#### 6.44 zfill()
 
 它在字符串的开头添加零（0），直到达到指定的长度。
 

docs/misc2/152.md

@@ -131,7 +131,7 @@ print (charList)	# ['a', 'b', 'c', 'd', 'e', 'f', 'h']
 
 要从列表中删除一项，请使用以下四种方式之一，即`remove()`，`pop()`，`clear()`或`del`关键字。
 
-#### 7.1 去掉（）
+#### 7.1 去掉()
 
 它会通过其值删除指定的项目。
 
@@ -144,7 +144,7 @@ print (charList)		# ['a', 'b']
 
 ```
 
-#### 7.2 pop（）
+#### 7.2 pop()
 
 它将通过索引删除指定的项目。 如果未提供 index，它将从列表中删除最后一项。
 
@@ -161,7 +161,7 @@ print (charList)		# ['a', 'c']
 
 ```
 
-#### 7.3 明确（）
+#### 7.3 明确()
 
 它清空列表。
 
@@ -211,7 +211,7 @@ print (charList)	# ['a', 'b', 'c', 1, 2, 3]
 
 ## 9\. Python 列表方法
 
-#### 9.1 附加（）
+#### 9.1 附加()
 
 在列表的末尾添加一个元素。
 
@@ -224,7 +224,7 @@ print (charList)	# ["a", "b", "c", "d"]
 
 ```
 
-#### 9.2 明确（）
+#### 9.2 明确()
 
 从列表中删除所有元素。
 
@@ -237,7 +237,7 @@ print (charList)	# []
 
 ```
 
-#### 9.3 复制（）
+#### 9.3 复制()
 
 返回列表的副本。
 
@@ -250,7 +250,7 @@ print (newList)	# ["a", "b", "c"]
 
 ```
 
-#### 9.4 计数（）
+#### 9.4 计数()
 
 返回具有指定值的元素数。
 
@@ -263,7 +263,7 @@ print (x)	# 1
 
 ```
 
-#### 9.5 延伸（）
+#### 9.5 延伸()
 
 将列表的元素添加到当前列表的末尾。
 
@@ -277,7 +277,7 @@ print (charList)	# ['a', 'b', 'c', 1, 2, 3]
 
 ```
 
-#### 9.6 指数（）
+#### 9.6 指数()
 
 返回具有指定值的第一个元素的索引。
 
@@ -290,7 +290,7 @@ print (x)	# 0
 
 ```
 
-#### 9.7 插（）
+#### 9.7 插()
 
 在指定位置添加元素。
 
@@ -303,7 +303,7 @@ print (charList)	# ['a', 'b', 'c', 'd']
 
 ```
 
-#### 9.8 pop（）
+#### 9.8 pop()
 
 删除指定位置或列表末尾的元素。
 
@@ -320,7 +320,7 @@ print (charList)		# ['a', 'c']
 
 ```
 
-#### 9.9 去掉（）
+#### 9.9 去掉()
 
 删除具有指定值的项目。
 
@@ -333,7 +333,7 @@ print (charList)		# ['a', 'b', 'c']
 
 ```
 
-#### 9.10 逆转（）
+#### 9.10 逆转()
 
 反转列表中项目的顺序。
 
@@ -346,7 +346,7 @@ print (charList)		# ['d', 'c', 'b', 'a']
 
 ```
 
-#### 9.11 分类（）
+#### 9.11 分类()
 
 默认情况下，以升序对给定列表进行排序。
 

docs/misc2/153.md

@@ -183,7 +183,7 @@ Tuple = ("a", "b", "c")		# Packing
 
 ## 8.命名元组
 
-Python 提供了一种称为**的特殊类型的函数，名称为 tuple（）**，该函数来自`collection`模块。
+Python 提供了一种称为**的特殊类型的函数，名称为 tuple()**，该函数来自`collection`模块。
 
 命名元组类似于字典，但是支持从值和键访问，其中字典仅支持按键访问。
 
@@ -204,7 +204,7 @@ print("Record name is:", R1.name)	# Record name is: My Record
 
 ## 9\. Python 元组方法
 
-#### 9.1 任何（）
+#### 9.1 任何()
 
 如果该元组中至少存在一个元素，则返回`True`；如果该元组为空，则返回`False`。
 
@@ -215,7 +215,7 @@ print( any( (1, 2) ) )	# Regular tuple - True
 
 ```
 
-#### 9.2 分钟（）
+#### 9.2 分钟()
 
 返回元组的最小元素（整数）。
 
@@ -226,7 +226,7 @@ print( min( Tuple ) )	# 1
 
 ```
 
-#### 9.3 max（）
+#### 9.3 max()
 
 返回元组的最大元素（整数）。
 
@@ -237,7 +237,7 @@ print( max( Tuple ) )	# 9
 
 ```
 
-#### 9.4 只要 （）
+#### 9.4 只要 ()
 
 返回元组的长度。
 
@@ -248,7 +248,7 @@ print( len( Tuple ) )	# 5
 
 ```
 
-#### 9.5 和（）
+#### 9.5 和()
 
 返回元组的所有元素（整数）的总和。
 

docs/misc2/154.md

-# Python max（）和 min（）– 在列表或数组中查找最大值和最小值
+# Python max()和 min()– 在列表或数组中查找最大值和最小值
 
 > 原文： [https://howtodoinjava.com/python/max-min/](https://howtodoinjava.com/python/max-min/)
 
-Python 示例使用 **max（）**和 **min（）**方法在可比较元素的集合（例如列表，集合或数组）中找到最大（或最小）的项目。
+Python 示例使用 **max()**和 **min()**方法在可比较元素的集合（例如列表，集合或数组）中找到最大（或最小）的项目。
 
-## 1\. Python max（）函数
+## 1\. Python max()函数
 
 `max()`功能用于：
 
@@ -54,7 +54,7 @@ Python 示例使用 **max（）**和 **min（）**方法在可比较元素的集
 
 ```
 
-## 2\. Python min（）函数
+## 2\. Python min()函数
 
 此功能用于：
 

docs/misc2/155.md

@@ -2,9 +2,9 @@
 
 > 原文： [https://howtodoinjava.com/python/find-largest-smallest-items/](https://howtodoinjava.com/python/find-largest-smallest-items/)
 
-Python 示例使用 **heapq** 库中的 **nlargest（）**和 **nsmallest（）**函数从元素集合中找到最大（或最小）的 N 个元素。
+Python 示例使用 **heapq** 库中的 **nlargest()**和 **nsmallest()**函数从元素集合中找到最大（或最小）的 N 个元素。
 
-## 1.使用 heapq 模块的 nlargest（）和 nsmallest（）
+## 1.使用 heapq 模块的 nlargest()和 nsmallest()
 
 Python `heapq`模块可用于**从集合中找到 N 个最大或最小的项目**。 它具有两个功能来帮助：
 

docs/misc2/156.md

@@ -15,7 +15,7 @@ CSV Dialects
 Custom CSV Dialects
 ```
 
-## 使用 csv.reader（）读取 CSV 文件
+## 使用 csv.reader()读取 CSV 文件
 
 [`csv.reader()`](https://docs.python.org/3/library/csv.html#csv.reader)方法返回一个读取器对象，该对象将遍历给定 CSV 文件中的行。
 
@@ -113,7 +113,7 @@ $ ./read_csv3.py
 
 ```
 
-## 使用 csv.writer（）写入 CSV 文件
+## 使用 csv.writer()写入 CSV 文件
 
 [`csv.writer()`](https://docs.python.org/3/library/csv.html#csv.writer)方法返回一个 writer 对象，该对象负责将用户数据转换为给定文件状对象上的定界字符串。
 

docs/misc2/16.md

@@ -8,7 +8,7 @@
 
 ## 1.序列化设置为 JSON
 
-Java 程序**使用 **Gson.toJson（）**方法将 HashSet 序列化为 JSON** 。
+Java 程序**使用 **Gson.toJson()**方法将 HashSet 序列化为 JSON** 。
 
 ```java
 Set<String> userSet = new HashSet<>();
@@ -33,7 +33,7 @@ System.out.println(jsonString);
 
 ## 2.反序列化 JSON 以进行设置
 
-Java 程序，使用 **Gson.fromJson（）**方法和[`TypeToken`](https://static.javadoc.io/com.google.code.gson/gson/2.8.5/com/google/gson/reflect/TypeToken.html)将 JSON 反序列化为 HashSet 。
+Java 程序，使用 **Gson.fromJson()**方法和[`TypeToken`](https://static.javadoc.io/com.google.code.gson/gson/2.8.5/com/google/gson/reflect/TypeToken.html)将 JSON 反序列化为 HashSet 。
 
 ```java
 import java.lang.reflect.Type;
@@ -54,14 +54,14 @@ System.out.println(userSet);
 
 ```
 
-Program output.
+程序输出：
 
 ```java
 ["Alex","Brian","Charles"]
 
 ```
 
-请问您有关**解析和反序列化 json 以在 Java 中设置**的问题。
+向我提供有关**解析和反序列化 json 以在 Java 中设置**的问题。
 
 学习愉快！
 

docs/misc2/162.md

@@ -18,7 +18,7 @@ set( a.items() ) & set( b.items() )   	# Output set([('y', 2), ('x', 1)])
 
 ```
 
-## 2.设置交集（）方法
+## 2.设置交集()方法
 
 Set `intersection()`方法返回一个 set，该 set 包含 set a 和 set b 中都存在的项。
 

docs/misc2/164.md

@@ -52,7 +52,7 @@ public class RxJava2Example
 
 在代码内部，当从可观察对象发出新单词时，将在每个订阅者上调用`onNext()`方法。 当可观察的单词成功完成或出现错误时，将在订阅者上调用`onComplete()`或`onError()`方法。
 
-## 2\. RxJava 2 依赖性
+## 2\. RxJava 2 依赖项
 
 要将 RxJava 2.0 包含到项目运行时中，可以在给定的 maven 配置，gradle 配置或 jar 文件添加到类路径中进行选择。
 

docs/misc2/165.md

@@ -113,7 +113,7 @@ Servlet 上面没有做一些重要的事情，您可能需要学习。
 2.  覆盖`doGet()`和`doPost()`方法。 这些方法在`HttpServlet`类中定义。 每当 GET 或 POST 请求到来时，都会将其映射到其相应的方法，例如 如果您发送
 3.  对此 Servlet 发出 HTTP GET 请求，然后调用`doGet()`方法。
     还有一些其他有用的方法，您可以重写它们以在运行时控制应用，例如 `getServletInfo()`。
-4.  `HttpServletRequest`和`HttpServletResponse`是所有 doXXX（）方法的默认参数。 我们将在后面的部分中了解有关这些对象的更多信息。
+4.  `HttpServletRequest`和`HttpServletResponse`是所有 doXXX()方法的默认参数。 我们将在后面的部分中了解有关这些对象的更多信息。
 
 这就是您应该知道的简单 servlet 的全部内容。
 
@@ -123,7 +123,7 @@ Servlet 上面没有做一些重要的事情，您可能需要学习。
 
 三种方法对于 Servlet 的生命周期至关重要。 它们是`init()`，`service()`和`destroy()`。 它们由每个 servlet 实现，并在运行时在特定时间调用。
 
-1）在 Servlet 生命周期的初始化阶段， **Web 容器通过调用 init（）方法**并传递实现`javax.servlet.ServletConfig`接口的对象来初始化 Servlet 实例。 此配置对象允许 Servlet 访问 Web 应用的 web.xml 文件中定义的名称 - 值初始化参数。 该**在该 Servlet 实例**的生存期内仅被调用一次。
+1）在 Servlet 生命周期的初始化阶段， **Web 容器通过调用 init()方法**并传递实现`javax.servlet.ServletConfig`接口的对象来初始化 Servlet 实例。 此配置对象允许 Servlet 访问 Web 应用的 web.xml 文件中定义的名称 - 值初始化参数。 该**在该 Servlet 实例**的生存期内仅被调用一次。
 
 初始化方法的定义如下所示：
 
@@ -134,7 +134,7 @@ public void  init() throws ServletException {
 
 ```
 
-2）初始化后，Servlet 实例可以为客户端请求提供服务。 **Web 容器针对每个请求**调用 servlet 的 service（）方法。 `service()`方法确定发出的请求的类型，并将其分派给适当的方法以处理该请求。 Servlet 的开发人员必须提供这些方法的实现。 如果对不是由 Servlet 实现的方法提出了请求，则将调用父类的方法，通常会导致将错误返回给请求者。
+2）初始化后，Servlet 实例可以为客户端请求提供服务。 **Web 容器针对每个请求**调用 servlet 的 service()方法。 `service()`方法确定发出的请求的类型，并将其分派给适当的方法以处理该请求。 Servlet 的开发人员必须提供这些方法的实现。 如果对不是由 Servlet 实现的方法提出了请求，则将调用父类的方法，通常会导致将错误返回给请求者。
 
 几乎在所有情况下都无需覆盖此方法。
 
@@ -200,7 +200,7 @@ if (method.equals(METHOD_GET)) {
 
 ```
 
-3）最后， **Web 容器调用 destroy（）方法，该方法使 Servlet 退出服务**。 如果要在 Servlet 超出范围之前关闭或销毁某些文件系统或网络资源，则应调用此方法。 像 init（）一样，`destroy()`方法在 Servlet 的生命周期中仅被调用一次。
+3）最后， **Web 容器调用 destroy()方法，该方法使 Servlet 退出服务**。 如果要在 Servlet 超出范围之前关闭或销毁某些文件系统或网络资源，则应调用此方法。 像 init()一样，`destroy()`方法在 Servlet 的生命周期中仅被调用一次。
 
 ```java
 public void destroy() {
@@ -392,7 +392,7 @@ protected void doGet(HttpServletRequest request,
 
 若要向容器注册监听器，可以使用以下技术之一：
 
-1）使用`@WebListener`批注。
+1）使用`@WebListener`注解。
 2）在 web.xml 应用部署描述符中注册监听器。
 3）使用在`ServletContext`上定义的`addListener()`方法。
 
@@ -442,7 +442,7 @@ String value = getServletConfig().getInitParameter("name");
 
 Web 过滤器对于预处理请求和访问给定 URL 时调用某些功能很有用。 与其直接调用在给定 URL 上存在的 servlet，否则将在 servlet 之前调用任何包含相同 URL 模式的过滤器。 这在许多情况下可能是有用的，这对于执行日志记录，身份验证或在没有用户交互的情况下在后台进行的其他服务而言可能是最有用的。
 
-过滤器必须实现`javax.servlet.Filter`接口。 此接口中包含的方法包括 **init（），destroy（）和 doFilter（）**。 容器调用 init（）和 destroy（）方法。 doFilter（）方法用于实现过滤器类的任务。 如果要链接过滤器，或者给定 URL 模式存在多个过滤器，则将按照在 web.xml 部署描述符中对其进行配置的顺序来调用它们。
+过滤器必须实现`javax.servlet.Filter`接口。 此接口中包含的方法包括 **init()，destroy()和 doFilter()**。 容器调用 init()和 destroy()方法。 doFilter()方法用于实现过滤器类的任务。 如果要链接过滤器，或者给定 URL 模式存在多个过滤器，则将按照在 web.xml 部署描述符中对其进行配置的顺序来调用它们。
 
 要将 web.xml 文件配置为包含过滤器，请使用<过滤器>和<过滤器映射> XML 元素及其关联的子元素标签。
 
@@ -502,7 +502,7 @@ private void downloadFile(HttpServletRequest request, HttpServletResponse respon
 
 ```
 
-## 使用 RequestDispatcher.forward（）将请求转发到另一个 servlet
+## 使用 RequestDispatcher.forward()将请求转发到另一个 servlet
 
 有时，您的应用要求 servlet 应该将请求移交给其他 servlet，以完成需要完成的任务。 此外，应在不将客户端重定向到另一个 URL 的情况下移交请求，即浏览器中的 URL 不应更改。
 
@@ -514,11 +514,11 @@ rd.forward(request, response);
 
 ```
 
-## 使用 HttpServletResponse.sendRedirect（）将请求重定向到另一个 servlet
+## 使用 HttpServletResponse.sendRedirect()将请求重定向到另一个 servlet
 
 尽管在某些情况下，您不希望像上一节中所看到的那样通知用户 servlet 重定向已发生，但是在某些情况下，我们实际上希望发生这种情况。 当您访问应用中的特定 URL 时，您想将浏览器重定向到另一个 URL。
 
-为此，您将需要调用`HttpServletResponse`对象的 sendRedirect（）方法。
+为此，您将需要调用`HttpServletResponse`对象的 sendRedirect()方法。
 
 ```java
 httpServletResponse.sendRedirect("/anotherURL");
@@ -543,7 +543,7 @@ response.addCookie(cookie);
 
 ```
 
-这里的响应是传递给 *doXXX（）*方法的`HttpServletResponse`的实例。
+这里的响应是传递给 *doXXX()*方法的`HttpServletResponse`的实例。
 
 要回读服务器父项上的 cookie 信息，请使用以下代码：
 

docs/misc2/169.md

@@ -34,7 +34,7 @@ Vaadin text field label
     final TextField txtFldOne = new TextField("Type your name here:");
     ```
 
-2.  #### 使用 setCaption（）方法设置文本字段标签
+2.  #### 使用 setCaption()方法设置文本字段标签
 
     ```java
     final TextField txtFldOne = new TextField();

docs/misc2/17.md

@@ -8,7 +8,7 @@
 
 ## 1.将包含通用类型的 HashMap 序列化为 JSON
 
-使用 Gson 将哈希图序列化为 JSON 很容易。 转换 HashMap 之后，只需使用 **gson.toJson（）**方法即可获取 JSON 字符串。
+使用 Gson 将哈希图序列化为 JSON 很容易。 转换 HashMap 之后，只需使用 **gson.toJson()**方法即可获取 JSON 字符串。
 
 使用 Gson 将 HashMap 转换为 JSON 字符串的 Java 程序。
 
@@ -86,7 +86,7 @@ public class Employee implements Comparable<Employee>{
 要将 JSON 字符串反序列化回 HashMap 涉及两个步骤：
 
 1.  创建代表通用类型的[`com.google.gson.reflect.TypeToken`](https://static.javadoc.io/com.google.code.gson/gson/2.6.2/com/google/gson/reflect/TypeToken.html)。 它强制客户端创建此类的子类，即使在运行时也可以检索类型信息。
-2.  使用 **gson.fromJson（）**方法从 JSON 字符串获取 HashMap。
+2.  使用 **gson.fromJson()**方法从 JSON 字符串获取 HashMap。
 
 Java 程序将 JSON 解析为包含通用类型的 HashMap 对象。
 

docs/misc2/177.md

@@ -4,7 +4,7 @@
 
 在我以前的文章中，我写了许多关于 [**JAX-RS RESTEasy**](//howtodoinjava.com/restful-web-service/ "RESTful Web services Tutorials") ， [**Spring3**](//howtodoinjava.com "Spring3 Tutorials") ， [**的示例和教程 ] Hibernate**](//howtodoinjava.com/hibernate-tutorials/ "Hibernate Tutorials") 和其他 Java 框架，例如 [**专家**](//howtodoinjava.com/maven/ "Maven Tutorials") 或 [**junit** **4**](//howtodoinjava.com/junit/ "JUnit Tutorials") 。 我还在与 [**Struts 2 hello world 和 xml 配置**](//howtodoinjava.com/struts-2/struts-2-hello-world-example-application/ "Struts 2 hello world example application") 相关的帖子中写道。 在本文中，我将更新先前的示例，以使用注释来配置 struts 2 应用。
 
-有关信息，struts 批注是 [**struts 常规插件**](https://struts.apache.org/docs/convention-plugin.html "struts 2 convention plugin") 的一部分。
+有关信息，struts 注解是 [**struts 常规插件**](https://struts.apache.org/docs/convention-plugin.html "struts 2 convention plugin") 的一部分。
 
 ```java
 Sections in this post: 

docs/misc2/179.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://howtodoinjava.com/struts2/how-to-correctly-set-result-path-in-struts-2/](https://howtodoinjava.com/struts2/how-to-correctly-set-result-path-in-struts-2/)
 
-在这里，结果路径表示 Struts 2 在执行 Action 类中的代码后将解析的 JSP 文件或其他视图文件的位置。 这些**结果路径在 Action 类顶部的@Result 批注**的“位置”中提到。
+在这里，结果路径表示 Struts 2 在执行 Action 类中的代码后将解析的 JSP 文件或其他视图文件的位置。 这些**结果路径在 Action 类顶部的@Result 注解**的“位置”中提到。
 
 一旦动作类完成执行，它将把控件传递给视图解析器。 视图解析器尝试查找需要渲染的视图文件的位置。 该解决方案主要可以通过两种方式提及：
 
@@ -54,7 +54,7 @@ Above definition will resolve the location of jsp file as ::
 
 ```
 
-**原因：**背后的原因是，开始时的**“ /”在项目根**处解析，而其余路径在项目根目录下解析。 但是，当**不在开始时使用“ /”时，默认的根目录假定为“ / WEB-INF / content”文件夹**，其余的路径与此相对。 因此，当您下次注意时，请在@Result 批注中指定 location 属性。
+**原因：**背后的原因是，开始时的**“ /”在项目根**处解析，而其余路径在项目根目录下解析。 但是，当**不在开始时使用“ /”时，默认的根目录假定为“ / WEB-INF / content”文件夹**，其余的路径与此相对。 因此，当您下次注意时，请在@Result 注解中指定 location 属性。
 
 ## 2）将资源根路径定义为常量“ struts.convention.result.path”
 

docs/misc2/18.md

@@ -11,7 +11,7 @@ Gson gson = new GsonBuilder().create();
 
 ```
 
-## 1\. GsonBuilder.setPrettyPrinting（）– 漂亮的打印 JSON
+## 1\. GsonBuilder.setPrettyPrinting()– 漂亮的打印 JSON
 
 默认情况下，Gson 将创建缩小的 JSON 字符串。 这对于减少通过网络传输的数据量非常重要。
 
@@ -138,9 +138,9 @@ Gson 将确保在将 Java 字段名称的第一个“字母”序列化为 JSON
 
 ```
 
-## 3\. GsonBuilder.serializeNulls（）– 空值的序列化
+## 3\. GsonBuilder.serializeNulls()– 空值的序列化
 
-默认情况下，Gson 在序列化过程中会忽略`null`属性。 但是，有时我们想序列化具有空值的字段，以便它必须出现在 JSON 中。 为此，请使用 **serializeNulls（）**方法。
+默认情况下，Gson 在序列化过程中会忽略`null`属性。 但是，有时我们想序列化具有空值的字段，以便它必须出现在 JSON 中。 为此，请使用 **serializeNulls()**方法。
 
 ```java
 Employee employeeObj = new Employee(1, "Lokesh", "Gupta", null);
@@ -165,7 +165,7 @@ System.out.println(gson.toJson(employeeObj));
 
 ```
 
-## 4\. GsonBuilder.setExclusionStrategies（）
+## 4\. GsonBuilder.setExclusionStrategies()
 
 [**ExclusionStrategy**](https://static.javadoc.io/com.google.code.gson/gson/2.8.2/com/google/gson/ExclusionStrategy.html) 用于确定是否应序列化或反序列化字段或顶级类作为 JSON 输出/输入的一部分。
 
@@ -195,7 +195,7 @@ Gson gson = new GsonBuilder()
 
 ```
 
-## 5\. GsonBuilder.setLenient（）– 宽松的 JSON 语法规则
+## 5\. GsonBuilder.setLenient()– 宽松的 JSON 语法规则
 
 在反序列化期间，Gson 使用了一个不太宽大的 *JsonReader* 类。 这意味着它仅接受兼容的 JSON 输入。 如果 JSON 违反结构规则之一，它将抛出 **MalformedJsonException** 。
 

docs/misc2/180.md

@@ -576,7 +576,7 @@ log4j.appender.R.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
 
 #### c）交易
 
-EmployeeManagerImpl.java 在诸如 getAllEmployees（）和 deleteEmployee（）之类的方法中使用注解@Transactional。 这实际上是在单个事务中运行在此方法下执行的所有数据库查询。 像这样在`beans.xml`上下文文件中声明了事务依赖性。
+EmployeeManagerImpl.java 在诸如 getAllEmployees()和 deleteEmployee()之类的方法中使用注解@Transactional。 这实际上是在单个事务中运行在此方法下执行的所有数据库查询。 像这样在`beans.xml`上下文文件中声明了事务依赖项。
 
 ```java
 <!-- Run SQL queries in transactions -->

docs/misc2/184.md

@@ -2,12 +2,12 @@
 
 > 原文： [https://howtodoinjava.com/data-structure/java-stack-implementation-array/](https://howtodoinjava.com/data-structure/java-stack-implementation-array/)
 
-本教程给出了**使用数组**实现[堆栈](https://en.wikipedia.org/wiki/Stack_(abstract_data_type))数据结构的示例。 堆栈提供了将新对象放入堆栈（方法 push（））并从堆栈中获取对象（方法 pop（））。 堆栈根据后进先出（LIFO）返回对象。 请注意，JDK 提供了默认的 Java 堆栈实现作为类`java.util.Stack`。
+本教程给出了**使用数组**实现[堆栈](https://en.wikipedia.org/wiki/Stack_(abstract_data_type))数据结构的示例。 堆栈提供了将新对象放入堆栈（方法 push()）并从堆栈中获取对象（方法 pop()）。 堆栈根据后进先出（LIFO）返回对象。 请注意，JDK 提供了默认的 Java 堆栈实现作为类`java.util.Stack`。
 
 适用于所有堆栈实现的两个强制操作是：
 
-*   **push（）**：将数据项放置在堆栈指针指向的位置。
-*   **pop（）**：在其中删除数据项并从堆栈指针指向的位置返回该数据项。
+*   **push()**：将数据项放置在堆栈指针指向的位置。
+*   **pop()**：在其中删除数据项并从堆栈指针指向的位置返回该数据项。
 
 某些严重依赖堆栈的环境可能会根据要求提供其他操作。 Stack 最常见的用法是表达式求值和语法解析。 您也可以在文字处理器的撤消/重做操作中找到它们。
 

docs/misc2/19.md

@@ -8,7 +8,7 @@ Gson 会忽略 null 字段，因为此行为允许使用更紧凑的 JSON 输出
 
 ## 1.如何在序列化期间允许空值
 
-要配置 Gson 实例以输出`null`，我们必须使用[`GsonBuilder`](https://howtodoinjava.com/gson/gson-gsonbuilder-configuration/)对象的 **serializeNulls（）**。
+要配置 Gson 实例以输出`null`，我们必须使用[`GsonBuilder`](https://howtodoinjava.com/gson/gson-gsonbuilder-configuration/)对象的 **serializeNulls()**。
 
 ```java
 Gson gson = new GsonBuilder()
@@ -84,7 +84,7 @@ System.out.println(gson.toJson(employeeObj));
 
 ```
 
-显然`null`字段已在 JSON 输出中序列化。 请问您有关此 *Gson 序列化 NULL 值*文章的问题。
+显然`null`字段已在 JSON 输出中序列化。 向我提供有关此 *Gson 序列化 NULL 值*文章的问题。
 
 学习愉快！
 

docs/misc2/193.md

@@ -8,7 +8,7 @@
 
 ## 1\. Java 回文字符串示例
 
-要检查**回文字符串**，请反转[字符串](https://howtodoinjava.com/java-string/)字符。 现在使用 **String.equals（）**方法来验证给定的字符串是否是回文。
+要检查**回文字符串**，请反转[字符串](https://howtodoinjava.com/java-string/)字符。 现在使用 **String.equals()**方法来验证给定的字符串是否是回文。
 
 #### 1.1 使用 Apache Commons StringUtils 检查字符串回文
 
@@ -56,7 +56,7 @@ public class Main
 
 #### 1.3 用 for 循环检查字符串回文
 
-将[用于循环](https://howtodoinjava.com/java/basics/for-loop-in-java/)，以使用 [charAt（）](https://howtodoinjava.com/java/string/string-charat-method-example/)方法遍历最后一个索引的字符串字符来获取**反向字符串**，并创建新字符串。
+将[用于循环](https://howtodoinjava.com/java/basics/for-loop-in-java/)，以使用 [charAt()](https://howtodoinjava.com/java/string/string-charat-method-example/)方法遍历最后一个索引的字符串字符来获取**反向字符串**，并创建新字符串。
 
 仅当您在 Java 中检查**字符串回文而不使用反向方法**时，才使用此方法。
 
@@ -136,7 +136,7 @@ public class PalindromeTest
     }
 }
 
-Program Output.
+程序输出：
 
 false
 true

docs/misc2/20.md

@@ -47,7 +47,7 @@ public class Employee
 
 #### 2.2 创建具有版本支持的 Gson 实例
 
-要创建将使用@Since 批注的`Gson`实例，请使用 **GsonBuilder.setVersion（）**方法。
+要创建将使用@Since 注解的`Gson`实例，请使用 **GsonBuilder.setVersion()**方法。
 
 ```java
 Gson gson = new GsonBuilder()
@@ -58,7 +58,7 @@ Gson gson = new GsonBuilder()
 
 ## 3.演示
 
-`@Since`批注*会影响*的序列化和反序列化，因此请务必谨慎使用。
+`@Since`注解*会影响*的序列化和反序列化，因此请务必谨慎使用。
 
 #### 3.1 具有版本支持的序列化
 

docs/misc2/201.md

@@ -21,7 +21,7 @@ YES
 NO
 ```
 
-## 使用 for 循环和 indexOf（）的解决方案
+## 使用 for 循环和 indexOf()的解决方案
 
 我写了一个快速的功能，可以找到这个完整的字符串。
 

docs/misc2/202.md

@@ -62,5 +62,5 @@ practices coding and concepts java smart for blog technology Java
 
 参考：
 
-[StringBuilder.reverse（）Java 文档](https://docs.oracle.com/javase/8/docs/api/java/lang/StringBuilder.html#reverse--)
+[StringBuilder.reverse()Java 文档](https://docs.oracle.com/javase/8/docs/api/java/lang/StringBuilder.html#reverse--)
 [StringTokenizer](https://docs.oracle.com/javase/8/docs/api/java/util/StringTokenizer.html)
\ No newline at end of file

docs/misc2/206.md

@@ -17,7 +17,7 @@ Using reflection
 
 > **注意：**在给定的示例中，我仅在编写伪代码。 要构建完整的，可以正常工作的示例代码，请阅读相关功能。
 
-## 使用 Class.newInstance（）创建对象
+## 使用 Class.newInstance()创建对象
 
 ```java
 Class ref = Class.forName("DemoClass");
@@ -26,7 +26,7 @@ DemoClass obj = (DemoClass) ref.newInstance();
 
 `Class.forName()`将类加载到内存中。 要创建此类的实例，我们需要使用`newInstance()`。
 
-## 使用类加载器的 loadClass（）创建对象
+## 使用类加载器的 loadClass()创建对象
 
 就像上述方法一样，类加载器的`loadClass()`方法执行相同的操作。 它使用相同类的现有实例创建类的新实例。
 
@@ -34,7 +34,7 @@ DemoClass obj = (DemoClass) ref.newInstance();
 instance.getClass().getClassLoader().loadClass("NewClass").newInstance();
 ```
 
-## 使用 Object.clone（）创建对象
+## 使用 Object.clone()创建对象
 
 这也是拥有新的类的独立实例的方法。
 
@@ -56,8 +56,8 @@ ObjectInputStream objStream = new ObjectInputStream(inputStream);
 
 反射也是在大多数可用框架中创建新实例的流行方法。
 
-builder.newInstance（）; 或
-class.newInstance（）;
+builder.newInstance(); 或
+class.newInstance();
 
 如果您认为我没有其他可能的方法，请告诉我。
 

docs/misc2/208.md

@@ -30,8 +30,8 @@
 
 *   HashMap 如何存储键值对？
 *   HashMap 如何解决冲突？
-*   HashMap 中如何使用 hashCode（）和 equals（）方法？
-*   密钥的随机/固定 hashCode（）值的影响？
+*   HashMap 中如何使用 hashCode()和 equals()方法？
+*   密钥的随机/固定 hashCode()值的影响？
 *   在多线程环境中使用 HashMap？
 
 #### 1.4 [为 HashMap 设计一个好的密钥](//howtodoinjava.com/java/collections/how-to-design-a-good-key-for-hashmap/)
@@ -40,7 +40,7 @@
 
 *   为什么`String`是 HashMap 的好钥匙？
 *   您将如何设计用作键的类？
-*   您将重写 Key 类中的 hashCode（）方法吗？ 有什么影响？
+*   您将重写 Key 类中的 hashCode()方法吗？ 有什么影响？
 *   为可以作为 HashMap 关键对象的类编写语法？
 
 #### 1.5 [关于 ConcurrentHashMap](//howtodoinjava.com/tag/concurrenthashmap/ "concurrenthashmap") 的问题
@@ -131,7 +131,7 @@ HashMap 不是线程安全的。 我们可以在并发应用中使用 **HashTabl
 
 Java 中的对象**克隆**并非易事。 我自己花了很长时间了解 Java 的克隆。 看起来真的很简单； 使用`Cloneable`界面并覆盖`clone()`方法。 可是等等; 在面试中还有很多要说的和要问的。 例如
 
-*   clone（）方法如何工作？
+*   clone()方法如何工作？
 *   Java 中的浅表复制是什么？
 *   什么是复制构造函数？
 *   Java 中的深层复制是什么？
@@ -277,7 +277,7 @@ Spring **AOP** （面向方面​​的编程）在某种意义上补充了 OOP
 *   如何使用基于 Java 的配置？
 *   我们如何使用 Spring 创建返回 JSON 响应的 Restful Web Service？
 *   < context：annotation-config >与< context：component-scan >之间的区别？
-*   @ Component，@ Controller，@ Repository & @Service 批注之间的区别？
+*   @ Component，@ Controller，@ Repository & @Service 注解之间的区别？
 *   Spring MVC 如何提供验证支持？
 *   什么是 Spring MVC 拦截器以及如何使用？
 *   如何在 Spring MVC Framework 中处理异常？
@@ -295,10 +295,10 @@ Spring **AOP** （面向方面​​的编程）在某种意义上补充了 OOP
 *   Java 的扩大和缩小？
 *   我只能试一下代码块吗？
 *   线程：生产者和消费者有问题吗？
-*   为什么在 Object 类中定义了 wait（），notify（）和 notifyAll（）？
-*   我们可以覆盖 wait（）或 notify（）方法吗？
-*   wait（），sleep（）和 yield（）之间的区别？
-*   解释一下线程类中的 join（）方法？
+*   为什么在 Object 类中定义了 wait()，notify()和 notifyAll()？
+*   我们可以覆盖 wait()或 notify()方法吗？
+*   wait()，sleep()和 yield()之间的区别？
+*   解释一下线程类中的 join()方法？
 *   您是否遇到了内存不足错误？ 如果是，您如何解决？ 告诉不同的情况为什么会这样？
 *   数据库连接泄漏？
 *   编写程序以使用第三个变量交换两个数字？

docs/misc2/21.md

@@ -6,11 +6,11 @@
 
 ## 1\. @SerializedName
 
-默认情况下，我们假设 Java 模型类和 JSON 将具有完全相同的字段名称。 但有时情况并非如此，某些名称有所不同。 现在我们必须将 json 中的`someName`映射到 Java 类中的`someOtherName`。 这是[`@SerializedName`](https://static.javadoc.io/com.google.code.gson/gson/2.8.5/com/google/gson/annotations/SerializedName.html)批注提供帮助的地方。
+默认情况下，我们假设 Java 模型类和 JSON 将具有完全相同的字段名称。 但有时情况并非如此，某些名称有所不同。 现在我们必须将 json 中的`someName`映射到 Java 类中的`someOtherName`。 这是[`@SerializedName`](https://static.javadoc.io/com.google.code.gson/gson/2.8.5/com/google/gson/annotations/SerializedName.html)注解提供帮助的地方。
 
-*@SerializedName* 批注指示应将带注释的成员序列化为 JSON，并使用提供的名称值作为其字段名称。 此注释将覆盖可能已经使用`GsonBuilder`类的所有[`FieldNamingPolicy`](https://static.javadoc.io/com.google.code.gson/gson/2.8.5/com/google/gson/FieldNamingPolicy.html)，包括默认字段命名策略。
+*@SerializedName* 注解指示应将带注释的成员序列化为 JSON，并使用提供的名称值作为其字段名称。 此注释将覆盖可能已经使用`GsonBuilder`类的所有[`FieldNamingPolicy`](https://static.javadoc.io/com.google.code.gson/gson/2.8.5/com/google/gson/FieldNamingPolicy.html)，包括默认字段命名策略。
 
-请注意，您在此批注中指定的值必须是有效的 JSON 字段名称。
+请注意，您在此注解中指定的值必须是有效的 JSON 字段名称。
 
 #### 1.1 注释属性
 
@@ -91,7 +91,7 @@ System.out.println(emp);
 
 ```
 
-Program output.
+程序输出：
 
 ```java
 Employee [id=1001, firstName=Lokesh, lastName=Gupta, email=admin@gmail.com]
@@ -100,6 +100,6 @@ Employee [id=1001, firstName=Lokesh, lastName=Gupta, email=admin@gmail.com]
 
 注意程序输出。 我们在*电子邮件*字段（即`email`和`emailAddress`）中有两个匹配项。 最后一次出现是`"emailAddress"`，因此它的值已填充到 Employee 对象中。
 
-让我问一下与**使用 Gson **@SerializedName** 批注将多个不同名称映射到 Java 类**中的成员字段有关的问题。
+让我问一下与**使用 Gson **@SerializedName** 注解将多个不同名称映射到 Java 类**中的成员字段有关的问题。
 
 学习愉快！
\ No newline at end of file

docs/misc2/210.md

@@ -106,11 +106,11 @@ str.intern();
 
 ```
 
-因此，对于`s`和`t`中的任何两个字符串，当且仅当`s.equals(t)`为`true`时，`s.intern() == t.intern()`才为`true`。 意味着如果 s 和 t 都是不同的字符串对象，并且具有相同的字符序列，则在这两个变量上调用 intern（）将导致两个变量引用的单个字符串池文字。
+因此，对于`s`和`t`中的任何两个字符串，当且仅当`s.equals(t)`为`true`时，`s.intern() == t.intern()`才为`true`。 意味着如果 s 和 t 都是不同的字符串对象，并且具有相同的字符序列，则在这两个变量上调用 intern()将导致两个变量引用的单个字符串池文字。
 
 ## 5.匹配正则表达式
 
-如果您还没有探索的话，它并不是那么秘密，但很有用。 您必须已经看到[模式](https://docs.oracle.com/javase/6/docs/api/java/util/regex/Pattern.html "java util  Pattern")和 Matcher 用于正则表达式匹配的用法。 字符串类提供了自己的快捷方式。 直接使用。 此方法还使用函数定义内的 *Pattern.matches（）*。
+如果您还没有探索的话，它并不是那么秘密，但很有用。 您必须已经看到[模式](https://docs.oracle.com/javase/6/docs/api/java/util/regex/Pattern.html "java util  Pattern")和 Matcher 用于正则表达式匹配的用法。 字符串类提供了自己的快捷方式。 直接使用。 此方法还使用函数定义内的 *Pattern.matches()*。
 
 ```java
 
@@ -120,12 +120,12 @@ str.matches("<regex>");
 
 ```
 
-## 6.使用 equals（）和'=='进行字符串比较
+## 6.使用 equals()和'=='进行字符串比较
 
 采访中另一个最喜欢的领域。 通常有两种比较对象的方法
 
 *   使用==运算符
-*   使用 equals（）方法
+*   使用 equals()方法
 
 **`==`运算符比较对象引用**，即内存地址相等性。 因此，如果两个字符串对象引用字符串池中的相同文字或堆中的相同字符串对象，则`s==t`将返回`true`，否则返回`false`。
 

docs/misc2/211.md

@@ -82,7 +82,7 @@ Java 规范说 Java 中的 ***都是按值传递*** 。 在 Java 中，没有“
 
 标记接口的*主要问题*是，接口定义用于实现类的协定，并且该协定被所有子类继承。 这意味着**您不能“取消实现”标记**。 在给定的示例中，如果创建不想序列化的子类（可能是因为它依赖于瞬态），则必须诉诸显式抛出 NotSerializableException。
 
-## **为什么将 Java 中的 main（）声明为 public static void？**
+## **为什么将 Java 中的 main()声明为 public static void？**
 
 ***为什么公开*？** 的主要方法是`public`，因此它可以在任何地方访问，并且对于可能希望使用它启动应用的每个对象都可以访问。 在这里，我并不是说 JDK / JRE 具有类似的原因，因为 java.exe 或 javaw.exe（对于 Windows）使用 Java 本机接口（JNI）调用来调用方法，因此，无论使用哪种访问修饰符，他们都可以通过任何一种方式来调用它。 。
 
@@ -90,13 +90,13 @@ Java 规范说 Java 中的 ***都是按值传递*** 。 在 Java 中，没有“
 
 ***为什么无效*？** 因此，没有任何将值返回给实际调用此方法的 JVM 的用途。 应用唯一想与调用过程进行通信的是：正常终止或异常终止。 使用`System.exit(int)`已经可以实现。 非零值表示异常终止，否则一切正常。
 
-## **将 String 创建为 new（）和文字之间有什么区别？**
+## **将 String 创建为 new()和文字之间有什么区别？**
 
 当我们使用`new()`创建`String`时，它会在堆中创建并添加到字符串池中，而使用文字创建的`String`仅在字符串池中创建，而字符串池仅存在于堆的 Perm 区域中。
 
 那么，您真的需要非常深入地了解字符串池的概念，才能回答此问题或类似问题。 我的建议..关于[字符串类和字符串池](//howtodoinjava.com/java/string/interview-stuff-about-string-class-in-java/ "String pool concepts")的“认真学习”。
 
-## **String 中的 substring（）如何工作？**
+## **String 中的 substring()如何工作？**
 
 Java 中的`String`与其他任何编程语言一样，都是字符序列。 这更像是用于该 char 序列的实用程序类。 此 char 序列在以下变量中维护：
 
@@ -156,10 +156,10 @@ final int hash;
 *   默认情况下，Java 接口的成员是公共的。 Java 抽象类可以具有类成员通常的风格，例如`private`或`abstract`等。
 *   Java 接口应使用关键字“ **实现**”实现； Java 抽象类应使用关键字“ **extended** ”来扩展。
 *   Java 类可以实现多个接口，但只能扩展一个抽象类。
-*   接口是~~的绝对抽象，~~不能实例化； Java 抽象类也无法实例化，但是可以在存在 main（）的情况下调用。 从 Java 8 开始，您可以在接口 中定义 [**默认方法。**](//howtodoinjava.com/java8/default-methods-in-java-8/)
+*   接口是~~的绝对抽象，~~不能实例化； Java 抽象类也无法实例化，但是可以在存在 main()的情况下调用。 从 Java 8 开始，您可以在接口 中定义 [**默认方法。**](//howtodoinjava.com/java8/default-methods-in-java-8/)
 *   抽象类比接口要快一些，因为接口涉及在 Java 中调用任何重写方法之前进行的搜索。 在大多数情况下，这并不是显着的差异，但是如果您正在编写时间紧迫的应用，那么您可能不想无所事事。
 
-## **何时覆盖 hashCode（）和 equals（）？**
+## **何时覆盖 hashCode()和 equals()？**
 
 `hashCode()`和`equals()`方法已在`Object`类中定义，该类是 Java 对象的父类。 因此，所有 java 对象都继承这些方法的默认实现。
 

docs/misc2/212.md

@@ -17,11 +17,11 @@ Explain transient and volatile keywords in java?
 Difference between Iterator and ListIterator?
 ```
 
-## 为什么要避免使用 finalize（）方法？
+## 为什么要避免使用 finalize()方法？
 
 我们都知道，在回收分配给对象的内存之前，垃圾收集器线程会调用[`finalize()`](https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#finalize--)方法的基本声明。 请参阅此程序的[，该程序证明根本不能保证`finalize()`调用。 其他原因可能是：](//howtodoinjava.com/java/related-concepts/why-not-to-use-finalize-method-in-java/ "Why not to use finalize() method in java")
 
-1.  `finalize()`方法无法像构造函数一样在链接中工作。 这意味着就像您调用构造函数时一样，所有超类的构造函数都将被隐式调用。 但是，在使用 finalize 方法的情况下，则不遵循此方法。 超级类的 finalize（）应该显式调用。
+1.  `finalize()`方法无法像构造函数一样在链接中工作。 这意味着就像您调用构造函数时一样，所有超类的构造函数都将被隐式调用。 但是，在使用 finalize 方法的情况下，则不遵循此方法。 超级类的 finalize()应该显式调用。
 2.  由 finalize 方法引发的任何异常都将被 GC 线程忽略，并且不会进一步传播，实际上不会记录在日志文件中。 真糟糕，不是吗？
 3.  Also, There is some performance penalty when finalize() in included in your class. In Effective java (2nd edition ) Joshua bloch says,
 
@@ -129,7 +129,7 @@ Java 基于 [Hoare](https://en.wikipedia.org/wiki/Tony_Hoare) 的监视器概念
 – 线程
 – 监视器（任何对象）
 
-在 Java 设计中，无法指定线程，它始终是当前运行代码的线程。 但是，我们可以指定监视器（这是我们称为 wait 的对象）。 这是一个很好的设计，因为如果我们可以让任何其他线程在所需的监视器上等待，则会导致“入侵”，给设计/编程并发程序带来了困难。 请记住，在 Java 中，不推荐使用会干扰另一个线程执行的所有操作（例如 stop（））。
+在 Java 设计中，无法指定线程，它始终是当前运行代码的线程。 但是，我们可以指定监视器（这是我们称为 wait 的对象）。 这是一个很好的设计，因为如果我们可以让任何其他线程在所需的监视器上等待，则会导致“入侵”，给设计/编程并发程序带来了困难。 请记住，在 Java 中，不推荐使用会干扰另一个线程执行的所有操作（例如 stop()）。
 
 ## 编写 Java 程序以在 Java 中创建死锁并修复死锁？
 

docs/misc2/213.md

@@ -19,9 +19,9 @@ Deep copy and shallow copy?
 
 ## **深拷贝和浅拷贝？**
 
-克隆是原始副本的精确副本。 在 Java 中，它实质上意味着能够创建状态与原始对象相似的对象。 clone（）方法提供了此功能。
+克隆是原始副本的精确副本。 在 Java 中，它实质上意味着能够创建状态与原始对象相似的对象。 clone()方法提供了此功能。
 
-浅拷贝应尽可能少地重复。 默认情况下，Java 克隆是浅表复制或“逐字段复制”，即，由于 Object 类不了解将在其上调用 clone（）方法的类的结构。 因此，JVM 被要求克隆时，请执行以下操作：
+浅拷贝应尽可能少地重复。 默认情况下，Java 克隆是浅表复制或“逐字段复制”，即，由于 Object 类不了解将在其上调用 clone()方法的类的结构。 因此，JVM 被要求克隆时，请执行以下操作：
 
 1）如果该类只有原始数据类型成员，则将创建该对象的全新副本，并返回对该新对象副本的引用。
 
@@ -32,7 +32,7 @@ Deep copy and shallow copy?
 *深度克隆要求满足以下规则。*
 
 1.  无需单独复制基元。
-2.  原始类中的所有成员类都应支持克隆，而上下文中原始类的 clone 方法应在所有成员类上调用 super.clone（）。
+2.  原始类中的所有成员类都应支持克隆，而上下文中原始类的 clone 方法应在所有成员类上调用 super.clone()。
 3.  如果任何成员类不支持克隆，则必须在克隆方法中创建该成员类的新实例，并将其所有属性一一复制到新的成员类对象中。 这个新的成员类对象将在克隆对象中设置。
 
 [在此处详细了解克隆](//howtodoinjava.com/java/cloning/a-guide-to-object-cloning-in-java/ "A guide to object cloning in java")。
@@ -45,19 +45,19 @@ Java 中的同步是使用 synced 关键字实现的。 您可以在类中的已
 
 ***对象级别锁定*** 是一种机制，当您要同步非静态方法或非静态代码块，以便仅一个线程将能够在给定实例的代码上执行代码块时， 班级。 应该始终这样做以确保实例级数据线程安全。
 
-***类级别锁定*** 可防止多个线程在运行时进入所有可用实例中的任何同步块。 这意味着，如果在运行时有 100 个 DemoClass 实例，则一次只能在一个实例中的任何一个线程上执行 demoMethod（），而所有其他实例将被其他线程锁定。 为了确保静态数据线程的安全，应该始终这样做。
+***类级别锁定*** 可防止多个线程在运行时进入所有可用实例中的任何同步块。 这意味着，如果在运行时有 100 个 DemoClass 实例，则一次只能在一个实例中的任何一个线程上执行 demoMethod()，而所有其他实例将被其他线程锁定。 为了确保静态数据线程的安全，应该始终这样做。
 
 [在此处了解有关同步的更多信息。](//howtodoinjava.com/java/multi-threading/thread-synchronization-object-level-locking-and-class-level-locking/ "Thread synchronization, object level locking and class level locking")
 
-## **sleep（）和 wait（）之间的区别？**
+## **sleep()和 wait()之间的区别？**
 
-sleep（）是一种用于将进程保留几秒钟或所需时间的方法，但是如果使用 wait（）方法，线程将进入等待状态，直到我们调用 notify（）或 notifyAll（）。
+sleep()是一种用于将进程保留几秒钟或所需时间的方法，但是如果使用 wait()方法，线程将进入等待状态，直到我们调用 notify()或 notifyAll()。
 
-主要区别在于，wait（）释放锁定或监视器，而 sleep（）不在等待期间释放任何锁或监视器。 通常，“等待”用于线程间通信，而“睡眠”用于引入执行暂停。
+主要区别在于，wait()释放锁定或监视器，而 sleep()不在等待期间释放任何锁或监视器。 通常，“等待”用于线程间通信，而“睡眠”用于引入执行暂停。
 
-Thread.sleep（）在一段时间内将当前线程发送到“不可运行”状态。 该线程将保留其已获取的监视器 - 即，如果该线程当前处于同步块或方法中，则其他线程无法进入该块或方法。 如果另一个线程调用 t.interrupt（），它将唤醒睡眠线程。 请注意，sleep 是一种静态方法，这意味着它始终会影响当前线程（正在执行 sleep 方法的线程）。 一个常见的错误是调用 t.sleep（），其中 t 是一个不同的线程。 即使这样，当前线程仍将休眠，而不是 t 线程。
+Thread.sleep()在一段时间内将当前线程发送到“不可运行”状态。 该线程将保留其已获取的监视器 - 即，如果该线程当前处于同步块或方法中，则其他线程无法进入该块或方法。 如果另一个线程调用 t.interrupt()，它将唤醒睡眠线程。 请注意，sleep 是一种静态方法，这意味着它始终会影响当前线程（正在执行 sleep 方法的线程）。 一个常见的错误是调用 t.sleep()，其中 t 是一个不同的线程。 即使这样，当前线程仍将休眠，而不是 t 线程。
 
-object.wait（）将当前线程发送到“ Not Runnable”状态，就像 sleep（）一样，但要稍加调整。 Wait 是在对象而不是线程上调用的； 我们将此对象称为“锁定对象”。 在调用 lock.wait（）之前，当前线程必须在锁对象上进行同步。 然后，wait（）释放此锁定，并将线程添加到与该锁定关联的“等待列表”。 稍后，另一个线程可以在同一个锁对象上同步并调用 lock.notify（）。 这将唤醒原始的等待线程。 基本上，wait（）/ notify（）就像 sleep（）/ interrupt（）一样，仅活动线程不需要直接指针指向睡眠线程，而仅需要指向共享锁对象的指针。
+object.wait()将当前线程发送到“ Not Runnable”状态，就像 sleep()一样，但要稍加调整。 Wait 是在对象而不是线程上调用的； 我们将此对象称为“锁定对象”。 在调用 lock.wait()之前，当前线程必须在锁对象上进行同步。 然后，wait()释放此锁定，并将线程添加到与该锁定关联的“等待列表”。 稍后，另一个线程可以在同一个锁对象上同步并调用 lock.notify()。 这将唤醒原始的等待线程。 基本上，wait()/ notify()就像 sleep()/ interrupt()一样，仅活动线程不需要直接指针指向睡眠线程，而仅需要指向共享锁对象的指针。
 
 [在此处详细阅读区别。](//howtodoinjava.com/java/multi-threading/difference-between-sleep-and-wait/ "Difference between sleep() and wait()?")
 
@@ -76,19 +76,19 @@ object.wait（）将当前线程发送到“ Not Runnable”状态，就像 slee
 
 [请阅读此处以深入了解。](https://en.wikipedia.org/wiki/Bitwise_operation "bitwise operations")
 
-## **如何覆盖 equals 和 hashCode（）方法？**
+## **如何覆盖 equals 和 hashCode()方法？**
 
-hashCode（）和 equals（）方法已在 Object 类中定义，Object 类是 Java 对象的父类。 因此，所有 java 对象都继承这些方法的默认实现。
+hashCode()和 equals()方法已在 Object 类中定义，Object 类是 Java 对象的父类。 因此，所有 java 对象都继承这些方法的默认实现。
 
-hashCode（）方法用于获取给定对象的唯一整数。 当此对象需要存储在类似数据结构的 HashTable 中时，此整数用于确定存储桶位置。 默认情况下，对象的 hashCode（）方法返回存储对象的内存地址的整数表示形式。
+hashCode()方法用于获取给定对象的唯一整数。 当此对象需要存储在类似数据结构的 HashTable 中时，此整数用于确定存储桶位置。 默认情况下，对象的 hashCode()方法返回存储对象的内存地址的整数表示形式。
 
-顾名思义，equals（）方法用于简单地验证两个对象的相等性。 默认实现只是检查两个对象的对象引用以验证它们的相等性。
+顾名思义，equals()方法用于简单地验证两个对象的相等性。 默认实现只是检查两个对象的对象引用以验证它们的相等性。
 
 以下是在覆盖这些功能时要记住的要点。
 
-1.  始终使用对象的相同属性来生成 hashCode（）和 equals（）两者。 在本例中，我们使用了员工 ID。
-2.  equals（）必须一致（如果未修改对象，则必须保持返回相同的值）。
-3.  只要 a.equals（b），则 a.hashCode（）必须与 b.hashCode（）相同。
+1.  始终使用对象的相同属性来生成 hashCode()和 equals()两者。 在本例中，我们使用了员工 ID。
+2.  equals()必须一致（如果未修改对象，则必须保持返回相同的值）。
+3.  只要 a.equals（b），则 a.hashCode()必须与 b.hashCode()相同。
 4.  如果覆盖一个，则应覆盖另一个。
 
 [在此处阅读更多有趣的事实以及指南。](//howtodoinjava.com/java/related-concepts/working-with-hashcode-and-equals-methods-in-java/ "Working with hashCode and equals methods in java")
@@ -126,7 +126,7 @@ protected acces 修饰符的作用与默认访问权限相同，除了子类还
 
 垃圾回收是许多现代编程语言（例如 Java 和.NET 框架中的语言）中的自动内存管理功能。 使用垃圾回收的语言通常在 JVM 之类的虚拟机中解释或运行。 在每种情况下，运行代码的环境还负责垃圾回收。 GC 具有两个目标：应释放所有未使用的内存，并且除非程序不再使用它，否则不应释放任何内存。
 
-你能强迫垃圾收集吗？ 不，System.gc（）尽可能接近。 最好的选择是调用 System.gc（），这只是向垃圾收集器提示您要它进行收集。 由于垃圾收集器是不确定的，因此无法强制立即收集。 另外，在 OutOfMemoryError 文档下，它声明除非 VM 在完全垃圾回收后未能回收内存，否则不会抛出该错误。 因此，如果在出现错误之前一直分配内存，那么您将已经强制执行完整的垃圾回收。
+你能强迫垃圾收集吗？ 不，System.gc()尽可能接近。 最好的选择是调用 System.gc()，这只是向垃圾收集器提示您要它进行收集。 由于垃圾收集器是不确定的，因此无法强制立即收集。 另外，在 OutOfMemoryError 文档下，它声明除非 VM 在完全垃圾回收后未能回收内存，否则不会抛出该错误。 因此，如果在出现错误之前一直分配内存，那么您将已经强制执行完整的垃圾回收。
 
 [在此处详细了解垃圾收集。](//howtodoinjava.com/java/garbage-collection/revisiting-memory-management-and-garbage-collection-mechanisms-in-java/ "Revisiting memory management and garbage collection mechanisms in java")
 
@@ -143,7 +143,7 @@ protected acces 修饰符的作用与默认访问权限相同，除了子类还
 
 1.  JNI / JNA 倾向于破坏 JVM 的稳定性，尤其是当您尝试做一些复杂的事情时。 如果您的本机代码错误地执行了本机代码内存管理，则很有可能会使 JVM 崩溃。 如果您的本机代码是不可重入的，并且从多个 Java 线程中调用，则坏事……会偶尔发生。 等等。
 2.  带有本机代码的 Java 比纯 Java 或纯 C / C ++更难调试。
-3.  本机代码可能为其他平台无关的 Java 应用引入重要的平台依赖性/问题。
+3.  本机代码可能为其他平台无关的 Java 应用引入重要的平台依赖项/问题。
 4.  本机代码需要一个单独的构建框架，并且也可能存在平台/可移植性问题。
 
 ## **什么是序列化？ 解释渔获物？**

docs/misc2/214.md

@@ -155,7 +155,7 @@ List numsList = Arrays.asList(nums);
 
 #### 7）如何反转列表？
 
-这个问题就像上面的测试您对**集合**实用程序类的了解。 使用它 **reverse（）**方法可以反转列表。
+这个问题就像上面的测试您对**集合**实用程序类的了解。 使用它 **reverse()**方法可以反转列表。
 
 ```java
    Collections.reverse(list);
@@ -199,7 +199,7 @@ return map.put(e, PRESENT)==null;
 
 #### 10）是否可以将 null 元素添加到 TreeSet 或 HashSet 中？
 
-如您所见，上一个问题的 add（）方法中没有 null 检查。 并且 HashMap 还允许一个 null 键，因此**在 HashSet** 中允许一个“ null”。
+如您所见，上一个问题的 add()方法中没有 null 检查。 并且 HashMap 还允许一个 null 键，因此**在 HashSet** 中允许一个“ null”。
 
 TreeSet 使用与 HashSet 相同的概念进行内部逻辑，但是使用 NavigableMap 来存储元素。
 
@@ -223,7 +223,7 @@ Map 接口是一种特殊的集合类型，它是**，用于存储键值对**。
 
 #### 12）什么是 IdentityHashMap 和 WeakHashMap？
 
-**IdentityHashMap** 与 HashMap 相似，不同之处在于**在比较元素**时使用引用相等性。 IdentityHashMap 类不是一种广泛使用的 Map 实现。 尽管此类实现了 Map 接口，但它有意违反 Map 的一般协定，该协定要求在比较对象时必须使用 equals（）方法。 IdentityHashMap 设计为仅在少数情况下使用，其中需要引用相等语义。
+**IdentityHashMap** 与 HashMap 相似，不同之处在于**在比较元素**时使用引用相等性。 IdentityHashMap 类不是一种广泛使用的 Map 实现。 尽管此类实现了 Map 接口，但它有意违反 Map 的一般协定，该协定要求在比较对象时必须使用 equals()方法。 IdentityHashMap 设计为仅在少数情况下使用，其中需要引用相等语义。
 
 **WeakHashMap** 是 Map 接口**的实现，该接口仅存储对其键**的弱引用。 当不再在 WeakHashMap 外部引用键值对时，仅存储弱引用将允许对键值对进行垃圾回收。 该类主要用于与 equals 方法使用==运算符测试对象标识的键对象一起使用。 一旦丢弃了这样的密钥，就永远无法重新创建它，因此以后不可能在 WeakHashMap 中对该密钥进行查找，并且会惊讶地发现它的条目已被删除。
 
@@ -267,9 +267,9 @@ transient Entry[] table;
 
 #### 15）如何为哈希表设计一个好的密钥？
 
-在回答哈希图如何工作后，通常会跟进另一个好问题。 好吧，最重要的约束是**，您将来必须能够取回值对象**。 否则，没有使用这种数据结构。 如果您了解 hashmap 的工作原理，将会发现它很大程度上取决于 Key 对象的 hashCode（）和 equals（）方法。
+在回答哈希图如何工作后，通常会跟进另一个好问题。 好吧，最重要的约束是**，您将来必须能够取回值对象**。 否则，没有使用这种数据结构。 如果您了解 hashmap 的工作原理，将会发现它很大程度上取决于 Key 对象的 hashCode()和 equals()方法。
 
-因此，好的密钥对象**必须一次又一次提供相同的 hashCode（）**，无论它被获取了多少次。 同样，与 equals（）方法比较时，相同的键**必须返回 true，而不同的键必须返回 false** 。
+因此，好的密钥对象**必须一次又一次提供相同的 hashCode()**，无论它被获取了多少次。 同样，与 equals()方法比较时，相同的键**必须返回 true，而不同的键必须返回 false** 。
 
 因此，**不变类被认为是 HashMap 密钥**的最佳候选者。
 
@@ -329,9 +329,9 @@ Java 中的 HashMap 和 Hashtable 之间有一些区别：
 
 迭代器与枚举在以下三个方面有所不同：
 
-*   迭代器允许调用方使用其 remove（）方法在迭代过程中从基础集合中删除元素。 使用枚举器时，不能从集合中添加/删除元素。
+*   迭代器允许调用方使用其 remove()方法在迭代过程中从基础集合中删除元素。 使用枚举器时，不能从集合中添加/删除元素。
 *   枚举在旧类（例如 Vector / Stack 等）中可用，而 Iterator 在所有现代集合类中可用。
-*   另一个小的区别是 Iterator 改进了方法名称，例如 Enumeration.hasMoreElement（）变为 Iterator.hasNext（），Enumeration.nextElement（）变为 Iterator.next（）等。
+*   另一个小的区别是 Iterator 改进了方法名称，例如 Enumeration.hasMoreElement()变为 Iterator.hasNext()，Enumeration.nextElement()变为 Iterator.next()等。
 
 #### 23）HashMap 和 HashSet 之间的区别？
 
@@ -342,8 +342,8 @@ HashMap 是键值对的集合，而 HashSet 是唯一元素的无序集合。
 有三个区别：
 
 *   我们可以使用 Iterator 遍历 Set 和 List 以及 Map 的 Object 类型。 但是列表迭代器可用于遍历列表类型的对象，但不能遍历对象的集合类型。
-*   通过使用 Iterator，我们只能从正向检索 Collection 对象中的元素，而 List Iterator 则允许您使用 hasPrevious（）和 previous（）方法在任一方向上遍历。
-*   ListIterator 允许您使用 add（）remove（）方法修改列表。 使用 Iterator 不能添加，只能删除元素。
+*   通过使用 Iterator，我们只能从正向检索 Collection 对象中的元素，而 List Iterator 则允许您使用 hasPrevious()和 previous()方法在任一方向上遍历。
+*   ListIterator 允许您使用 add()remove()方法修改列表。 使用 Iterator 不能添加，只能删除元素。
 
 #### 25）TreeSet 和 SortedSet 之间的区别？
 
@@ -377,9 +377,9 @@ SortedSet 是 TreeSet 实现的接口。 就是这样！
 
 上面的方法将 collection 作为参数并返回相同类型的 collection，这些类型是同步的且线程安全的。
 
-#### 29）为什么没有像 Iterator.add（）这样的方法将元素添加到集合中？
+#### 29）为什么没有像 Iterator.add()这样的方法将元素添加到集合中？
 
-迭代器的唯一目的是通过集合进行枚举。 所有集合都包含 add（）方法以实现您的目的。 添加[Iterator]毫无意义，因为**集合可能有序，也可能没有排序。 而且 **add（）方法对于有序和无序集合**不能具有相同的实现。**
+迭代器的唯一目的是通过集合进行枚举。 所有集合都包含 add()方法以实现您的目的。 添加[Iterator]毫无意义，因为**集合可能有序，也可能没有排序。 而且 **add()方法对于有序和无序集合**不能具有相同的实现。**
 
 #### 30）有哪些不同的方法可以遍历列表？
 
@@ -420,7 +420,7 @@ CopyOnWriteArrayList 的迭代器是故障安全迭代器的示例，而且 Conc
 
 实际的集合类型不支持的被调用方法抛出**异常。**
 
-例如，如果您使用“ Collections.unmodifiableList（list）”创建一个只读列表列表，然后调用 add（）或 remove（）方法，那将会发生什么。 它应该明确抛出 UnsupportedOperationException。
+例如，如果您使用“ Collections.unmodifiableList（list）”创建一个只读列表列表，然后调用 add()或 remove()方法，那将会发生什么。 它应该明确抛出 UnsupportedOperationException。
 
 #### 35）哪些收集类别可随机访问其元素？
 
@@ -441,7 +441,7 @@ BlockingQueue 方法有四种形式：一种抛出异常，第二种返回一个
 
 **堆栈也是队列的一种形式，但有一个区别，那就是 LIFO（后进先出）。**
 
-无论使用哪种顺序，队列的开头都是该元素，可以通过调用 remove（）或 poll（）将其删除。 另请注意，堆栈和向量都已同步。
+无论使用哪种顺序，队列的开头都是该元素，可以通过调用 remove()或 poll()将其删除。 另请注意，堆栈和向量都已同步。
 
 **用法：**如果要按接收顺序处理传入流，请使用队列。适用于工作列表和处理请求。
 如果只想从堆栈顶部推动并弹出，请使用堆栈。 适用于递归算法。

docs/misc2/216.md

@@ -49,20 +49,20 @@ try (FileInputStream f = new FileInputStream("ttt"))
 *   [http://en.wikipedia.org/wiki/Producer-consumer_problem](https://en.wikipedia.org/wiki/Producer-consumer_problem)
 *   [//howtodoinjava.com/java-5/how-to-use-blockingqueue-and-threadpoolexecutor-in-java/](//howtodoinjava.com/java-5/how-to-use-blockingqueue-and-threadpoolexecutor-in-java/)
 
-**8）为什么在 Object 类中定义了 wait（），notify（）和 notifyAll（）？**
+**8）为什么在 Object 类中定义了 wait()，notify()和 notifyAll()？**
 
 *   [//howtodoinjava.com/2013/03/04/core-java-interview-questions-series-part-2/](//howtodoinjava.com/java/interviews-questions/core-java-interview-questions-series-part-2/)
 *   [http://stackoverflow.com/questions/17840397/concept-behind-putting-wait-notify-methods-in-object-class](https://stackoverflow.com/questions/17840397/concept-behind-putting-wait-notify-methods-in-object-class) 
 
-**9）我们可以重写 wait（）或 notify（）方法吗？**
+**9）我们可以重写 wait()或 notify()方法吗？**
 
-在 Object.java 中，方法 getClass（），notify（），notifyAll（）和三个 wait（）方法是最终的，因此您无法覆盖它们。
+在 Object.java 中，方法 getClass()，notify()，notifyAll()和三个 wait()方法是最终的，因此您无法覆盖它们。
 
-**10）wait（），sleep（）和 yield（）之间的区别？**
+**10）wait()，sleep()和 yield()之间的区别？**
 
 [http://stackoverflow.com/questions/9700871/what-is-difference-between-sleep-method-and-yield-method-of-multi-threading](https://stackoverflow.com/questions/9700871/what-is-difference-between-sleep-method-and-yield-method-of-multi-threading)
 
-**11）解释线程类**中的 join（）方法
+**11）解释线程类**中的 join()方法
 
 [http://stackoverflow.com/questions/18479771/java-multithreading-concept-and-join-method](https://stackoverflow.com/questions/18479771/java-multithreading-concept-and-join-method)
 
@@ -209,7 +209,7 @@ catch()
 **19）我可以将一个类声明为私有类吗？**
 
 [http://docs.oracle.com/javase/tutorial/java/javaOO/classdecl.html](https://docs.oracle.com/javase/tutorial/java/javaOO/classdecl.html)
- **20）如果我在 try 块中写 return 会发生什么？ 最终会执行吗？ 如果写入 system.exit（），最终将执行块会怎样？**
+ **20）如果我在 try 块中写 return 会发生什么？ 最终会执行吗？ 如果写入 system.exit()，最终将执行块会怎样？**
 
 [http://stackoverflow.com/questions/65035/does-finally-always-execute-in-java](https://stackoverflow.com/questions/65035/does-finally-always-execute-in-java)
 

docs/misc2/217.md

@@ -14,18 +14,18 @@
 4\. [ConcurrentHashMap 和 Collections.synchronizedMap（HashMap）之间的区别？](#4)
 5\. [HashMap 和 HashTable 之间的区别？](#5)
 6\. [HashTable 和 Collections.synchronized（HashMap）之间的区别？](#6)
-7\. [密钥的随机/固定 hashCode（）值的影响？](#7)
+7\. [密钥的随机/固定 hashCode()值的影响？](#7)
 8\. [在多线程应用的非同步代码中使用 HashMap 吗？](#8)
 
 ## 1.如何为 HashMap 设计一个好的密钥
 
 设计一个好的密钥的最基本的需求是“我们应该能够从地图中检索到价值对象而不会失败”，对吗？ 否则，无论您如何构建精美的数据结构，它都将毫无用处。 要确定我们已经创建了一个好的密钥，我们必须知道“ [**HashMap 如何工作？**](https://howtodoinjava.com/java/collections/how-hashmap-works-in-java/ "How hashmap works in java") 。 我将介绍散列表的工作原理，让您从链接的文章中阅读内容，但总而言之，它是基于散列原理的。
 
-键的哈希码主要与 equals（）方法结合使用，用于将键放入地图，然后从地图中搜索回来。 因此，如果在将键值对放入映射后，键对象的哈希码发生变化，则几乎不可能从映射取回值对象。 这是内存泄漏的情况。 为了避免这种情况，映射**键应该是不可变的**。 这些是 [**创建类**](https://howtodoinjava.com/java/basics/how-to-make-a-java-class-immutable/ "How to make a java class immutable") 不变的东西。
+键的哈希码主要与 equals()方法结合使用，用于将键放入地图，然后从地图中搜索回来。 因此，如果在将键值对放入映射后，键对象的哈希码发生变化，则几乎不可能从映射取回值对象。 这是内存泄漏的情况。 为了避免这种情况，映射**键应该是不可变的**。 这些是 [**创建类**](https://howtodoinjava.com/java/basics/how-to-make-a-java-class-immutable/ "How to make a java class immutable") 不变的东西。
 
 这就是为什么不可变类（例如 String，Integer 或其他包装器类）是好的关键对象候选对象的主要原因。
 
-但是请记住，建议**不可变，而不是强制性**。 如果要将可变对象作为哈希图中的键，则必须确保键对象的**状态更改不会更改对象**的哈希码。 这可以通过重写 hashCode（）方法来完成。 同样，键类必须遵守 [**hashCode（）和 equals（）方法协定**](https://howtodoinjava.com/java/basics/java-hashcode-equals-methods/ "Working with hashCode and equals methods in java") ，以避免在运行时出现不良行为。 在链接的文章中阅读有关此合同的更多信息。
+但是请记住，建议**不可变，而不是强制性**。 如果要将可变对象作为哈希图中的键，则必须确保键对象的**状态更改不会更改对象**的哈希码。 这可以通过重写 hashCode()方法来完成。 同样，键类必须遵守 [**hashCode()和 equals()方法协定**](https://howtodoinjava.com/java/basics/java-hashcode-equals-methods/ "Working with hashCode and equals methods in java") ，以避免在运行时出现不良行为。 在链接的文章中阅读有关此合同的更多信息。
 
 更详细的信息可在 [**在此处**](https://howtodoinjava.com/java/collections/design-good-key-for-hashmap/ "How to design a good key for HashMap") 中找到。
 
@@ -48,9 +48,9 @@ ConcurrentHashMap Internal Structure
 
 ## 3\. HashMap 和 Collections.synchronizedMap（HashMap）之间的区别
 
-这个问题很简单，对！ HashMap 是不同步的，并且 Collections.synchronizedMap（）返回 HashMap 的包装实例，该实例具有同步的所有 get，put 方法。
+这个问题很简单，对！ HashMap 是不同步的，并且 Collections.synchronizedMap()返回 HashMap 的包装实例，该实例具有同步的所有 get，put 方法。
 
-本质上， **Collections.synchronizedMap（）返回内部创建的内部类“ SynchronizedMap”** 的引用，该类包含作为参数传递的输入 HashMap 的键值对。
+本质上， **Collections.synchronizedMap()返回内部创建的内部类“ SynchronizedMap”** 的引用，该类包含作为参数传递的输入 HashMap 的键值对。
 
 内部类的此实例与原始参数 HashMap 实例无关，并且是完全独立的。
 
@@ -60,7 +60,7 @@ ConcurrentHashMap Internal Structure
 
 如上所述，ConcurrentHashMap 由内部段组成，从概念上讲，这些内部段可以视为独立的 HashMap。 所有这样的段可以在高并发执行中被单独的线程锁定。 这样，**多个线程可以从 ConcurrentHashMap 获取/放置键值对，而不会互相阻塞/等待**。
 
-在 Collections.synchronizedMap（）中，我们获得了 HashMap 的同步版本，并且**以阻塞方式**进行访问。 这意味着如果多个线程尝试同时访问 syncedMap，将允许它们一次以同步方式获取/放置键值对。
+在 Collections.synchronizedMap()中，我们获得了 HashMap 的同步版本，并且**以阻塞方式**进行访问。 这意味着如果多个线程尝试同时访问 syncedMap，将允许它们一次以同步方式获取/放置键值对。
 
 ## 5\. HashMap 和 HashTable 之间的区别
 
@@ -78,7 +78,7 @@ ConcurrentHashMap Internal Structure
 
 唯一将它们分开的是事实 **HashTable 是提升为收集框架的旧版**类。 它具有自己的额外功能，例如枚举器。
 
-## 7.密钥的随机/固定 hashcode（）值的影响
+## 7.密钥的随机/固定 hashcode()值的影响
 
 两种情况（密钥的固定哈希码或密钥的随机哈希码）的影响将产生相同的结果，即“ **意外行为**”。 HashMap 中哈希码最基本的需求是确定存储桶的位置，以将键值对放置在哪里，以及必须从哪里检索它。
 
@@ -94,7 +94,7 @@ ConcurrentHashMap Internal Structure
 
 当 HashMap 达到其大小上限时，它具有重新哈希的概念。 重新哈希处理是创建新的内存区域，并在新的内存中复制所有已经存在的键值对的过程。 可以说，线程 A 尝试将键值对放入映射中，然后开始重新哈希。 同时，线程 B 来了，并开始使用 put 操作来操作存储桶。
 
-在进行重新哈希处理时，有机会生成循环依赖关系，其中链表中的任何元素（在任何存储桶中）都可以指向同一存储桶中的任何先前节点。 这将导致无限循环，因为重新哈希处理的代码包含一个“ while（true）{//获取下一个节点； }”块，并且在循环依赖性下它将无限运行。
+在进行重新哈希处理时，有机会生成循环依赖关系，其中链表中的任何元素（在任何存储桶中）都可以指向同一存储桶中的任何先前节点。 这将导致无限循环，因为重新哈希处理的代码包含一个“ while（true）{//获取下一个节点； }”块，并且在循环依赖项下它将无限运行。
 
 要仔细观察，请查看用于重新哈希处理的传输方法的艺术源代码：
 

docs/misc2/218.md

@@ -10,7 +10,7 @@ Java 版本 7 或 8 中的**新 Java 功能是什么？ 这些是 Java 面试中
 
 [Java 12](https://howtodoinjava.com/java12/new-features-enhancements/) （于 2019 年 3 月 19 日发布）是 JDK 的最新版本。 让我们看看它为开发人员和建筑师带来的新功能和改进。
 
-*   Stream API 中的 Collectors.teeing（）
+*   Stream API 中的 Collectors.teeing()
 *   字符串 API 的更改
 *   Files.mismatch（路径，路径）
 *   紧凑数字格式
@@ -25,8 +25,8 @@ Java 版本 7 或 8 中的**新 Java 功能是什么？ 这些是 Java 面试中
 *   启动不编译的单文件程序
 *   字符串 API 的更改
 *   Collection.toArray（IntFunction）
-*   Files.readString（）和 Files.writeString（）
-*   Optional.isEmpty（）
+*   Files.readString()和 Files.writeString()
+*   Optional.isEmpty()
 
 ## Java 10 功能
 
@@ -37,7 +37,7 @@ Java 9 发布后，Java 10 很快问世。 与以前的版本不同，Java 10
 *   JEP 304：垃圾收集器接口
 *   JEP 307：用于 G1 的并行全 GC
 *   JEP 316：备用存储设备上的堆分配
-*   JEP 296：将 JDK 林整合到单个存储库中
+*   JEP 296：将 JDK 林整合到单个仓库中
 *   JEP 310：应用类 - 数据共享
 *   JEP 314：其他 Unicode 语言标签扩展
 *   JEP 319：根证书
@@ -134,7 +134,7 @@ Java 9 中的一些重要功能/ [更改是：](https://howtodoinjava.com/java9/
 版本也称为 5.0，而不是 1.5。 包括的功能在下面列出：
 
 *   [泛型](//howtodoinjava.com/java/generics/complete-java-generics-tutorial/)
-*   [批注](//howtodoinjava.com/2014/06/09/complete-java-annotations-tutorial/)
+*   [注解](//howtodoinjava.com/2014/06/09/complete-java-annotations-tutorial/)
 *   自动装箱/拆箱
 *   [枚举](//howtodoinjava.com/java-5/guide-for-understanding-enum-in-java/)
 *   瓦拉格斯

docs/misc2/22.md

@@ -4,9 +4,9 @@
 
 [Gson](https://howtodoinjava.com/learningpaths/gson/) 允许我们从 Java 类中排除或忽略字段，这些字段不希望包含在序列化和反序列化中。 Gson 支持许多内置机制，用于排除顶级类，字段和字段类型。
 
-## 1\. Gson @Expose 批注
+## 1\. Gson @Expose 注解
 
-[`@Expose`](https://static.javadoc.io/com.google.code.gson/gson/2.8.5/com/google/gson/annotations/Expose.html)标记要排除的对象的某些字段，默认为*标记为*，以考虑将序列化和反序列化为 JSON。 这意味着 Gson 将排除类中没有用`@Expose`批注标记的所有字段。
+[`@Expose`](https://static.javadoc.io/com.google.code.gson/gson/2.8.5/com/google/gson/annotations/Expose.html)标记要排除的对象的某些字段，默认为*标记为*，以考虑将序列化和反序列化为 JSON。 这意味着 Gson 将排除类中没有用`@Expose`注解标记的所有字段。
 
 `@Expose`注释在一种编程风格中很有用，在该编程风格中，您要显式指定应考虑进行序列化或反序列化的所有字段。
 
@@ -14,8 +14,8 @@
 
 `@Expose`是可选的，并提供两个配置参数：
 
-*   `serialize` – 如果*为真*，则在序列化时会在 JSON 中写出带有此批注的字段。
-*   `deserialize` – 如果*为真*，则从 JSON 反序列化带有此批注的字段。
+*   `serialize` – 如果*为真*，则在序列化时会在 JSON 中写出带有此注解的字段。
+*   `deserialize` – 如果*为真*，则从 JSON 反序列化带有此注解的字段。
 
 ```java
 @Expose(serialize = false) 

docs/misc2/23.md

@@ -139,12 +139,12 @@ Token Value >>>> null
 
 在上面的示例中：
 
-*   `JsonReader`的 **hasNext（）**方法如果有更多令牌，则返回 true。
-*   **peek（）**方法返回下一个 JSON 令牌，但不移至下一个。
+*   `JsonReader`的 **hasNext()**方法如果有更多令牌，则返回 true。
+*   **peek()**方法返回下一个 JSON 令牌，但不移至下一个。
 *   随后，多次调用`peek()`将返回相同的 JSON 令牌。
 *   可以使用`JsonToken`类的常量检查返回令牌的类型。
-*   使用 *beginArray（）*和 *endArray（）*方法检查数组的左括号`'['`和`']'`。
-*   使用 *beginObject（）*和 *endObject（）*方法检查对象的左括号`'{'`和`'}'`。
+*   使用 *beginArray()*和 *endArray()*方法检查数组的左括号`'['`和`']'`。
+*   使用 *beginObject()*和 *endObject()*方法检查对象的左括号`'{'`和`'}'`。
 
 令牌的密钥的类型为 **JsonToken.NAME** 。 使用`nextName()`方法获取密钥名称。
 

docs/misc2/24.md

@@ -42,7 +42,7 @@ JsonObject jsonObject = jsonElement.getAsJsonObject();
 JsonArray jsonArray = jsonElement.getAsJsonArray();
 ```
 
-一旦有了`JsonObject`或`JsonArray`实例，就可以使用其 **get（）**方法从中提取字段。
+一旦有了`JsonObject`或`JsonArray`实例，就可以使用其 **get()**方法从中提取字段。
 
 ## 4\. Gson JsonParser 示例
 
@@ -85,9 +85,9 @@ public class Main
 
 ```
 
-## 5.使用 fromJson（）获得 JsonObject
+## 5.使用 fromJson()获得 JsonObject
 
-我们可以使用`Gson`实例和来自 Json（）方法的**实例来达到相同的结果。**
+我们可以使用`Gson`实例和来自 Json()方法的**实例来达到相同的结果。**
 
 ```java
 String json = "{'id': 1001, " 
@@ -104,7 +104,7 @@ System.out.println(jsonObject.get("email"));
 
 ```
 
-Program output.
+程序输出：
 
 ```java
 1001

docs/misc2/25.md

@@ -24,7 +24,7 @@ public interface JsonSerializer<T>
 
 为 Json 创建自定义序列化器之后，我们还需要通过`GsonBuilder.registerTypeAdapter(Type, Object)`注册该序列化器。
 
-Gson 在遇到指定类型的字段时，会在序列化过程中调用其回调方法 *serialize（）*。
+Gson 在遇到指定类型的字段时，会在序列化过程中调用其回调方法 *serialize()*。
 
 #### 1.2 Gson JsonSerializer 示例
 
@@ -52,7 +52,7 @@ public class BooleanSerializer implements JsonSerializer<Boolean> {
 
 ```
 
-让我们编写一个程序，使用 **registerTypeAdapter（）**注册 *JsonSerializer* 实例，然后使用它将 Java 对象序列化为 json。
+让我们编写一个程序，使用 **registerTypeAdapter()**注册 *JsonSerializer* 实例，然后使用它将 Java 对象序列化为 json。
 
 ```java
 import com.google.gson.Gson;
@@ -108,7 +108,7 @@ public interface JsonDeserializer<T>
 
 为 Json 创建自定义解串器之后，我们还需要通过`GsonBuilder.registerTypeAdapter(Type, Object)`注册此解串器。
 
-Gson 在遇到指定类型的字段时，会在序列化过程中调用其回调方法 *deserialize（）*。
+Gson 在遇到指定类型的字段时，会在序列化过程中调用其回调方法 *deserialize()*。
 
 #### 2.2 Gson JsonDeserializer 示例
 
@@ -217,6 +217,6 @@ Employee [id=1001,
 
 根据提供的 json 输入的保证，我们可能想用`has()`来检查 *JsonObject* 中是否存在模型属性。 否则，如果我们正在访问属性，然后尝试获取该属性的值，则可能会遇到`NullPointerException`。
 
-请问您有关 Java 中使用 Gson 的*自定义序列化和反序列化的问题。*
+向我提供有关 Java 中使用 Gson 的*自定义序列化和反序列化的问题。*
 
 学习愉快！
\ No newline at end of file

docs/misc2/26.md

@@ -24,7 +24,7 @@ Table of Contents
 9\. More Gson Tutorials
 ```
 
-## 1.先决条件和依赖性
+## 1.先决条件和依赖项
 
 #### 1.1 POJO 课程
 
@@ -97,7 +97,7 @@ Gson gson = new GsonBuilder()
 
 使用`GsonBuilder`时，可以为`Gson`对象提供许多其他[有用选项](https://static.javadoc.io/com.google.code.gson/gson/2.7/com/google/gson/GsonBuilder.html)。 继续检查一下。
 
-## 3\. Gson toJson（）– 将 Java 对象转换为 JSON 字符串
+## 3\. Gson toJson()– 将 Java 对象转换为 JSON 字符串
 
 要将**将对象转换为 json** ，请使用 **`toJson()`** 方法。
 
@@ -121,7 +121,7 @@ System.out.println(gson.toJson(employee));
 
 ```
 
-## 4\. 3\. Gson fromJson（）– 将 JSON 字符串转换为 Object
+## 4\. 3\. Gson fromJson()– 将 JSON 字符串转换为 Object
 
 要**将 json 解析为对象**，请使用 **`fromJson()`** 方法。
 
@@ -134,7 +134,7 @@ System.out.println(
 
 ```
 
-Program Output.
+程序输出：
 
 ```java
 Employee [id=1, firstName=Lokesh, lastName=Gupta, roles=[ADMIN, MANAGER]]
@@ -220,7 +220,7 @@ System.out.println(
 
 ```
 
-Program Output.
+程序输出：
 
 ```java
 Employee [id=1, firstName=Lokesh, lastName=Gupta, roles=[ADMIN, MANAGER], department=Department [deptName=Finance]]
@@ -325,7 +325,7 @@ System.out.println(gson.fromJson("{'id':1,'firstName':'Lokesh','lastName':'Gupta
 
 ```
 
-Program Output.
+程序输出：
 
 ```java
 {"id":1,"firstName":"Lokesh","lastName":"Gupta","roles":["ADMIN","MANAGER"],"birthDate":"17/06/2014"}
@@ -334,9 +334,9 @@ Employee [id=1, firstName=Lokesh, lastName=Gupta, roles=[ADMIN, MANAGER], birthD
 
 ```
 
-## 7\. Gson setPrettyPrinting（）– 漂亮的打印 JSON 输出
+## 7\. Gson setPrettyPrinting()– 漂亮的打印 JSON 输出
 
-Gson 提供的默认 JSON 输出是紧凑的 JSON 格式。 这意味着在输出 JSON 结构中将没有任何空格。 要生成更具可读性和美观的 JSON，请使用`GsonBuilder`中的 **setPrettyPrinting（）**。
+Gson 提供的默认 JSON 输出是紧凑的 JSON 格式。 这意味着在输出 JSON 结构中将没有任何空格。 要生成更具可读性和美观的 JSON，请使用`GsonBuilder`中的 **setPrettyPrinting()**。
 
 ```java
 Gson gson = new GsonBuilder().setPrettyPrinting().create();
@@ -344,7 +344,7 @@ String jsonOutput = gson.toJson(employee);
 
 ```
 
-Program Output.
+程序输出：
 
 ```java
 {
@@ -360,9 +360,9 @@ Program Output.
 
 ```
 
-## 8\. Gson setVersion（）- 版本支持
+## 8\. Gson setVersion()- 版本支持
 
-如果您正在使用的类文件已在不同版本中进行了修改，并且使用[`@Since`](https://code.google.com/p/google-gson/source/browse/trunk/gson/src/main/java/com/google/gson/annotations/Since.java "since")注释了字段，则可以使用此功能。 您需要做的就是使用`GsonBuilder`的 **setVersion（）**方法。
+如果您正在使用的类文件已在不同版本中进行了修改，并且使用[`@Since`](https://code.google.com/p/google-gson/source/browse/trunk/gson/src/main/java/com/google/gson/annotations/Since.java "since")注释了字段，则可以使用此功能。 您需要做的就是使用`GsonBuilder`的 **setVersion()**方法。
 
 ```java
 GsonBuilder gsonBuilder = new GsonBuilder();

docs/misc2/27.md

@@ -67,7 +67,7 @@ public class Employee
 
 #### 1.2 对于 ANT 或其他项目类型
 
-对于非 Maven 用例，可以从 [Central Maven 存储库](https://repo1.maven.org/maven2/com/fasterxml/jackson/core/jackson-core/)下载 jar。
+对于非 Maven 用例，可以从 [Central Maven 仓库](https://repo1.maven.org/maven2/com/fasterxml/jackson/core/jackson-core/)下载 jar。
 
 ## 2.杰克逊 ObjectMapper
 
@@ -146,7 +146,7 @@ public class JavaToJSONExample
 
 ```
 
-## 4\. Jackson 漂亮打印 JSON 输出
+## 4\. Jackson 精美打印 JSON 输出
 
 如果看上面的输出，那么写在文本文件中的输出是非常原始的并且没有格式化。 您可以使用 ~~`defaultPrettyPrintingWriter()`~~ **`writerWithDefaultPrettyPrinter`** 实例编写格式化的 JSON 内容，如下所示：
 
@@ -186,7 +186,7 @@ public class JavaToPrettyJSONExample
 
 ```
 
-Program Output.
+程序输出：
 
 ```java
 {
@@ -236,7 +236,7 @@ public class JSONToJavaExample
 
 ```
 
-Program Output.
+程序输出：
 
 ```java
 Employee [id=1, firstName=Lokesh, lastName=Gupta]

docs/misc2/29.md

-# JAXB 批注
+# JAXB 注解
 
 > 原文： [https://howtodoinjava.com/jaxb/jaxb-annotations/](https://howtodoinjava.com/jaxb/jaxb-annotations/)
 
-详细了解 **JAXB 批注**及其在编组和解组操作期间的用法。
+详细了解 **JAXB 注解**及其在编组和解组操作期间的用法。
 
 ## 1）JAXB 注释列表
 
@@ -22,7 +22,7 @@
 
 #### 1.1）@XmlRootElement
 
-这将类或枚举类型映射到 XML 根元素。 当使用`@XmlRootElement`批注对顶级类或枚举类型进行批注时，则其值将表示为 XML 文档中的 XML 元素。
+这将类或枚举类型映射到 XML 根元素。 当使用`@XmlRootElement`注解对顶级类或枚举类型进行注解时，则其值将表示为 XML 文档中的 XML 元素。
 
 ```java
 @XmlRootElement(name = "employee")
@@ -309,7 +309,7 @@ Above will result into:
 
 ## 2）JAXB 注释示例
 
-学习在模型类上应用 JAXB 批注，然后将对象编组到 XML 文件中。
+学习在模型类上应用 JAXB 注解，然后将对象编组到 XML 文件中。
 
 ```java
 package com.howtodoinjava.demo.model;

docs/misc2/3.md

@@ -45,7 +45,7 @@ Table of Contents
 在点对点消息传递域中，该应用是基于消息队列，发送者和接收者构建的。 每个消息都寻址到特定的[**队列**](https://docs.oracle.com/javaee/6/api/javax/jms/Queue.html)。 队列保留发送给他们的所有消息，直到消息被消耗或过期。 PTP 消息传递具有一些特征：
 
 1.  每个消息只有一个客户端。
-2.  消息的发送者和接收者没有时间依赖性。
+2.  消息的发送者和接收者没有时间依赖项。
 3.  当发送方发送消息时，接收方可以获取消息是否正在运行。
 4.  接收者在收到消息后发送确认。
 
@@ -62,7 +62,7 @@ Table of Contents
 一些特征是：
 
 1.  一条消息可以有多个订阅者。
-2.  发布者和订阅具有时间依赖性。 订阅主题的客户端只能使用在客户端创建订阅后发布的消息，并且订阅者必须继续处于活动状态才能使用消息。
+2.  发布者和订阅具有时间依赖项。 订阅主题的客户端只能使用在客户端创建订阅后发布的消息，并且订阅者必须继续处于活动状态才能使用消息。
 
 ![Publish Subscribe JMS Messaging](img/4f8be82ddadbab37115d9ed981df7021.png)
 

docs/misc2/30.md

@@ -2,11 +2,11 @@
 
 > 原文： [https://howtodoinjava.com/jaxb/xmlrootelement-annotation/](https://howtodoinjava.com/jaxb/xmlrootelement-annotation/)
 
-**[JAXB](https://howtodoinjava.com/jaxb/jaxb-annotations/) @XmlRootElement 批注**的 Java 示例及其在编组和解组操作期间的用法详细说明。
+**[JAXB](https://howtodoinjava.com/jaxb/jaxb-annotations/) @XmlRootElement 注解**的 Java 示例及其在编组和解组操作期间的用法详细说明。
 
-## 1\. JAXB @XmlRootElement 批注类型
+## 1\. JAXB @XmlRootElement 注解类型
 
-`@XmlRootElement`将类或[枚举类型](https://howtodoinjava.com/java/enum/guide-for-understanding-enum-in-java/)映射到 XML 元素。 当使用`@XmlRootElement`批注注释顶级类或枚举类型时，则其值在 XML 文档中表示为 XML 元素。
+`@XmlRootElement`将类或[枚举类型](https://howtodoinjava.com/java/enum/guide-for-understanding-enum-in-java/)映射到 XML 元素。 当使用`@XmlRootElement`注解注释顶级类或枚举类型时，则其值在 XML 文档中表示为 XML 元素。
 
 `@XmlRootElement`注释可以与以下注释一起使用：`XmlType`，`XmlEnum`，`XmlAccessorType`，`XmlAccessorOrder`。
 

docs/misc2/36.md

@@ -131,7 +131,7 @@ public class JaxbExample
 
 ```
 
-Program Output.
+程序输出：
 
 ```java
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
@@ -178,7 +178,7 @@ private static void jaxbXmlFileToObject(String fileName) {
 
 ```
 
-Program Output.
+程序输出：
 
 ```java
 Employee [id=1, firstName=Lokesh, lastName=Gupta, department=Department [id=101, name=IT]]

docs/misc2/39.md

@@ -28,9 +28,9 @@
 
 ## 2）模型类别
 
-我创建了一个模型类“ `Employee`”，它具有一些公共字段。 我想构建可以解析一组`employees`的代码。 请注意，JAXB 在最重要的类上需要 [`@XmlRootElement`](https://docs.oracle.com/javaee/5/api/javax/xml/bind/annotation/XmlRootElement.html "XmlRootElement") 批注，我们将对其进行封送或取消封送。
+我创建了一个模型类“ `Employee`”，它具有一些公共字段。 我想构建可以解析一组`employees`的代码。 请注意，JAXB 在最重要的类上需要 [`@XmlRootElement`](https://docs.oracle.com/javaee/5/api/javax/xml/bind/annotation/XmlRootElement.html "XmlRootElement") 注解，我们将对其进行封送或取消封送。
 
-`ArrayList`类是集合框架的一部分，它没有任何 JAXB 批注。 因此，我们需要另外一个类别“ `Employees`”，该类别将代表一组雇员。 现在，在该类中，我们可以添加任何我们喜欢的注释。
+`ArrayList`类是集合框架的一部分，它没有任何 JAXB 注解。 因此，我们需要另外一个类别“ `Employees`”，该类别将代表一组雇员。 现在，在该类中，我们可以添加任何我们喜欢的注释。
 
 ```java
 @XmlRootElement(name = "employee")

docs/misc2/42.md

@@ -23,9 +23,9 @@ Random exceptions
 
 ## 原因
 
-发生上述异常是因为 JAXB 总是期望实体上有一个@XmlRootElement 批注，它会编组。 这是强制性的，不能跳过。 需要@XmlRootElement 批注才能从 Java 对象编组的 XML 根元素中获取元数据。
+发生上述异常是因为 JAXB 总是期望实体上有一个@XmlRootElement 注解，它会编组。 这是强制性的，不能跳过。 需要@XmlRootElement 注解才能从 Java 对象编组的 XML 根元素中获取元数据。
 
-ArrayList 类或任何 Java 集合类都没有任何 JAXB 批注。 由于这个原因，JAXB 无法解析任何此类 java 对象，并引发此错误。
+ArrayList 类或任何 Java 集合类都没有任何 JAXB 注解。 由于这个原因，JAXB 无法解析任何此类 java 对象，并引发此错误。
 
 ## 解决方案：创建包装器类
 

docs/misc2/43.md

@@ -56,11 +56,11 @@ Random exceptions
 
 ## 原因
 
-发生上述异常的主要原因是缺少@XmlAccessType 批注或对@XmlAccessType 和@XxmlElement 批注的无效使用。 正确的用法是，一个 Java 字段应只包含一个表示其元数据的有效 JAXB 批注。
+发生上述异常的主要原因是缺少@XmlAccessType 注解或对@XmlAccessType 和@XxmlElement 注解的无效使用。 正确的用法是，一个 Java 字段应只包含一个表示其元数据的有效 JAXB 注解。
 
 默认情况下，JAXB 包含所有公共字段和用于整理的 getter。 因此，如果您有一个字段及其获取器，那么它将包含两次。 这是错误，需要通过正确使用注释来解决。
 
-## 解决方案：使用@XmlAccessType 批注
+## 解决方案：使用@XmlAccessType 注解
 
 **1）@XmlAccessorType（XmlAccessType.FIELD）**
 
@@ -96,7 +96,7 @@ public class Employees
 
 **2）@XmlAccessorType（XmlAccessType.NONE）**
 
-如果使用“ XmlAccessType.NONE”，则意味着必须在输出 XML 中注释所有要编组的字段。 剩下的任何字段都不会包含在 JAXB 上下文中。 因此，本质上，“员工”和“大小”字段都需要@XmlElement 批注。 如果这两个字段中的任何一个都未使用@XmlElement 注释，则不会将其编组。
+如果使用“ XmlAccessType.NONE”，则意味着必须在输出 XML 中注释所有要编组的字段。 剩下的任何字段都不会包含在 JAXB 上下文中。 因此，本质上，“员工”和“大小”字段都需要@XmlElement 注解。 如果这两个字段中的任何一个都未使用@XmlElement 注释，则不会将其编组。
 
 ```java
 @XmlRootElement(name = "employees")

docs/misc2/44.md

@@ -4,7 +4,7 @@
 
 很多时候，我们将需要**编组 Java 对象，而不使用 [JAXB 注释](https://howtodoinjava.com/jaxb/jaxb-annotations/)** ，例如 [@XmlRootElement](https://howtodoinjava.com/jaxb/xmlrootelement-annotation/) ，并且我们不允许在源代码中进行任何更改。 当我们使用遗留代码或某些我们没有源代码的客户端 jar 时，可能会发生这种情况。
 
-可能还有许多其他情况，但是想法是*我们无法使用 JAXB 批注*修改模型类。 这可能是**将 Java 对象转换为 xml 而没有 jaxb** 的示例。
+可能还有许多其他情况，但是想法是*我们无法使用 JAXB 注解*修改模型类。 这可能是**将 Java 对象转换为 xml 而没有 jaxb** 的示例。
 
 ## 1.没有@XmlRootElement 进行编组时出现问题
 
@@ -30,7 +30,7 @@ as an element because it is missing an @XmlRootElement annotation
 
 ```
 
-其中`Employee.java`类如下。 它没有任何[XGG1]这样的 JAXB 批注。
+其中`Employee.java`类如下。 它没有任何[XGG1]这样的 JAXB 注解。
 
 ```java
 package com.howtodoinjava.demo.model;
@@ -69,9 +69,9 @@ public class Employee implements Serializable {
 
 ```
 
-## 2.解决没有@XmlRootElement 批注的对象的解决方案
+## 2.解决没有@XmlRootElement 注解的对象的解决方案
 
-缺少`@XmlRootElement`批注时，JAXB 无法为`Employee`对象构建[`JAXBElement`](https://docs.oracle.com/javaee/7/api/javax/xml/bind/JAXBElement.html)实例。 这就是我们必须帮助 JAXB 手动构建它的地方。
+缺少`@XmlRootElement`注解时，JAXB 无法为`Employee`对象构建[`JAXBElement`](https://docs.oracle.com/javaee/7/api/javax/xml/bind/JAXBElement.html)实例。 这就是我们必须帮助 JAXB 手动构建它的地方。
 
 #### 2.1 句法
 

docs/misc2/45.md

-# 没有 jaxb 批注的解组
+# 没有 jaxb 注解的解组
 
 > 原文： [https://howtodoinjava.com/jaxb/unmarshal-without-xmlrootelement/](https://howtodoinjava.com/jaxb/unmarshal-without-xmlrootelement/)
 
@@ -42,7 +42,7 @@ javax.xml.bind.UnmarshalException: unexpected element (uri:"", local:"employee")
 
 ```
 
-其中`Employee.java`类如下。 它没有任何[XGG1]这样的 JAXB 批注。
+其中`Employee.java`类如下。 它没有任何[XGG1]这样的 JAXB 注解。
 
 ```java
 package com.howtodoinjava.demo.model;
@@ -83,7 +83,7 @@ public class Employee implements Serializable {
 
 ## 2.不带 jaxb 注释的解组解决方案
 
-缺少`@XmlRootElement`批注时，JAXB 无法为`Employee`对象构建`JAXBElement`实例。 因此，您必须在此帮助 JAXB 手动构建它。
+缺少`@XmlRootElement`注解时，JAXB 无法为`Employee`对象构建`JAXBElement`实例。 因此，您必须在此帮助 JAXB 手动构建它。
 
 #### 2.1 句法
 

docs/misc2/47.md

@@ -67,7 +67,7 @@ public class Employee
 
 #### 1.2 对于 ANT 或其他项目类型
 
-对于非 Maven 用例，可以从 [Central Maven 存储库](https://repo1.maven.org/maven2/com/fasterxml/jackson/core/jackson-core/)下载 jar。
+对于非 Maven 用例，可以从 [Central Maven 仓库](https://repo1.maven.org/maven2/com/fasterxml/jackson/core/jackson-core/)下载 jar。
 
 ## 2.杰克逊 ObjectMapper
 
@@ -146,7 +146,7 @@ public class JavaToJSONExample
 
 ```
 
-## 4\. Jackson 漂亮打印 JSON 输出
+## 4\. Jackson 精美打印 JSON 输出
 
 如果看上面的输出，那么写在文本文件中的输出是非常原始的并且没有格式化。 您可以使用 ~~`defaultPrettyPrintingWriter()`~~ **`writerWithDefaultPrettyPrinter`** 实例编写格式化的 JSON 内容，如下所示：
 
@@ -186,7 +186,7 @@ public class JavaToPrettyJSONExample
 
 ```
 
-Program Output.
+程序输出：
 
 ```java
 {
@@ -236,7 +236,7 @@ public class JSONToJavaExample
 
 ```
 
-Program Output.
+程序输出：
 
 ```java
 Employee [id=1, firstName=Lokesh, lastName=Gupta]

docs/misc2/48.md

@@ -114,7 +114,7 @@ public class JSONToMap
 
 ```
 
-Program Output.
+程序输出：
 
 ```java
 {id=1, name=Lokesh Gupta, age=34, location=India}

docs/misc2/50.md

@@ -340,7 +340,7 @@ public class ParseUnknownXMLStructure
 
 ```
 
-Program Output.
+程序输出：
 
 ```java
 employees

docs/misc2/52.md

@@ -173,7 +173,7 @@ Root Element :: employees
 
 #### 读取属性值
 
-使用 Element.getAttributeValue（）方法。
+使用 Element.getAttributeValue()方法。
 
 ```java
 public static void main(String[] args) 

docs/misc2/59.md

@@ -114,7 +114,7 @@ XPath 数据模型中有七种节点：
 
 #### 2.6 处理指令节点
 
-**处理指令节点具有两个部分**，**名称**（由 name（）函数返回）和**字符串值**。 字符串值是名称`<?xml`之后的所有内容，包括空格，但不包括关闭处理指令的`?>`。
+**处理指令节点具有两个部分**，**名称**（由 name()函数返回）和**字符串值**。 字符串值是名称`<?xml`之后的所有内容，包括空格，但不包括关闭处理指令的`?>`。
 
 For example:
 

docs/misc2/64.md

@@ -8,7 +8,7 @@
 
 ## Java 程序使用 XPath 从 Java 中获得价值
 
-在给定的 Java 程序下面，从提供的 XML 字符串创建 DOM 对象。 然后，它使用 **XPath.selectNodes（）**方法应用 XPATH 表达式。
+在给定的 Java 程序下面，从提供的 XML 字符串创建 DOM 对象。 然后，它使用 **XPath.selectNodes()**方法应用 XPATH 表达式。
 
 方法返回`Element`实例的列表，这些实例是评估 XPath 表达式的结果。 您可以迭代列表并使用结果。
 

docs/misc2/65.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://howtodoinjava.com/xml/xpath-attribute-evaluate/](https://howtodoinjava.com/xml/xpath-attribute-evaluate/)
 
-**的简单示例，如何使用 Java 中的 [xpath](https://howtodoinjava.com/xml/java-xpath-tutorial-example/)** 获取 xml 中的属性值。 我们将学习获取信息以匹配*属性值*，*属性值在*范围内， **xpath 属性 contains（）**等。
+**的简单示例，如何使用 Java 中的 [xpath](https://howtodoinjava.com/xml/java-xpath-tutorial-example/)** 获取 xml 中的属性值。 我们将学习获取信息以匹配*属性值*，*属性值在*范围内， **xpath 属性 contains()**等。
 
 ## 1\. XPath 属性表达式
 

docs/misc2/72.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://howtodoinjava.com/eclipse/create-eclipse-templates-for-faster-java-coding/](https://howtodoinjava.com/eclipse/create-eclipse-templates-for-faster-java-coding/)
 
-我们大多数使用 **Eclipse IDE** 编写代码的人，都必须使用`main`或`sysout`之类的快捷方式，然后点击`CTRL+SPACE`，它将快捷方式转换为公共*静态 void main （字符串[] args）{…}* 和 *System.out.println（）*。 这是一项非常有用的功能，每当我为项目或教程编写代码时，我就一直使用它。
+我们大多数使用 **Eclipse IDE** 编写代码的人，都必须使用`main`或`sysout`之类的快捷方式，然后点击`CTRL+SPACE`，它将快捷方式转换为公共*静态 void main （字符串[] args）{…}* 和 *System.out.println()*。 这是一项非常有用的功能，每当我为项目或教程编写代码时，我就一直使用它。
 
 好消息是**，您也可以在此列表中添加自己的模板**，并利用此功能。 例如 解析作为参数传递的 XML 字符串是非常普遍的要求。 解析此类 XML 字符串的代码始终几乎相同。 我们可以为其创建模板，然后在需要时使用其快捷方式。
 

docs/misc2/73.md

@@ -41,7 +41,7 @@ Please note that deleting the files from above both folders does not impact any
 
 ## 3）不要使用 subclipse 插件
 
-该技术确实有效，但难以遵循。 它说您应该只在 eclipse 中使用代码来编写/修改和执行。 与 SVN / perforce 或任何代码存储库相关的所有其他事情都应在 eclipse 之外完成。 这可以来自命令行工具或任何可视客户端。
+该技术确实有效，但难以遵循。 它说您应该只在 eclipse 中使用代码来编写/修改和执行。 与 SVN / perforce 或任何代码仓库相关的所有其他事情都应在 eclipse 之外完成。 这可以来自命令行工具或任何可视客户端。
 
 Subversion 插件占用了过多的系统资源，严重影响了 Eclipse 的性能。
 

docs/misc2/78.md

@@ -4,11 +4,11 @@
 
 在上一篇文章中，我们对[集中版本控制系统](//howtodoinjava.com/2015/07/16/how-version-control-system-vcs-works/)进行了介绍。 在这篇文章中，我将向您介绍“ **分布式版本控制系统**”。
 
-与集中式 VCS 不同，在集中式 VCS 中，所有繁重的工作都在服务器端完成，并作为所有操作的单点操作，而客户端仅拥有代码库的工作副本。 在分布式 VCS 中，每个客户端（称为**合作者**）都有自己的本地存储库，大部分将在其本地存储库上工作。
+与集中式 VCS 不同，在集中式 VCS 中，所有繁重的工作都在服务器端完成，并作为所有操作的单点操作，而客户端仅拥有代码库的工作副本。 在分布式 VCS 中，每个客户端（称为**合作者**）都有自己的本地仓库，大部分将在其本地仓库上工作。
 
 ## 分布式版本控制系统如何工作？
 
-颠倒中央 VCS 的整个方法，**每个合作者将在其本地计算机上拥有完整的存储库，即完整的修订历史记录，所有分支，标签，提交信息都存在于本地计算机**上。 我们没有中央服务器的概念，但是我们可以将任何存储库配置为中央存储库，以将其视为真相来源并与 [**Jenkins**](https://jenkins-ci.org/) 之类的构建和部署工具集成 ]， [**厨师**](https://www.chef.io/) 等。
+颠倒中央 VCS 的整个方法，**每个合作者将在其本地计算机上拥有完整的仓库，即完整的修订历史记录，所有分支，标签，提交信息都存在于本地计算机**上。 我们没有中央服务器的概念，但是我们可以将任何仓库配置为中央仓库，以将其视为真相来源并与 [**Jenkins**](https://jenkins-ci.org/) 之类的构建和部署工具集成 ]， [**厨师**](https://www.chef.io/) 等。
 
 下面是不同协作者如何与分布式版本控制系统一起工作的框图。
 
@@ -20,12 +20,12 @@ Distributed VCS
 
 从上图可以看出，与传统的 VCS 不同，在分布式 VCS 中，我们的协作者在分散式系统中与其他协作者一起工作。
 
-在分布式 VCS 中，客户不仅仅签出文件的最新快照，还需要查看文件的最新快照。 而是完全镜像存储库。 因此，如果有任何服务器故障，并且这些系统通过它进行协作，则可以将任何客户端存​​储库复制回服务器以恢复该服务器。 每个克隆实际上都是所有数据的完整备份。
+在分布式 VCS 中，客户不仅仅签出文件的最新快照，还需要查看文件的最新快照。 而是完全镜像仓库。 因此，如果有任何服务器故障，并且这些系统通过它进行协作，则可以将任何客户端存​​储库复制回服务器以恢复该服务器。 每个克隆实际上都是所有数据的完整备份。
 
 另请注意，分布式 VCS 中使用的术语不同于集中式 VCS。 我们在中央 VCS 中使用“结帐”和“提交”的地方； 在分布式 VCS 中，我们使用“推”和“拉”。
 
-1.  **推送**：将更改发送到另一个存储库（可能需要许可）
-2.  **拉**：从存储库中获取更改
+1.  **推送**：将更改发送到另一个仓库（可能需要许可）
+2.  **拉**：从仓库中获取更改
 
 有很多分布式版本控制系统，例如 [**Git**](https://git-scm.com/) ， [**Mercurial**](https://mercurial.selenic.com/) 等。在即将发布的系列文章中，我将介绍 Git 并将 每当提到“分布式版本控制系统”时，都指的是 Git。
 
@@ -35,11 +35,11 @@ Distributed VCS
 
 #### 快速
 
-每个协作者都将代码库签出到其本地存储库中并在本地存储库上工作。 因此，由于不会有网络呼叫任何服务器，因此所有操作将很快进行。
+每个协作者都将代码库签出到其本地仓库中并在本地仓库上工作。 因此，由于不会有网络呼叫任何服务器，因此所有操作将很快进行。
 
 #### 便宜的分支和合并
 
-由于代码库位于本地硬盘上，因此创建分支和合并非常简单容易。 这是强大的功能之一，因为如果使用集中式存储库，则使用分支和合并太复杂了。
+由于代码库位于本地硬盘上，因此创建分支和合并非常简单容易。 这是强大的功能之一，因为如果使用集中式仓库，则使用分支和合并太复杂了。
 
 #### 本地分支
 
@@ -47,7 +47,7 @@ Distributed VCS
 
 #### 快照而不是差异
 
-这是主要好处之一。 我们可以为执行的每个提交获取完整的代码存储库。 因此，与中央 VCS 一样，我们可以轻松地恢复到任何提交，而无需手动应用来自基本版本的更改。
+这是主要好处之一。 我们可以为执行的每个提交获取完整的代码仓库。 因此，与中央 VCS 一样，我们可以轻松地恢复到任何提交，而无需手动应用来自基本版本的更改。
 
 #### 简单而高效的工具
 

docs/misc2/79.md

@@ -2,11 +2,11 @@
 
 > 原文： [https://howtodoinjava.com/vcs/how-version-control-system-vcs-works/](https://howtodoinjava.com/vcs/how-version-control-system-vcs-works/)
 
-如果您是开发人员或正在测试，则必须使用源代码存储库（也称为**版本控制系统**）。 您可能使用过 **CVS** ， **SVN** 和 **Perforce** 等。在本文中，我将带您了解版本控制系统的**基础 ]，这将有助于我们了解传统版本控制系统的主要优缺点。**
+如果您是开发人员或正在测试，则必须使用源代码仓库（也称为**版本控制系统**）。 您可能使用过 **CVS** ， **SVN** 和 **Perforce** 等。在本文中，我将带您了解版本控制系统的**基础 ]，这将有助于我们了解传统版本控制系统的主要优缺点。**
 
 ## 传统 VCS 的工作原理
 
-传统的 VCS 具有集中式服务器，该服务器充当源代码存储库。 除了存储代码外，这些工具还维护每次提交的修订历史记录。
+传统的 VCS 具有集中式服务器，该服务器充当源代码仓库。 除了存储代码外，这些工具还维护每次提交的修订历史记录。
 
 在下图中，我们有 3 个文件 A，B 和 C。 项目更改以四个方面提交，即初始提交，第二，第三和第四次提交。
 
@@ -32,11 +32,11 @@
 
 ## 传统 VCS 的缺点
 
-由于 VCS 驻留在服务器上，并且在托管代码，对文件进行版本控制，维护提交日志信息方面承担了所有繁重的工作，因此客户端仅被限制为获取代码的最新副本并工作，最后将所做的更改提交给客户端。 VCS。 客户端计算机上的代码仅仅是工作副本，而不是整个存储库本身。 现在让我们看看这种方法的主要缺点。 让我借助示例进行解释。
+由于 VCS 驻留在服务器上，并且在托管代码，对文件进行版本控制，维护提交日志信息方面承担了所有繁重的工作，因此客户端仅被限制为获取代码的最新副本并工作，最后将所做的更改提交给客户端。 VCS。 客户端计算机上的代码仅仅是工作副本，而不是整个仓库本身。 现在让我们看看这种方法的主要缺点。 让我借助示例进行解释。
 
-1.  假设有 5 个开发人员正在使用 VCS，并且他们都使用功能并将更改提交到存储库。 不幸的是，VCS 崩溃，并且没有备份。 我们剩下的是使用最后一次稳定的提交来还原 VCS。 现在，由于修订历史记录和提交日志都保存在 VCS 服务器上，并且开发人员计算机上存在的代码库只是普通的工作副本，因此我们无法自信地将 VCS 置于上一个提交状态。
+1.  假设有 5 个开发人员正在使用 VCS，并且他们都使用功能并将更改提交到仓库。 不幸的是，VCS 崩溃，并且没有备份。 我们剩下的是使用最后一次稳定的提交来还原 VCS。 现在，由于修订历史记录和提交日志都保存在 VCS 服务器上，并且开发人员计算机上存在的代码库只是普通的工作副本，因此我们无法自信地将 VCS 置于上一个提交状态。
 2.  这是我们遇到的常见情况。 我们执行的几乎所有操作（如检查文件差异，提交，合并等）都只能在 VCS 启动时执行。 由于某些原因，如果 VCS 暂时关闭，例如网络中断，服务器维护，则将阻止所有访问 VCS 的用户。 即使简单的操作（如将文件与以前的版本进行比较）也无法完成。
-3.  这种集中式存储库的另一个缺点是与分支有关。 当我们在进行项目时，我们有主干或主分支，它们被认为是事实的来源，将被用于与诸如 Jenkins 之类的构建工具集成。 为了进行开发，我们从主干创建一个分支，在该分支上工作，然后在该分支上进行测试，最后将所做的更改合并回创建标记的主干，并最终将其推送进行部署。 请注意，分支是在服务器上创建的。 另外，如果两个开发人员希望使用某个功能并希望彼此合作而不影响其他人的代码，那么他们将不得不求助于分支机构，该分支机构又将位于服务器上。 因此，在一段时间内，服务器将充满许多分支。
+3.  这种集中式仓库的另一个缺点是与分支有关。 当我们在进行项目时，我们有主干或主分支，它们被认为是事实的来源，将被用于与诸如 Jenkins 之类的构建工具集成。 为了进行开发，我们从主干创建一个分支，在该分支上工作，然后在该分支上进行测试，最后将所做的更改合并回创建标记的主干，并最终将其推送进行部署。 请注意，分支是在服务器上创建的。 另外，如果两个开发人员希望使用某个功能并希望彼此合作而不影响其他人的代码，那么他们将不得不求助于分支机构，该分支机构又将位于服务器上。 因此，在一段时间内，服务器将充满许多分支。
 4.  VCS 的另一个缺点是可伸缩性。 想象一下在一个开源项目中工作，在该项目中成千上万的开发人员需要工作，并且创建了成千上万的分支机构。 合并更改和管理分支机构是一场噩梦，而传统的版本控制系统是无法实现的。
 
 集中版本控制工具在软件开发中扮演着重要的角色，并将继续发挥作用，但是当项目发展壮大时，对于高可用性和关键项目，这可能不是最佳解决方案，因为还有其他更好的选择。 了解集中式 VCS 的弊端有助于我们确定促使我们探索其他选项的因素，例如**分布式版本控制系统**，例如 **Git** ， **Mercurial** 等 。

docs/misc2/89.md

@@ -43,7 +43,7 @@ When someone says “web server” you often think HTTP-centric, web UI oriented
 
 ## 什么是 Servlet？ 他们如何提供帮助？
 
-在 Java 中， **servlet 使您可以编写服务器端组件，以根据请求帮助生成动态内容**。 实际上，Servlet 是在 javax.servlet 包中定义的接口。 它声明了 Servlet 生命周期的三种基本方法 -init（），service（）和 destroy（）。 它们由每个 servlet（在 SDK 中定义或由用户定义）实现，并在服务器的生命周期中由服务器在特定时间调用。
+在 Java 中， **servlet 使您可以编写服务器端组件，以根据请求帮助生成动态内容**。 实际上，Servlet 是在 javax.servlet 包中定义的接口。 它声明了 Servlet 生命周期的三种基本方法 -init()，service()和 destroy()。 它们由每个 servlet（在 SDK 中定义或由用户定义）实现，并在服务器的生命周期中由服务器在特定时间调用。
 
 Servlet 类由其类加载器通过**延迟加载或急切加载**动态地加载到容器中。 **每个请求都在其自己的线程**中，并且 servlet 对象可以同时服务多个线程。 当不再使用它时，它将被 JVM 垃圾回收。
 
@@ -69,7 +69,7 @@ Servlet 容器连接到 Web 服务器，该服务器在特定端口号（通常
 
 ## 如何管理会话？ 知道 cookie 吗？
 
-当客户端首次访问 Web 应用和/或要通过 request.getSession（）首次获取 HttpSession 时，则 Servlet 容器将创建它，并生成一个长而唯一的 ID（您可以 通过 session.getId（）获取并存储在服务器的内存中。 servlet 容器还将在 HTTP 响应中设置 Cookie，其中 **JSESSIONID** 为 cookie 名称，唯一会话 ID 为 cookie 值。
+当客户端首次访问 Web 应用和/或要通过 request.getSession()首次获取 HttpSession 时，则 Servlet 容器将创建它，并生成一个长而唯一的 ID（您可以 通过 session.getId()获取并存储在服务器的内存中。 servlet 容器还将在 HTTP 响应中设置 Cookie，其中 **JSESSIONID** 为 cookie 名称，唯一会话 ID 为 cookie 值。
 
 根据 [**HTTP cookie 规范**](http://www.faqs.org/rfcs/rfc2965.html "http cookie") （体面的 Web 浏览器和 Web 服务器必须遵守的合同），要求客户端（Web 浏览器）在后续请求中将该 Cookie 发送回 只要 Cookie 有效即可。 Servlet 容器将确定每个传入的 HTTP 请求标头中是否存在名为 JSESSIONID 的 cookie，并使用其值从服务器的内存中获取关联的 HttpSession。
 
@@ -83,7 +83,7 @@ HttpSession 会一直存在，直到没有被使用为止，您可以在 web.xml
 
 ![New session](img/adf2d37562aa73ff0230458f2450106e.png)
 
-另一方面，客户端上的会话 cookie **具有默认生存期，该生存期只要浏览器实例正在运行**即可。 因此，当客户端关闭浏览器实例（所有选项卡/窗口）时，会话将在客户端被丢弃。 在新的浏览器实例中，与该会话关联的 cookie 将不再发送。 一个新的 request.getSession（）将返回一个全新的 HttpSession 并设置一个具有全新会话 ID 的 cookie。
+另一方面，客户端上的会话 cookie **具有默认生存期，该生存期只要浏览器实例正在运行**即可。 因此，当客户端关闭浏览器实例（所有选项卡/窗口）时，会话将在客户端被丢弃。 在新的浏览器实例中，与该会话关联的 cookie 将不再发送。 一个新的 request.getSession()将返回一个全新的 HttpSession 并设置一个具有全新会话 ID 的 cookie。
 
 ## 应如何确保线程安全？
 

docs/misc2/9.md

@@ -8,7 +8,7 @@
 
 步骤 1）[创建一个 Maven 项目](//howtodoinjava.com/maven/create-a-simple-java-project-using-maven/ "Create a simple java project using maven")并将其转换为 Eclipse Java 项目。
 
-步骤 2）使用 Spring3 和 hornetq 依赖项更新 maven 存储库。
+步骤 2）使用 Spring3 和 hornetq 依赖项更新 maven 仓库。
 
 ```java
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

docs/misc2/93.md

@@ -54,7 +54,7 @@ Swagger2 Project Structure
 
     
 
-    将项目解压缩并将其作为现有的 maven 项目导入 Eclipse。 在此步骤中，将从 maven 存储库下载所有必需的依赖项。 在此步骤中执行全新的`mvn clean install`，以便正确下载所有与春季启动相关的工件。
+    将项目解压缩并将其作为现有的 maven 项目导入 Eclipse。 在此步骤中，将从 maven 仓库下载所有必需的依赖项。 在此步骤中执行全新的`mvn clean install`，以便正确下载所有与春季启动相关的工件。
 
 2.  打开`application.properties`并添加以下属性。 这将在`/swagger2-demo`上下文路径中启动应用。
 

docs/misc2/97.md

@@ -169,7 +169,7 @@ public enum EnumSingleton {
 
 ```
 
-## 6.将 readResolve（）添加到 Singleton 对象
+## 6.将 readResolve()添加到 Singleton 对象
 
 到目前为止，您必须已经决定如何实现单例。 现在，让我们看看即使在面试中也可能出现的其他问题。
 
@@ -333,5 +333,5 @@ public class DemoSingleton implements Serializable {
 
 **实时单例示例** – 我只是想添加一些示例，以供进一步研究和在访谈中提及：
 
-*   [java.awt.Desktop＃getDesktop（）](https://docs.oracle.com/javase/6/docs/api/java/awt/Desktop.html#getDesktop%28%29 "Desktop singelton")
-*   [java.lang.Runtime＃getRuntime（）](https://docs.oracle.com/javase/6/docs/api/java/lang/Runtime.html#getRuntime%28%29 "runtime")
\ No newline at end of file
+*   [java.awt.Desktop＃getDesktop()](https://docs.oracle.com/javase/6/docs/api/java/awt/Desktop.html#getDesktop%28%29 "Desktop singelton")
+*   [java.lang.Runtime＃getRuntime()](https://docs.oracle.com/javase/6/docs/api/java/lang/Runtime.html#getRuntime%28%29 "runtime")
\ No newline at end of file

docs/misc2/98.md

@@ -204,13 +204,13 @@ User: Super, Man, 0, null, null
 
 [java.lang.Appendable](https://docs.oracle.com/javase/7/docs/api/java/lang/Appendable.html "Appendable") 的所有实现实际上都是在 Java 中使用 Builder 模式的良好示例。 例如
 
-[java.lang.StringBuilder＃append（）](https://docs.oracle.com/javase/7/docs/api/java/lang/StringBuilder.html#append%28java.lang.CharSequence%29 "StringBuilder") [未同步的类]
+[java.lang.StringBuilder＃append()](https://docs.oracle.com/javase/7/docs/api/java/lang/StringBuilder.html#append%28java.lang.CharSequence%29 "StringBuilder") [未同步的类]
 
-[java.lang.StringBuffer＃append（）](https://docs.oracle.com/javase/1.5.0/docs/api/java/lang/StringBuffer.html#append%28java.lang.CharSequence%29 "StringBuffer") [同步类]
+[java.lang.StringBuffer＃append()](https://docs.oracle.com/javase/1.5.0/docs/api/java/lang/StringBuffer.html#append%28java.lang.CharSequence%29 "StringBuffer") [同步类]
 
-[java.nio.ByteBuffer＃put（）](https://docs.oracle.com/javase/6/docs/api/java/nio/ByteBuffer.html#put%28java.nio.ByteBuffer%29 "ByteBuffer")（也在 CharBuffer，ShortBuffer，IntBuffer，LongBuffer，FloatBuffer 和 DoubleBuffer 上）
+[java.nio.ByteBuffer＃put()](https://docs.oracle.com/javase/6/docs/api/java/nio/ByteBuffer.html#put%28java.nio.ByteBuffer%29 "ByteBuffer")（也在 CharBuffer，ShortBuffer，IntBuffer，LongBuffer，FloatBuffer 和 DoubleBuffer 上）
 
-另一种用法可以在 [javax.swing.GroupLayout.Group＃addComponent（）](https://docs.oracle.com/javase/6/docs/api/javax/swing/GroupLayout.Group.html#addComponent%28java.awt.Component%29 "GroupLayout")中找到。
+另一种用法可以在 [javax.swing.GroupLayout.Group＃addComponent()](https://docs.oracle.com/javase/6/docs/api/javax/swing/GroupLayout.Group.html#addComponent%28java.awt.Component%29 "GroupLayout")中找到。
 
 看看这些实现与我们上面讨论的相似。
 

docs/misc2/99.md

@@ -223,10 +223,10 @@ designPatterns.creational.factory.LuxuryCar@e9bfee2
 
 **工厂模式最适合涉及一些复杂的对象创建步骤的地方**。 为确保这些步骤集中进行，并且不暴露于编写类中，应使用工厂模式。 我们可以在 JDK 本身中看到许多实时的工厂模式示例，例如
 
-*   [java.sql.DriverManager＃getConnection（）](https://docs.oracle.com/javase/10/docs/api/java/sql/DriverManager.html#getConnection%28java.lang.String%29 "driver manager get connection")
-*   [java.net.URL＃openConnection（）](https://docs.oracle.com/javase/10/docs/api/java/net/URL.html#openConnection%28%29 "url open connection")
-*   [java.lang.Class＃newInstance（）](https://docs.oracle.com/javase/10/docs/api/java/lang/Class.html#newInstance%28%29 "class new instance")
-*   [java.lang.Class＃forName（）](https://docs.oracle.com/javase/10/docs/api/java/lang/Class.html#forName%28java.lang.String%29 "class forname")
+*   [java.sql.DriverManager＃getConnection()](https://docs.oracle.com/javase/10/docs/api/java/sql/DriverManager.html#getConnection%28java.lang.String%29 "driver manager get connection")
+*   [java.net.URL＃openConnection()](https://docs.oracle.com/javase/10/docs/api/java/net/URL.html#openConnection%28%29 "url open connection")
+*   [java.lang.Class＃newInstance()](https://docs.oracle.com/javase/10/docs/api/java/lang/Class.html#newInstance%28%29 "class new instance")
+*   [java.lang.Class＃forName()](https://docs.oracle.com/javase/10/docs/api/java/lang/Class.html#forName%28java.lang.String%29 "class forname")
 
 希望我在此 **Java 工厂模式示例**中包含了足够的信息，以使该帖子内容丰富。