2019-11-23 20:42:11

docs/114.md

@@ -4,7 +4,7 @@
 
 本示例演示了如何使用 Servlet 的 doPost（）方法来处理 POST 请求
 
-在我们以前的教程[的 Java Servlet 实施例](https://javatutorial.net/java-servlet-example)我展示了 doGet（）方法的使用。 现在，我将向您展示如何使用 doPost（）方法来处理表单 POST 提交。 Java Servlet 可以处理各种类型的请求。 下面的列表显示了所有方法及其用途
+在我们以前的教程[的 Java Servlet 实现例](https://javatutorial.net/java-servlet-example)我展示了 doGet（）方法的使用。 现在，我将向您展示如何使用 doPost（）方法来处理表单 POST 提交。 Java Servlet 可以处理各种类型的请求。 下面的列表显示了所有方法及其用途
 
 | **方法** | **SERVLET 方法** | **目的** |
 | 得到 | **doGet（）** | 在指定的 URL 检索资源 |

docs/122.md

@@ -90,7 +90,7 @@ Java 文件上传表格
 </project>
 ```
 
-现在拥有所有必需的库，让我们继续实施 REST 服务。 下面的代码中有几个地方我想提醒您注意。 首先请注意@Consumes（MediaType.MULTIPART_FORM_DATA）作为请求的编码类型的用法。 其次，如果愿意，您可能希望向该方法添加其他参数。 例如，您可能要在上传时传递一些描述或其他文本数据。 最后，如果您尝试将文件上传到不存在的目录中，Java 将抛出异常。 为了避免这个问题，我创建了方法 createFolderIfNotExists（StringdirName）。
+现在拥有所有必需的库，让我们继续实现 REST 服务。 下面的代码中有几个地方我想提醒您注意。 首先请注意@Consumes（MediaType.MULTIPART_FORM_DATA）作为请求的编码类型的用法。 其次，如果愿意，您可能希望向该方法添加其他参数。 例如，您可能要在上传时传递一些描述或其他文本数据。 最后，如果您尝试将文件上传到不存在的目录中，Java 将抛出异常。 为了避免这个问题，我创建了方法 createFolderIfNotExists（StringdirName）。
 
 ```java
 package net.javatutorial.tutorials.services;

docs/123.md

@@ -90,7 +90,7 @@
 
 ```
 
-## 实施 Websocket 服务器
+## 实现 Websocket 服务器
 
 我将使用 Glassfish 4.1 部署 WebSocket 服务器。 我们将使用 Jetty 9.x 作为 Websocket 服务器，而 Glassfish 已在 Jetty 中内置。 我们将使用的另一个 API 是 JSON API，它也是 Glassfish 4 的一部分。请查看下面的 Maven pom 文件以获取所需的依赖关系
 

docs/124.md

@@ -52,7 +52,7 @@ CREATE TABLE `user_groups` (
 
 ## 项目结构
 
-在开始实施项目的后端部分之前，我想向您展示项目结构。 这样，您将知道所有文件所在的位置
+在开始实现项目的后端部分之前，我想向您展示项目结构。 这样，您将知道所有文件所在的位置
 
 ![](img/7a9e5e0c8bc0b6c412ed33d495753d4d.jpg)
 

docs/127.md

@@ -4,7 +4,7 @@
 
 本指南向您展示如何在 Eclipse 中安装 Spring Tool Suite
 
-[STS](https://spring.io/tools/sts) 代表 **Spring Tool Suite** 。 它提供了使用 Eclipse [IDE](https://javatutorial.net/choose-your-java-ide-eclipse-netbeans-and-intellij-idea) 来实施，运行，调试和部署 Spring 应用程序的现成环境。 它是一个强大的环境，它将帮助您使 Spring 开发更快，更轻松。
+[STS](https://spring.io/tools/sts) 代表 **Spring Tool Suite** 。 它提供了使用 Eclipse [IDE](https://javatutorial.net/choose-your-java-ide-eclipse-netbeans-and-intellij-idea) 来实现，运行，调试和部署 Spring 应用程序的现成环境。 它是一个强大的环境，它将帮助您使 Spring 开发更快，更轻松。
 
 ## 如何在 Eclipse 中安装 Spring Tool Suite
 

docs/135.md

@@ -16,7 +16,7 @@
 
 首先，我说过我们需要实现 HandlerInterceptor 接口，但是我们也可以实现 HandlerInterceptorAdapter 。 它们之间有 1 个区别，就是 HandlerInterceptor 我们必须覆盖我上面提到的所有三种方法，而 HandlerInterceptorAdapter 允许我们仅覆盖所需的方法 方法。
 
-### 代码实施
+### 代码实现
 
 通常，这 3 种方法的工作流程会引发 Exception **或返回 true 的**。
 

docs/139.md

@@ -36,7 +36,7 @@ public class Employee{
 }
 ```
 
-您能明白为什么第二个例子更好吗？ 因为现在员工无需担心公司的实现，所以它将独立于员工实施，并将提供给员工 ]通过构造函数，换句话说，是在 Employee 初始化时。 换句话说，如果没有公司的一部分，员工将无法生存。 否则，他就不会当雇员。
+您能明白为什么第二个例子更好吗？ 因为现在员工无需担心公司的实现，所以它将独立于员工实现，并将提供给员工 ]通过构造函数，换句话说，是在 Employee 初始化时。 换句话说，如果没有公司的一部分，员工将无法生存。 否则，他就不会当雇员。
 
 依赖项（公司）通过构造函数注入到 Employee 类中。
 

docs/140.md

@@ -6,7 +6,7 @@
 
 在我以前的教程[中，使用 STS 创建简单的 Spring Web App](https://javatutorial.net/spring-web-app-sts) ，我向您展示了如何构建引入控制器的 Spring Boot App。 本教程是对上一个教程的扩展。
 
-在开始实施之前，让我们快速概述一下控制器如何参与 MVC 工作流程。
+在开始实现之前，让我们快速概述一下控制器如何参与 MVC 工作流程。
 
 ![Spring MVC architecture workflow](img/8805b0798732fff068dcb2d8db411870.jpg)
 

docs/142.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://javatutorial.net/what-is-dao-and-how-to-to-use-it](https://javatutorial.net/what-is-dao-and-how-to-use-it)
 
-在开始实施这些类之前，我们首先要了解什么是 DAO。 如果您已经知道 DAO 是什么，请随时跳转至代码示例。 如果没有，请忍受我。
+在开始实现这些类之前，我们首先要了解什么是 DAO。 如果您已经知道 DAO 是什么，请随时跳转至代码示例。 如果没有，请忍受我。
 
 ![spring-featured-image](img/d2f73752d8ae931b119dec1eac866973.jpg)
 

docs/149.md

@@ -16,11 +16,11 @@
 
 有两种方法可以防止 CSRF。
 
-其中之一是通过实施相同的来源策略。 根据此策略，Web 浏览器允许一个网页中包含的脚本访问另一个网页**中的数据，但前提是两个网页具有相同的来源。** 此方法取决于 [HTTP Cookies](https://en.wikipedia.org/wiki/HTTP_cookie) 。
+其中之一是通过实现相同的来源策略。 根据此策略，Web 浏览器允许一个网页中包含的脚本访问另一个网页**中的数据，但前提是两个网页具有相同的来源。** 此方法取决于 [HTTP Cookies](https://en.wikipedia.org/wiki/HTTP_cookie) 。
 
 另一个是通过应用每个会话/每个请求令牌来过滤作为 CSRF 攻击而来的请求。
 
-## Spring 实施中如何防止 CSRF
+## Spring 实现中如何防止 CSRF
 
 ```java
 public class TokenFilter extends OncePerRequestFilter {

docs/15.md

@@ -193,6 +193,6 @@ Yummy! you eat some raspberry
 
 我们无法执行石头对象的 eat 方法，因为它不是`Eatable`类型。
 
-## 免责声明
+## 结论
 
 可以使用[抽象类](https://javatutorial.net/java-abstraction-example)，[集合](https://javatutorial.net/java-collection-tutorial)和[继承](https://javatutorial.net/java-inheritance-example)以更时髦的方式编写上面的代码示例。 其中一些是更高级的主题，将在下一个教程中进行说明。 这是一个初学者教程，旨在仅说明 Java 接口。
\ No newline at end of file

docs/156.md

@@ -51,7 +51,7 @@ public class Example {
 4.  抛出建议后：仅在连接点方法抛出异常时才运行这些建议（与“返回建议之后”相反）。 要将建议类型标记为“抛后”，我们可以使用@AfterThrowing 批注。
 5.  围绕建议：这些建议为我们提供了灵活性，因为借助它们的使用，我们可以选择是否执行连接点方法。
 
-让我们看看如何实施这些不同的建议类型。
+让我们看看如何实现这些不同的建议类型。
 
 **咨询之前**
 
@@ -85,7 +85,7 @@ public class AfterAdviceDemo{
 }
 ```
 
-与“建议之前”实施非常相似，只有我们将“之前”替换为“之后”。
+与“建议之前”实现非常相似，只有我们将“之前”替换为“之后”。
 
 **返回建议后**
 

docs/176.md

@@ -227,7 +227,7 @@ public class DataBaseHelper extends SQLiteOpenHelper {
 
 ## 步骤 3：创建登录数据库类
 
-登录数据库是一类，您在其中实现所有数据库编码。 首先使用四个字段创建用于登录的表，然后实施所有其他方法。
+登录数据库是一类，您在其中实现所有数据库编码。 首先使用四个字段创建用于登录的表，然后实现所有其他方法。
 
 ```java
 package com.example.admin.androiddatabaseexample;

docs/59.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://javatutorial.net/java-hashset-example](https://javatutorial.net/java-hashset-example)
 
-使用哈希表进行存储的集合通常由 Java HashSet 类创建。 顾名思义，HashSet 实现 Set 接口，并且还使用一个哈希表，该哈希表是 HashMap 实例。 HashSet 中元素的顺序是随机的。 此类允许使用 null 元素。 就复杂性而言，HashSet 为基本操作（如添加，删除，包含和大小）提供恒定的时间性能，前提是假定元素已被函数正确分散。
+使用哈希表进行存储的集合通常由 Java HashSet 类创建。 顾名思义，HashSet 实现 Set 接口，并且还使用一个哈希表，该哈希表是 HashMap 实例。 HashSet 中元素的顺序是随机的。 此类允许使用 null 元素。 就复杂度而言，HashSet 为基本操作（如添加，删除，包含和大小）提供恒定的时间性能，前提是假定元素已被函数正确分散。
 
 ![java-featured-image](img/e0db051dedc1179e7424b6d998a6a772.jpg)
 
@@ -13,7 +13,7 @@
 *   HashSet 允许为空值。
 *   HashSet 类不同步。
 *   HashSet 的顺序不由插入顺序维护。 元素（在此类中）是根据其哈希码插入的。
-*   就搜索操作而言，由于 HashSet 具有恒定的时间复杂性，因此它是最好的方法。
+*   就搜索操作而言，由于 HashSet 具有恒定的时间复杂度，因此它是最好的方法。
 *   HashSet 的初始默认容量为 16，而负载系数为 0.75。
 
 ## `HashSet`简单的结构图

docs/60.md

-# Java TreeSet 示例
+# Java `TreeSet`示例
 
 > 原文： [https://javatutorial.net/java-treeset-example](https://javatutorial.net/java-treeset-example)
 
-Java TreeSet 类是一个基于 [TreeMap](https://docs.oracle.com/javase/8/docs/api/java/util/TreeMap.html) 的 [NavigableSet](https://docs.oracle.com/javase/8/docs/api/java/util/NavigableSet.html) 实现。 元素可以通过[比较器](https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html)进行排序，也可以仅通过其自然排序进行排序。 在复杂性方面，此实现为所有基本操作（例如添加，删除，包含）提供了 log（n）时间成本。
+Java TreeSet 类是一个基于 [TreeMap](https://docs.oracle.com/javase/8/docs/api/java/util/TreeMap.html) 的 [NavigableSet](https://docs.oracle.com/javase/8/docs/api/java/util/NavigableSet.html) 实现。 元素可以通过[比较器](https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html)进行排序，也可以仅通过其自然排序进行排序。 在复杂度方面，此实现为所有基本操作（例如添加，删除，包含）提供了 log（n）时间成本。
 
 ![java-featured-image](img/e0db051dedc1179e7424b6d998a6a772.jpg)
 
-## 关于 Java 中的 TreeSet 的重要知识
+## 关于 Java 中的`TreeSet`的重要知识
 
 *   TreeSet 实现 SortedSet 接口，这意味着不允许重复值。
 *   异构对象不能插入 TreeSet 中，因为它不允许这样做。 它将在运行时引发 classCastException。
 *   TreeSet 类不保留元素的插入顺序，但是元素按其键排序。
 *   TreeSet 中的元素以升序和排序顺序存储。
 
-## Java 中 TreeSet 的局限性
+## Java 中`TreeSet`的局限性
 
 *   值必须是可比较的，或者需要在构造函数中提供比较器
 
-## TreeSet 的简单说明
+## `TreeSet`的简单说明
 
 ![This diagram shows the inheritance diagram](img/80a537da566b5a3522a88128f3a7fdc2.jpg)
 
 继承图
 
-## TreeSet 中的构造方法
+## `TreeSet`中的构造方法
 
 1.  TreeSet（）：构造一个新的空树集，并根据其元素的自然顺序进行排序
 2.  TreeSet（Collection <？扩展 E > c）：构造一个新树集，该树集包含指定集合中的元素，并根据其元素的自然顺序对其进行排序。
 3.  TreeSet（Comparator <？super E >比较器）：构造一个空树集，该树集根据指定的比较器排序。
 4.  TreeSet（SortedSet < E > s）：构造一个与指定集合完全相同的新树集，包括元素的顺序。
 
-## TreeSet 中的方法
+## `TreeSet`中的方法
 
 1.  void add（Object o）：根据 TreeSet 中的某些排序顺序添加指定的元素。 不会添加重复项。
 2.  void clear（）：从树集中删除所有元素。
@@ -45,7 +45,7 @@ Java TreeSet 类是一个基于 [TreeMap](https://docs.oracle.com/javase/8/docs/
 
 有关所有方法的文档，请访问 [Oracle 官方文档页面](https://docs.oracle.com/javase/8/docs/api/?java/util/TreeSet.html)。
 
-### 使用 add（）在 TreeSet 中添加元素
+### 使用`add()`在`TreeSet`中添加元素
 
 语法：treeSet.add（对象 o）
 
@@ -73,7 +73,7 @@ public class TreeSetExample {
 TreeSet: [Elephant, Tiger, Lion]
 ```
 
-### 使用 first（）和 last（）获取 TreeSet 的第一个和最后一个元素
+### 使用`first()`和`last()`获取`TreeSet`的第一个和最后一个元素
 
 句法：
 
@@ -109,7 +109,7 @@ The first element: Elephant
 The last element: Lion
 ```
 
-### 使用 contains（）检查元素是否在树集中
+### 使用`contains()`检查元素是否在树集中
 
 语法：treeSet.contains（对象元素）
 
@@ -141,7 +141,7 @@ Is 'Cat' in the tree set? false
 Is 'Lion' in the tree set? true
 ```
 
-### 使用 remove（）从树集中删除一个元素
+### 使用`remove()`从树集中删除一个元素
 
 语法：treeSet.remove（Object o）
 
@@ -173,7 +173,7 @@ TreeSet: [Elephant, Tiger, Lion]
 TreeSet: [Tiger]
 ```
 
-### 使用 size（）获取树集中的元素数量
+### 使用`size()`获取树集中的元素数量
 
 语法：treeSet.size（）
 
@@ -204,7 +204,7 @@ TreeSet: [Elephant, Tiger, Lion]
 The size of the tree set is: 3
 ```
 
-### 使用 isEmpty（）检查树集是否为空
+### 使用`isEmpty()`检查树集是否为空
 
 语法：treeSet.isEmpty（）
 
@@ -240,7 +240,7 @@ Empty: false
 Empty: true
 ```
 
-## 使用 Iterator（）遍历树集
+## 使用`Iterator()`遍历树集
 
 句法：
 
@@ -283,7 +283,7 @@ Tiger
 Lion
 ```
 
-## 使用增强的 for 循环遍历树集
+## 使用增强的`for`循环遍历树集
 
 句法：
 

docs/61.md

-# Java LinkedHashSet 示例
+# Java `LinkedHashSet`示例
 
 > 原文： [https://javatutorial.net/java-linkedhashset-example](https://javatutorial.net/java-linkedhashset-example)
 
@@ -6,7 +6,7 @@ Java 中的 LinkedHashSet 类与 [HashSet](https://javatutorial.net/java-hashset
 
 ![java-featured-image](img/e0db051dedc1179e7424b6d998a6a772.jpg)
 
-## LinkedHashSet 的优点
+## `LinkedHashSet`的优点
 
 *   LinkedHashSet 维护元素的插入顺序
 *   插入，删除和检索操作的时间复杂度为 O（1）（恒定时间）。
@@ -19,14 +19,14 @@ Java 中的 LinkedHashSet 类与 [HashSet](https://javatutorial.net/java-hashset
 
 LinkedHashSet 的继承图
 
-## LinkedHashSet 中的构造方法
+## `LinkedHashSet`中的构造方法
 
 1.  LinkedHashSet（）：初始化一个新的链接哈希集，默认初始容量为 16，负载因子为 0.75。
 2.  LinkedHashSet（Collection <？Extended E > c）：使用与指定集合相同的元素初始化一个新的链接哈希集。
 3.  LinkedHashSet（int initialCapacity）：使用指定的初始容量初始化一个新的链接哈希集。
 4.  LinkedHashSet（int initialCapacity，float loadFactor）：使用指定的容量和负载因子初始化一个新的链接哈希集。
 
-## LinkedHashSet 中的方法
+## `LinkedHashSet`中的方法
 
 1.  从类 java.util.HashSet 继承的方法：[添加](https://docs.oracle.com/javase/7/docs/api/java/util/HashSet.html#add(E))，[清除](https://docs.oracle.com/javase/7/docs/api/java/util/HashSet.html#clear())，[克隆](https://docs.oracle.com/javase/7/docs/api/java/util/HashSet.html#clone())，[包含](https://docs.oracle.com/javase/7/docs/api/java/util/HashSet.html#contains(java.lang.Object))， [isEmpty](https://docs.oracle.com/javase/7/docs/api/java/util/HashSet.html#isEmpty()) ， [迭代器](https://docs.oracle.com/javase/7/docs/api/java/util/HashSet.html#iterator())，[删除](https://docs.oracle.com/javase/7/docs/api/java/util/HashSet.html#remove(java.lang.Object))，[大小](https://docs.oracle.com/javase/7/docs/api/java/util/HashSet.html#size())
 2.  从类 java.util.AbstractSet 继承的方法：[等于](https://docs.oracle.com/javase/7/docs/api/java/util/AbstractSet.html#equals(java.lang.Object))， [hashCode](https://docs.oracle.com/javase/7/docs/api/java/util/AbstractSet.html#hashCode()) ， [removeAll](https://docs.oracle.com/javase/7/docs/api/java/util/AbstractSet.html#removeAll(java.util.Collection))
@@ -36,7 +36,7 @@ LinkedHashSet 的继承图
 
 有关所有方法的文档，请访问 [Oracle 官方文档页面](https://docs.oracle.com/javase/7/docs/api/java/util/LinkedHashSet.html)。
 
-## 使用 Iterator（）在 LinkedHashSet 中进行迭代
+## 使用`Iterator()`迭代`LinkedHashSet`
 
 ```java
 import java.util.*;  
@@ -63,7 +63,7 @@ Tiger
 Lion
 ```
 
-## **使用 Fo​​r 循环**遍历 LinkedHashSet
+## 使用`Fo​​r`循环遍历`LinkedHashSet`
 
 ```java
 LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();
@@ -72,7 +72,7 @@ for (int i = 0; i < linkedHashSet.size(); i++) {
 }
 ```
 
-## 使用 Enchanced For 循环遍历 LinkedHashSet
+## 使用增强`For`循环遍历`LinkedHashSet`
 
 ```java
 for (String temp : linkedHashSet) {
@@ -80,7 +80,7 @@ for (String temp : linkedHashSet) {
 }
 ```
 
-## 使用 While 循环遍历 LinkedHashSet
+## 使用`While`循环遍历`LinkedHashSet`
 
 ```java
 int i = 0;
@@ -90,7 +90,7 @@ while (i < linkedHashSet.size()) {
 }
 ```
 
-## 使用 LinkedHashSet 的示例程序
+## `LinkedHashSet`的示例程序
 
 ```java
 import java.util.LinkedHashSet;   

docs/63.md

-# Java ConcurrentHashSet 示例
+# Java `ConcurrentHashSet`示例
 
 > 原文： [https://javatutorial.net/java-concurrenthashset-example](https://javatutorial.net/java-concurrenthashset-example)
 
@@ -12,7 +12,7 @@ Java 并发 API 中包含许多 Collection 类，例如 ArrayList 的 CopyOnArra
 
 还有其他尝试创建 ConcurrentHashSet 的即兴创作，但现在它们都已过去，因为 Java 8 添加了 newKeySet（），它返回由 ConcurrentHashMap 支持的 Set。
 
-### 如何在 Java 8 中创建 ConcurrentHashSet
+### 如何在 Java 8 中创建`ConcurrentHashSet`
 
 ```java
 ConcurrentHashMap<String, Integer> example = new ConcurrentHashMap<>(); 
@@ -28,7 +28,7 @@ exampleSet.remove("example");
 
 **注意：** 这是在 Java 中创建线程安全 Set 的唯一方法。
 
-### **Java 程序使用 java.util.concurrent.ConcurrentHashMap 类上添加的新方法创建 ConcurrentHashSet。**
+### Java 程序使用`java.util.concurrent.ConcurrentHashMap`类上添加的新方法创建 ConcurrentHashSet。
 
 ```java
 import java.util.Set; 

docs/64.md

-# Java HashMap 示例
+# Java `HashMap`示例
 
 > 原文： [https://javatutorial.net/java-hashmap-example](https://javatutorial.net/java-hashmap-example)
 
@@ -6,7 +6,7 @@
 
 ![java-featured-image](img/e0db051dedc1179e7424b6d998a6a772.jpg)
 
-## 为什么 HashMap 重要和有用
+## 为什么`HashMap`重要和有用
 
 *   由于其键/值对，因此易于组织数据。
 *   HashMap 允许 1 个 null 键和多个 null 值。
@@ -17,14 +17,14 @@
 
 ![Inheritance diagram of HashMap](img/fff6489e999a8221d5c68f8d836ad5a7.jpg)
 
-## HashMap 中的构造方法摘要
+## `HashMap`中的构造方法摘要
 
 1.  HashMap（）：使用默认的初始容量 16 和默认的加载因子 0.75 初始化一个空的 HashMap。
 2.  HashMap（int initialCapacity）：使用指定的初始容量和默认加载因子 0.75 初始化一个空的 HashMap。
 3.  HashMap（int initialCapacity，float loadFactor）：使用指定的初始容量和负载因子初始化一个空的 HashMap。
 4.  HashMap（Map <？扩展 K，？扩展 V > m）：使用与指定 Map 相同的映射初始化一个新的 HashMap。
 
-## HashMap 类中的方法
+## `HashMap`类中的方法
 
 1.  void clear（）：从此映射中删除所有映射。
 2.  Object clone（）：克隆另一个 HashMap，但是不会克隆键和值本身。
@@ -37,7 +37,7 @@
 9.  V replace（K 键，V 值）：仅当当前映射到某个值时，才替换指定键的条目。
 10.  int size（）：返回此映射中的键/值对的数量。
 
-### **使用 HashMap 进行基本方法操作以及它们如何工作以及如何相互交互**
+### 使用`HashMap`进行基本操作，以及它们如何工作以及如何相互交互
 
 ```java
 import java.util.HashMap;

docs/65.md

-# Java LinkedHashMap 示例
+# Java `LinkedHashMap`示例
 
 > 原文： [https://javatutorial.net/java-linkedhashmap-example](https://javatutorial.net/java-linkedhashmap-example)
 
@@ -19,7 +19,7 @@ LinkedHashMap 是哈希表和链接列表的组合，以可预测的迭代顺序
 
 继承图
 
-## LinkedHashMap 中的构造方法摘要
+## `LinkedHashMap`中的构造方法摘要
 
 1.  LinkedHashMap（）：构造一个空的插入顺序的 LinkedHashMap，其默认初始容量（16）和默认负载因子（0.75）。
 2.  LinkedHashMap（int initialCapacity）：构造一个空的插入顺序的 LinkedHashMap，并将容量设置为指定的 initialCapacity 参数和默认负载因子（0.75）。
@@ -27,7 +27,7 @@ LinkedHashMap 是哈希表和链接列表的组合，以可预测的迭代顺序
 4.  LinkedHashMap（int initialCapacity，float loadFactor，boolean accessOrder）：使用指定的初始容量，负载系数和排序方式构造一个空的 LinkedHashMap 实例。
 5.  LinkedHashMap（Map <？扩展 K，？扩展 V > m）：构造一个插入顺序的 LinkedHashMap 实例，该实例具有与指定映射相同的映射。
 
-## LinkedHashMap 类中的方法
+## `LinkedHashMap`类中的方法
 
 1.  void clear（）：从此映射中删除所有映射。
 2.  boolean containsValue（Object value）：如果 LinkedHashMap 包含指定的值，则返回 true，否则返回 false。
@@ -40,7 +40,7 @@ LinkedHashMap 是哈希表和链接列表的组合，以可预测的迭代顺序
 
 有关 EnumSet 主要方法的更多信息，请随时访问原始 [Oracle 文档](https://docs.oracle.com/javase/8/docs/api/java/util/LinkedHashMap.html)。
 
-### 获取 LinkedHashMap 的大小，检查其在特定键中是否包含某个值，并检查其是否为空，最后从 LinkedHashMap 中删除键：
+### 获取`LinkedHashMap`的大小，检查其在特定键中是否包含某个值，并检查其是否为空，最后从`LinkedHashMap`中删除键：
 
 ```java
 import java.util.*; 
@@ -86,7 +86,7 @@ Does it contain 'marital status'? true
 Deleting element 'name': "Joe"
 ```
 
-### 使用 clear（）清除 LinkedHashMap
+### 使用`clear()`清除`LinkedHashMap`
 
 ```java
 import java.util.*; 

docs/66.md

-# Java TreeMap 示例
+# Java `TreeMap`示例
 
 > 原文： [https://javatutorial.net/java-treemap-example](https://javatutorial.net/java-treemap-example)
 
@@ -6,26 +6,26 @@ TreeMap 实现了 Map 接口，还实现了 NavigableMap 以及 Abstract 类。
 
 ![java-featured-image](img/e0db051dedc1179e7424b6d998a6a772.jpg)
 
-## 有关 TreeMap 的要点
+## 有关`TreeMap`的要点
 
 *   TreeMap 实现 Map 接口。
 *   TreeMap 不允许使用空键。 而是，抛出 NullPointerException。 虽然，多个空值可以与不同的键关联。
 *   TreeMap 是 [Java Collections Framework](https://docs.oracle.com/javase/8/docs/technotes/guides/collections/index.html) 的成员。
 
-## TreeMap 的继承图
+## `TreeMap`的继承图
 
 ![TreeMap inheritance diagram](img/d259c9e6fc8d33362024fc7adca465de.jpg)
 
 TreeMap 继承图
 
-## TreeMap 中的构造方法摘要
+## `TreeMap`中的构造方法摘要
 
 1.  TreeMap（）：使用其键的自然顺序构造一个新的空树图。
 2.  TreeMap（Comparator <？super K >比较器）：构造一个新的空树图，根据给定的比较器排序。
 3.  TreeMap（Map <？扩展 K，？扩展 V > m）：构造一个新的树图，该树图包含与给定图相同的映射，并根据其键的自然顺序进行排序。
 4.  TreeMap（SortedMap < K ，?扩展 V > m）：构造一个新的树图，该树图包含与指定排序图相同的映射并使用相同的排序。
 
-## TreeMap 类中的方法
+## `TreeMap`类中的方法
 
 1.  void clear（）：删除树形图中的所有元素。
 2.  Object clone（）：返回 TreeMap 实例的浅表副本。
@@ -40,7 +40,7 @@ TreeMap 继承图
 
 有关 EnumSet 主要方法的更多信息，请随时访问原始 [Oracle 文档](https://docs.oracle.com/javase/8/docs/api/java/util/TreeMap.html)。
 
-### 使用 containsKey（）和 containsValue（）检查当前树形图是否包含指定的键或值，并使用 put（）填充 TreeMap
+### 使用`containsKey()`和`containsValue()`检查当前树形图是否包含指定的键或值，并使用`put()`填充`TreeMap`
 
 ```java
 import java.util.*; 
@@ -88,7 +88,7 @@ Is the value 'tutorial' present? true
 
 ```
 
-### 使用 remove（）从 TreeMap 中删除元素
+### 使用`remove()`从`TreeMap`中删除元素
 
 ```java
 import java.util.*;  

docs/67.md

-# Java EnumMap 示例
+# Java `EnumMap`示例
 
 > 原文： [https://javatutorial.net/java-enummap-example](https://javatutorial.net/java-enummap-example)
 
@@ -11,19 +11,19 @@ EnumMap 类实现 [Map](https://docs.oracle.com/javase/7/docs/api/java/util/Map.
 *   EnumMap 不同步。
 *   EnumMap 比 [HashMap](https://javatutorial.net/java-hashmap-example) 快得多
 
-## EnumMap 图
+## `EnumMap`图
 
 ![EnumMap Inheritance diagram](img/e63bca435be3bbe175a8aa31a6645aad.jpg)
 
 EnumMap 继承图
 
-## EnumMap 中的构造方法
+## `EnumMap`中的构造方法
 
 1.  EnumMap（Class < K > keyType）：使用指定的密钥类型创建一个空的枚举映射。
 2.  EnumMap（EnumMap < K，？扩展 V > m）：创建一个与指定枚举图具有相同键类型的枚举图，最初包含相同的映射（如果有）。
 3.  EnumMap（Map < K，？扩展 V > m）：创建一个从指定映射初始化的枚举映射。
 
-## EnumMap 中的方法
+## `EnumMap`中的方法
 
 1.  void clear（）：从此映射中删除所有映射。
 2.  EnumMap < K，V > clone（）：返回一个 EnumMap，它表示另一个副本。

docs/68.md

-# Java WeakHashMap 示例
+# Java `WeakHashMap`示例
 
 > 原文： [https://javatutorial.net/java-weakhashmap-example](https://javatutorial.net/java-weakhashmap-example)
 
@@ -20,14 +20,14 @@ Java 中的 WeakHashMap 实现了 Map 接口，并表示一个具有弱键的哈
 
 WeakHashMap 实现 Map 并扩展 AbstractMap。
 
-## WeakHashMap 中的构造方法
+## `WeakHashMap`中的构造方法
 
 1.  WeakHashMap（）：创建一个空的 WeakHashMap，默认初始容量为 16，负载系数为 0.75。
 2.  WeakHashMap（int initialCapacity：创建具有指定容量的空 WeakHashMap。
 3.  WeakHashMap（int initialCapacity，float loadFactor）：创建具有指定容量和负载因子的空 WeakHashMap。
 4.  WeakHashMap（Map <？扩展 K，？扩展 V > m）：创建一个具有与指定映射相同的映射的新 WeakHashMap。
 
-## WeakHashMap 中的方法
+## `WeakHashMap`中的方法
 
 1.  void clear（）：从当前映射中删除所有映射。
 2.  boolean containsKey（Object key）：如果当前映射包含指定键的映射，则返回 true。

docs/69.md

-# Java IdentityHashMap 示例
+# Java `IdentityHashMap`示例
 
 > 原文： [https://javatutorial.net/java-identityhashmap-example](https://javatutorial.net/java-identityhashmap-example)
 
@@ -16,13 +16,13 @@ IdentityHashMap 允许空值和空键以及所有可选的映射操作。 但是
 
 IdentityHashMap：实现和扩展的内容。
 
-## IdentityHashMap 中的构造方法
+## `IdentityHashMap`中的构造方法
 
 1.  IdentityHashMap（）：创建一个新的身份哈希映射，默认最大大小为 21。
 2.  IndetityHashMap（int ExpectedMaxSize）：创建一个具有预期最大大小的新空地图。
 3.  IdentityHashMap（Map <？扩展 K，？扩展 V > m）：创建一个新的 Identity，其映射包含与指定映射相同的映射。
 
-## IdentityHashMap 中的方法
+## `IdentityHashMap`中的方法
 
 1.  void clear（）：从此映射中删除所有映射。
 2.  Object clone（）：返回此标识哈希图的副本（重要的是要注意，键和值本身未克隆）。

docs/70.md

-# Java SortedMap 示例
+# Java `SortedMap`示例
 
 > 原文： [https://javatutorial.net/java-sortedmap-example](https://javatutorial.net/java-sortedmap-example)
 

docs/71.md

-# Java ConcurrentMap 示例
+# Java `ConcurrentMap`示例
 
 > 原文： [https://javatutorial.net/java-concurrentmap-example](https://javatutorial.net/java-concurrentmap-example)
 
@@ -17,7 +17,7 @@
 
 ConcurrentMap 由表示为表存储桶的节点数组组成，它们在第一次插入后初始化。
 
-## ConcurrentMap 和 [HashMap](https://javatutorial.net/java-hashmap-example) 之间的效率比较
+## `ConcurrentMap`和[`HashMap`](https://javatutorial.net/java-hashmap-example)之间的效率比较
 
 *   如果要尽快处理数据，则必须使用所有线程，因此这意味着 ConcurrentMap 在这里更有效。
 *   如果只需要单线程访问，则 HashMap 更快。
@@ -30,7 +30,7 @@ ConcurrentMap 由表示为表存储桶的节点数组组成，它们在第一次
 
 ConcurrentMap
 
-## ConcurrentMap 中的方法
+## `ConcurrentMap`中的方法
 
 1.  默认 V 计算（K 键，BiFunction <？超级 K，？超级 V，？扩展 V > remappingFunction）：尝试计算指定键及其当前映射值的映射。
 2.  默认的 V computeIfAbsent（K 键，函数<？超级 K，？扩展 V > mappingFunction）：如果作为参数给出的键与值不相关（或为 null），则尝试计算其值并输入 进入此地图，除非为 null。

docs/72.md

-# Java 哈希表示例
+# Java `Hashtable`示例
 
 > 原文： [https://javatutorial.net/java-hashtable-example](https://javatutorial.net/java-hashtable-example)
 
@@ -20,14 +20,14 @@ Hashtable 实现一个哈希表（顾名思义），并将键映射到值（例
 *   允许任意插入和删除键值对。
 *   在许多情况下搜索树或任何其他表时效率更高。
 
-## 哈希表中的构造方法摘要
+## `Hashtable`中的构造方法摘要
 
 1.  Hashtable（）：构造一个具有默认初始容量（11）（与 HashMap 或 LinkedHashMap 不同）和负载因子（0.75）的新哈希表。
 2.  Hashtable（int initialCapacity）：构造一个具有指定容量和默认负载因子（0.75）的新哈希表。
 3.  Hashtable（int initialCapacity，float loadFactor）：构造一个具有指定容量和指定负载因子的新哈希表。
 4.  哈希表（Map <？扩展 K，？扩展 V > t）：使用与给定 Map 相同的映射构造一个新的哈希表。
 
-## 哈希表类中的方法
+## `Hashtable`类中的方法
 
 1.  void clear：清除当前哈希表，该哈希表删除/删除所有键/值对。
 2.  对象 clone（）：创建此哈希表的浅表副本。
@@ -45,7 +45,7 @@ Hashtable 实现一个哈希表（顾名思义），并将键映射到值（例
 
 有关 Hashtable 类的主要方法的更多信息，请随时访问原始 [Oracle 文档](https://docs.oracle.com/javase/8/docs/api/java/util/Hashtable.html)。
 
-### 从哈希表中删除所有键并克隆哈希表
+### 从`Hashtable`中删除所有键并克隆`Hashtable`
 
 ```java
 import java.util.*; 

docs/73.md

-# Java 中 ArrayList 和 LinkedList 之间的区别
+# Java 中`ArrayList`和`LinkedList`之间的区别
 
 > 原文： [https://javatutorial.net/difference-between-arraylist-and-linkedlist-in-java](https://javatutorial.net/difference-between-arraylist-and-linkedlist-in-java)
 
@@ -6,15 +6,15 @@
 
 由于继承了相同的接口– List，因此 ArrayList 和 Linked list 共享相同的属性。 但是 ArrayList 和 LinkedList 有什么区别？ 简单地说– ArrayLists 对于一次写入多次读取操作很有用，但不利于从前端或中间进行添加/删除。 另一方面，LinkedList 更适合插入和删除数据。
 
-## 营运表现
+## 性能表现
 
 下表通过对 LinkedLists 和 ArrayLists 执行不同的操作来显示平均算法复杂度
 
 ![ArrayList vs. LinkedList operations complexity](img/2f6d37b5d3752640aaf862d0aa8f3702.jpg)
 
-ArrayList 与 LinkedList 操作的复杂性
+ArrayList 与 LinkedList 操作的复杂度
 
-## [ArrayList](https://javatutorial.net/java-arraylist-example) 与 [LinkedList](https://javatutorial.net/java-linkedlist-example) 性能示例
+## [`ArrayList`](https://javatutorial.net/java-arraylist-example)与[`LinkedList`](https://javatutorial.net/java-linkedlist-example)性能示例
 
 下面的示例演示使用 ArrayList 和 LinkedList 上的相同数据进行`add`，`set`和`remove`操作的性能
 
@@ -123,6 +123,6 @@ LinkedList size after removal 0
 *   ArrayList 在访问和修改元素方面明显更快
 *   ArrayList 从列表开头删除元素的速度明显较慢
 
-## 免责声明
+## 结论
 
 在所有情况下，算法复杂度和运算性能都不是恒定的。 您必须考虑两个主要因素-列表的大小以及我们使用的元素在列表中的放置位置（在开头，中间或结尾）。 唯一不变的规则是：如果要更快地检索元素，请使用 ArrayList，如果要更快地处理数据，请使用 LinkedList。
\ No newline at end of file

docs/74.md

-# Java 通过 HashMap 示例进行迭代
+# Java `HashMap`迭代示例
 
 > 原文： [https://javatutorial.net/java-iterate-hashmap-example](https://javatutorial.net/java-iterate-hashmap-example)
 
@@ -6,7 +6,7 @@
 
 在 Java 中遍历集合或数据集是一项非常常见的任务。 您可以使用它来打印或处理数据。 以下示例显示了有关如何遍历 HashMap 的三种不同方法。 根据您的 Java 版本，您可以选择其中之一。
 
-## 分别用于遍历 [HashMap](https://javatutorial.net/java-hashmap-example)
+## 使用`for`遍历[`HashMap`](https://javatutorial.net/java-hashmap-example)
 
 这是建议的方法。 它使您可以完全控制地图中的键和值。 使用这种方法，您实际上遍历了映射的`EntrySet`，并获得了循环内每个条目的键和值。
 
@@ -52,7 +52,7 @@ public class IterateHashMap {
 
 ```
 
-## 使用 Iterator 遍历 HashMap
+## 使用`Iterator`遍历`HashMap`
 
 此方法使用`java.util.Iterator`浏览 HashMap。 这是 Java 1.4 和更早版本中的默认方法。 尽管下面的示例使用泛型，所以您需要 Java 1.5 +才能执行它
 

docs/75.md

-# Java HashMap 内联初始化
+# Java `HashMap`内联初始化
 
 > 原文： [https://javatutorial.net/java-hashmap-inline-initialization](https://javatutorial.net/java-hashmap-inline-initialization)
 
 下面的示例演示如何使用标准方法和内联方法初始化 Java [HashMap](https://javatutorial.net/java-hashmap-example) 。
 
-## 为什么我们需要直接初始化 [HashMap](https://javatutorial.net/java-hashmap-example) ？
+## 为什么我们需要直接初始化[`HashMap`](https://javatutorial.net/java-hashmap-example) ？
 
-尽管 Maps 被广泛用于以动态方式收集和处理数据，但通常您需要创建一个带有预定义键和值的小地图，以测试一种简短的算法或您正在研究的概念。 手动初始化 Java HashMap 的另一个用例是测试程序或算法如何使用特定值执行。 在编写简短的演示程序时，您很可能更愿意直接初始化地图，而不是从文件或某种流中读取数据并用值填充地图。 您可以想象，与单行 HashMap 初始化相比，您需要花费更多的精力。
+尽管 Maps 被广泛用于以动态方式收集和处理数据，但通常您需要创建一个带有预定义键和值的小映射，以测试一种简短的算法或您正在研究的概念。 手动初始化 Java HashMap 的另一个用例是测试程序或算法如何使用特定值执行。 在编写简短的演示程序时，您很可能更愿意直接初始化映射，而不是从文件或某种流中读取数据并用值填充映射。 您可以想象，与单行 HashMap 初始化相比，您需要花费更多的精力。
 
 ![](img/ad0c213c2121594bbf7c044f4c63b997.jpg)
 
 Java 初始化 HashMap
 
-## 初始化 HashMap 的必要方法
+## 初始化`HashMap`的必要方法
 
 直接的解决方案是声明一个 Map，然后只需 put（）进入 Map。 我们将使用此示例作为参考，以与其他更节省类型的技术进行比较。
 
@@ -22,9 +22,9 @@ test.put("A","one");
 test.put("B","two");
 ```
 
-如您在上面的示例中看到的，首先创建一个地图对象，然后在其中放置条目。 这里要提到的另一重要事项是，通过使用此方法，您可以创建动态地图，并且可以编辑，删除或创建新条目。
+如您在上面的示例中看到的，首先创建一个映射对象，然后在其中放置条目。 这里要提到的另一重要事项是，通过使用此方法，您可以创建动态映射，并且可以编辑，删除或创建新条目。
 
-## 使用匿名子类初始化 HashMap
+## 使用匿名子类初始化`HashMap`
 
 这将创建 HashMap 的匿名子类，其实例初始化程序将这些值放入。 换句话说，它将创建一个继承自 HashMap 的新类。 这是创建和初始化动态 HashMap 的最短方法
 
@@ -37,9 +37,9 @@ Map<Integer, String> mymap = new HashMap<Integer, String>() {
 };
 ```
 
-## 初始化不可变地图
+## 初始化不可变映射
 
-与动态地图（如上例所示）相比，不可变地图是不可编辑的。 这意味着您不能在其中添加新条目，删除条目或更新它们。 如果您想测试一个简单的算法，它们将对您很好。
+与动态映射（如上例所示）相比，不可变映射是不可编辑的。 这意味着您不能在其中添加新条目，删除条目或更新它们。 如果您想测试一个简单的算法，它们将对您很好。
 
 ## 在 Java SE 8 和更早版本中初始化不可变映射
 
@@ -53,9 +53,9 @@ mymap.put(3,"three");
 Map<Integer,String> immutableMap = Collections.unmodifiableMap(mymap);
 ```
 
-如您所见，您以老式方式创建和初始化 Map。 使地图不可变的原因是对 Collections.unmodifiableMap（Map map）的调用。 好吧，它看起来不太像内联初始化。 不用担心，下一个示例可以。
+如您所见，您以老式方式创建和初始化 Map。 使映射不可变的原因是对 Collections.unmodifiableMap（Map map）的调用。 好吧，它看起来不太像内联初始化。 不用担心，下一个示例可以。
 
-## 以 Guava 方式内联初始化 HashMap
+## 以 Guava 方式内联初始化`HashMap`
 
 [Guava](https://github.com/google/guava) 是第一个引入真正的单行 Map 初始化的人。 参见下面的例子
 
@@ -63,7 +63,7 @@ Map<Integer,String> immutableMap = Collections.unmodifiableMap(mymap);
 Map<String, Integer> left = ImmutableMap.of("a", 1, "b", 2, "c", 3);
 ```
 
-## 用 Java 9 方式内联初始化 HashMap
+## 用 Java 9 方式内联初始化`HashMap`
 
 最后，在 Java 9 中，我们可以使用单行语句来初始化不可变的 HashMap，而无需第三方库。
 

docs/76.md

-# Java 中 HashMap 和 TreeMap 之间的区别
+# Java 中`HashMap`和`TreeMap`之间的区别
 
 > 原文： [https://javatutorial.net/difference-between-hashmap-and-treemap-in-java](https://javatutorial.net/difference-between-hashmap-and-treemap-in-java)
 
@@ -12,7 +12,7 @@
 
 Java 中 HashMap 和 TreeMap 之间的区别
 
-## HashMap 和 TreeMap 之间的主要区别
+## `HashMap`和`TreeMap`之间的主要区别
 
 **TreeMap** 是 [SortedMap](https://javatutorial.net/java-sortedmap-example) 的示例，由 Red-Black 树实现，这意味着对键的顺序进行了排序。 遍历键时，您可以依靠它们会井然有序的事实。 键的顺序由元素的`compareTo()`方法或外部提供的[比较器](https://javatutorial.net/java-comparator-example)确定。
 
@@ -86,7 +86,7 @@ TreeMap iteration order =======
 
 如您所见，在 HashMap 上进行迭代时，我们以“随机”顺序获得条目。 另一方面，TreeMap 迭代以其自然顺序返回条目。
 
-## 实施复杂性差异
+## 实现复杂度差异
 
 由于 HashMap 实现的复杂度为 O（1），因此通常可以认为 HashMap 效率更高，因此无论您何时在乎键的顺序，都可以使用它。 另一方面，TreeMap 中获取，放置和删除操作的复杂度为 O（log（n））
 

docs/77.md

-# 图形 Java 示例
+# Java 图示例
 
 > 原文： [https://javatutorial.net/graphs-java-example](https://javatutorial.net/graphs-java-example)
 
-图形通常由顶点和弧线组成。 有时，它们也称为节点（而不是顶点）和边缘（而不是弧）。 为了本教程的缘故，我将使用节点和边作为参考。
+图形通常由顶点和弧线组成。 有时，它们也称为节点（而不是顶点）和边（而不是弧）。 为了本教程的缘故，我将使用节点和边作为参考。
 
 ![java-featured-image](img/e0db051dedc1179e7424b6d998a6a772.jpg)
 
@@ -32,7 +32,7 @@
 
 ## 有向图
 
-定向图形时，这意味着只能沿其“指向”的方向遍历这些边缘。
+定向图形时，这意味着只能沿其“指向”的方向遍历这些边。
 
 ![Directed graph](img/d925c10d009f3ac8a8168d9036caa201.jpg)
 
@@ -83,7 +83,7 @@ Node.java 有 3 个方法和 1 个构造函数。
 
 **getNodeId（）**仅返回每个节点的 ID。
 
-**addNeighbour（Edge e）**通过边缘创建连接，该边缘作为参数传递到另一个节点。 这是通过将指定的边添加到 Node 类的边列表中来完成的。 **注意**，存在一个 if 条件，用于检查此节点的当前边缘中是否已经存在指定的边缘 **e** 。
+**addNeighbour（Edge e）**通过边创建连接，该边作为参数传递到另一个节点。 这是通过将指定的边添加到 Node 类的边列表中来完成的。 **注意**，存在一个 if 条件，用于检查此节点的当前边中是否已经存在指定的边 **e** 。
 
 **getNeighbours（）**仅用于显示目的。 查看**输出**，以查看此方法显示信息的精确程度。
 
@@ -136,13 +136,13 @@ Edge.java 有 6 个方法和 1 个构造函数。
 
 **getId（）**仅返回当前边的 ID。
 
-**getStart（）**返回边缘从其开始的 Node 对象。
+**getStart（）**返回边从其开始的 Node 对象。
 
-**getIdOfStartNode（）**返回边缘从其开始的 Node 对象的 ID。
+**getIdOfStartNode（）**返回边从其开始的 Node 对象的 ID。
 
-**getEnd（）**返回边缘“停止”在的 Node 对象。
+**getEnd（）**返回边“停止”在的 Node 对象。
 
-**getIdOfEndNode（）**返回边缘“停止”在的 Node 对象的 ID。
+**getIdOfEndNode（）**返回边“停止”在的 Node 对象的 ID。
 
 **getWeight（）**获取当前 Node 对象的权重。
 
@@ -215,7 +215,7 @@ Main.java 只有一个 main 方法。
 
 在 main 方法中创建一个图形。 之后，将创建 3 个 Node 实例。 然后，使用 **createNode（Node 节点）**方法将这些 Node 实例添加到图形中。 之后，将创建 2 个 Edge 实例。 第一个将节点 1 连接到节点 2。第二个将节点 1 连接到节点 3。
 
-此后，存在一个 if 条件，该条件检查节点数是否大于 1，如果超过，则将“ Neighbour”添加​​到 node1。 （e12 是连接 node1 和 node2 的边缘。）（e13 是连接 node1 和 node3 的边缘）。
+此后，存在一个 if 条件，该条件检查节点数是否大于 1，如果超过，则将“ Neighbour”添加​​到 node1。 （e12 是连接 node1 和 node2 的边。）（e13 是连接 node1 和 node3 的边）。
 
 **输出**
 

docs/78.md

@@ -8,13 +8,13 @@
 
 深度优先搜索（简称 DFS）从一个未访问的节点开始，然后开始选择一个相邻节点，直到没有剩余节点为止。 执行完该“过程”之后，您将回溯到另一个选择节点的选择，如果没有，则只需选择另一个未访问的节点即可。
 
-## 使用堆栈实现
+## 使用栈实现
 
 ![DFS Iterative](img/677972a44b34e24ae1c260f8cc776225.jpg)
 
 上图访问的节点的顺序为：5 10 25 30 35 40 15 20
 
-### **使用堆栈数据结构实现 DFS**
+### 使用栈数据结构实现 DFS
 
 Node.java 代表上图中的每个“球”或“圆”。 它有一个 **值** ，它代表每个球的“值”。 它也有一个名为 **Visited** 的布尔变量，顾名思义，它表示遍历是否访问了 Node。 第三个实例变量 Node 类具有一个 ArrayList，它表示当前节点 **_ 与 _** 的所有相邻节点（或相邻节点）。 （如果您想了解有关 ArrayList 的更多信息，可以查看[本教程](https://javatutorial.net/java-arraylist-example)。）
 
@@ -65,7 +65,7 @@ public class Node{
 
 此类只有一种方法：解决方案。
 
-它使用堆栈数据结构，并以节点为元素。 它将指定的元素添加到节点，然后将其标记为已访问。 在那之后，有一个 while 循环，不断检查堆栈是否为空。 如果不是，则从堆栈中删除一个元素，获取要删除的元素的邻居。 然后，存在另一个循环，其目的是将每个邻居节点标记为已访问，并将该邻居节点添加到堆栈中。
+它使用栈数据结构，并以节点为元素。 它将指定的元素添加到节点，然后将其标记为已访问。 在那之后，有一个 while 循环，不断检查栈是否为空。 如果不是，则从栈中删除一个元素，获取要删除的元素的邻居。 然后，存在另一个循环，其目的是将每个邻居节点标记为已访问，并将该邻居节点添加到栈中。
 
 ```java
 import java.util.*;

docs/79.md

@@ -18,9 +18,9 @@ BFS 使用与深度优先搜索完全相反的工作流程，反之亦然。
 
 BFS 的工作流程
 
-## BFS 的实施
+## BFS 的实现
 
-实施 BFS 时要遵循两个简单的规则：
+实现 BFS 时要遵循两个简单的规则：
 
 1.  访问给定层上的每个元素
 2.  移至下一层

docs/80.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://javatutorial.net/algorithm-time-complexities](https://javatutorial.net/algorithm-time-complexities)
 
-在开始解释不同的时间复杂性之前，让我们首先看一下实际的算法是什么。
+在开始解释不同的时间复杂度之前，让我们首先看一下实际的算法是什么。
 
 ![java-featured-image](img/e0db051dedc1179e7424b6d998a6a772.jpg)
 
@@ -12,7 +12,7 @@
 
 算法工作流程
 
-尽管听起来很简单且不复杂，但事实恰恰相反。 许多算法要花费大量时间才能完成某件事，而有些则没有。 这就是为什么了解给定算法的**复杂度**非常重要的原因。 那是因为通过了解算法的复杂性，可以使我们了解算法的“价值”，或者说效率如何。
+尽管听起来很简单且不复杂，但事实恰恰相反。 许多算法要花费大量时间才能完成某件事，而有些则没有。 这就是为什么了解给定算法的**复杂度**非常重要的原因。 那是因为通过了解算法的复杂度，可以使我们了解算法的“价值”，或者说效率如何。
 
 算法示例：
 
@@ -71,7 +71,7 @@
 
 “花费的时间不会超过且不短于”
 
-## 如何确定给定程序的复杂性
+## 如何确定给定程序的复杂度
 
 ```java
 int sumArray(int[] aiNumbers)
@@ -83,9 +83,9 @@ int sumArray(int[] aiNumbers)
 }
 ```
 
-该程序的复杂性只是 aiNumbers.length。 因此，如果此数组的长度为 4，则复杂度为 4。如果 aiNumbers.length 为 6，则复杂度为 6。
+该程序的复杂度只是 aiNumbers.length。 因此，如果此数组的长度为 4，则复杂度为 4。如果 aiNumbers.length 为 6，则复杂度为 6。
 
-复杂性是 aiNumbers.length 的原因是因为它会循环 aiNumbers.length 次。 因此，复杂度为 O（N）。
+复杂度是 aiNumbers.length 的原因是因为它会循环 aiNumbers.length 次。 因此，复杂度为 O（N）。
 
 ```java
 N = in.length;
@@ -119,4 +119,4 @@ for (int i = 0; i < n; i++) {
 
 图片来源： [https://adrianmejia.com/most-popular-algorithms-time-complexity-every-programmer-should-know-free-online-tutorial-course/](https://adrianmejia.com/most-popular-algorithms-time-complexity-every-programmer-should-know-free-online-tutorial-course/)
 
-在算法和复杂性方面，请尽可能尝试优化算法。 这样做的一个好方法是使用集合等在输入数据中找到共同点。请记住：内存很昂贵，您的时间也很昂贵。
\ No newline at end of file
+在算法和复杂度方面，请尽可能尝试优化算法。 这样做的一个好方法是使用集合等在输入数据中找到共同点。请记住：内存很昂贵，您的时间也很昂贵。
\ No newline at end of file

docs/84.md

@@ -10,7 +10,7 @@ Java 8 引入了新的 Date-Time API，其目的是弥补旧的 date-time API
 
 新的 API 不仅解决了所有这些问题，而且还引入了`java.time`包中的 2 个重要类：
 
-*   本地 –时区处理没有复杂性
+*   本地 –时区处理没有复杂度
 *   分区的 –处理各种时区的更复杂的日期时间 API
 
 **当地时间 API** 在不需要时区时应使用

docs/99.md

@@ -22,7 +22,7 @@
 
 Java 中的每个类都有一个由用户显式设置或默认设置的构造函数。 当可以借助许多不同的参数（可能是强制性的，而其他参数也可能是可选的）创建对象时，将使用构建器模式。 在这种情况下，事情变得复杂并且容易出错。 因此，在这种情况下，构建器模式会派上用场。
 
-实施构建器设计模式的步骤：
+实现构建器设计模式的步骤：
 
 1.  使用所有必填字段创建一个构建器类
 2.  Builder 类应具有带有所有必需参数的公共构造函数