2020-05-23 21:40:44

docs/java/110.md

@@ -131,7 +131,7 @@ JDK 设计人员通过制作`HttpServlet`抽象类来解决此问题。 它具
 
 #### 4.3 示例
 
-我想以集合框架中的`Map`接口为例。 它仅提供规则，以及映射在实践中应如何表现。 例如它应该存储键-值对，应该可以使用键等访问该值。这些规则在接口中采用抽象方法的形式。
+我想以集合框架中的`Map`接口为例。 它仅提供规则，以及映射在实践中应如何表现。 例如它应该存储键值对，应该可以使用键等访问该值。这些规则在接口中采用抽象方法的形式。
 
 所有实现类（例如[`HashMap`](//howtodoinjava.com/java/collections/how-hashmap-works-in-java/ "How hashmap works in java")，`HashTable`，`TreeMap`或[`WeakHashMap`](https://docs.oracle.com/javase/7/docs/api/java/util/WeakHashMap.html "WeakHashMap")）都不同地实现了所有方法，因此与其他方法相比具有不同的功能。
 

docs/java/131.md

@@ -2,9 +2,9 @@
 
 > 原文： [https://howtodoinjava.com/java/multi-threading/executor-framework-tutorial/](https://howtodoinjava.com/java/multi-threading/executor-framework-tutorial/)
 
-与 JDK 5 一起发布的 [Java 执行器框架](https://docs.oracle.com/javase/tutorial/essential/concurrency/executors.html "Executor framework")（java.util.concurrent.Executor）用于运行`Runnable`对象，而无需每次都创建新线程，并且主要是重新使用已经创建的线程。
+与 JDK 5 一起发布的 [Java 执行器框架](https://docs.oracle.com/javase/tutorial/essential/concurrency/executors.html "Executor framework")（`java.util.concurrent.Executor`）用于运行`Runnable`对象，而无需每次都创建新线程，并且主要是重新使用已经创建的线程。
 
-我们都知道有两种方法可以在 Java 中创建线程。 如果您想了解有关它们比较的更多信息，请阅读 [**如何在 Java**](//howtodoinjava.com/java/multi-threading/difference-between-implements-runnable-and-extends-thread-in-java/ "Difference between “implements Runnable” and “extends Thread” in java") 中创建线程。
+我们都知道有两种方法可以在 Java 中创建线程。 如果您想了解有关它们比较的更多信息，请阅读[**如何在 Java**](//howtodoinjava.com/java/multi-threading/difference-between-implements-runnable-and-extends-thread-in-java/ "Difference between “implements Runnable” and “extends Thread” in java")中创建线程。
 
 在 Java 中创建线程是一个非常昂贵的过程，其中还包括内存开销。 因此，如果我们可以在创建后重新使用这些线程来运行将来的可运行对象，则是一个好主意。 在此**执行器框架教程**中，我将编写一些演示程序来演示`Executor`的用法，然后我们将讨论在设计下一个多线程应用程序时需要牢记的一些最佳实践。
 
@@ -96,9 +96,9 @@ class TestTwo implements Runnable {
 
 请不要忘记在帖子结尾阅读最佳实践。
 
-## 2\. Java 执行器框架 – 可多运行
+## 2\. Java 执行器框架 – `MultiRunnable`
 
-不必每个`Runnable`都在单独的线程中执行。 有时，我们需要在单个线程中执行多个作业，并且每个作业都是`Runnable`的实例。 要设计此类解决方案，应使用**多可运行**。 这个多可运行对象不过是需要执行的可运行对象的集合。 唯一的补充是，该多可运行库本身也是**可运行库**。
+不必每个`Runnable`都在单独的线程中执行。 有时，我们需要在单个线程中执行多个作业，并且每个作业都是`Runnable`的实例。 要设计此类解决方案，应使用`MultiRunnable`。 这个`MultiRunnable`对象不过是需要执行的可运行对象的集合。 唯一的补充是，该`MultiRunnable`库本身也是`Runnable`。
 
 以下是需要在单个线程中执行的任务列表。
 
@@ -143,7 +143,7 @@ public class TaskThree implements Runnable {
 
 ```
 
-让我们创建上述任务的多可运行包装器。
+让我们创建上述任务的`MultiRunnable`包装器。
 
 ```java
 package com.howtodoinjava.demo.multiThread;
@@ -168,7 +168,7 @@ public class MultiRunnable implements Runnable {
 
 ```
 
-现在可以在下面的程序中以这种方式执行上面的 multi runnable：
+现在可以在下面的程序中以这种方式执行上面的`multi runnable`：
 
 ```java
 package com.howtodoinjava.demo.multiThread;
@@ -214,8 +214,8 @@ class RejectedExecutionHandelerImpl implements RejectedExecutionHandler
 
 ## 3\. Java 执行器框架最佳实践
 
-1.  始终针对静态分析工具（例如 [PMD](http://pmd.sourceforge.net/ "pmd home page") 和 [FindBugs](http://findbugs.sourceforge.net/ "findbugs home page") ）运行 Java 代码，以查找更深层次的问题。 它们对于确定将来可能出现的丑陋情况非常有帮助。
-2.  始终与高级人员进行交叉检查并更好地计划代码审查，以在执行过程中检测并可能在代码中出现[死锁或活动锁](https://en.wikipedia.org/wiki/Deadlock "deadlock and livelock")。 在大多数情况下，在应用程序中添加运行状况监视器以检查正在运行的任务的状态是一个很好的选择。
+1.  始终针对静态分析工具（例如 [PMD](http://pmd.sourceforge.net/ "pmd home page") 和 [FindBugs](http://findbugs.sourceforge.net/ "findbugs home page")）运行 Java 代码，以查找更深层次的问题。 它们对于确定将来可能出现的丑陋情况非常有帮助。
+2.  始终与高级人员进行交叉检查并更好地计划代码审查，以在执行过程中检测并可能在代码中出现[死锁或活锁](https://en.wikipedia.org/wiki/Deadlock "deadlock and livelock")。 在大多数情况下，在应用程序中添加运行状况监视器以检查正在运行的任务的状态是一个很好的选择。
 3.  在多线程程序中，也要养成捕获错误的习惯，而不仅仅是异常。 有时会发生意想不到的事情，除了异常之外，Java 还会向您抛出错误。
 4.  使用退避开关，因此，如果出现问题并且无法恢复，您就不会急于启动另一个循环来升级情况。 相反，您需要等到情况恢复正常后再重新开始。
 5.  请注意，执行器的全部目的是抽象出执行的细节，因此除非明确说明，否则不能保证顺序。

docs/java/132.md

-# Java 线程间通信 – PipedReader 和 PipedWriter
+# Java 线程间通信 – `PipedReader`和`PipedWriter`
 
 > 原文： [https://howtodoinjava.com/java/multi-threading/inter-thread-communication-using-piped-streams-in-java/](https://howtodoinjava.com/java/multi-threading/inter-thread-communication-using-piped-streams-in-java/)
 
-Java 线程间通信在很长一段时间以来一直是热门的[面试问题](https://howtodoinjava.com/java-interview-questions/)。 在 JDK 1.5 版本中， [ExecutorService](https://howtodoinjava.com/java/multi-threading/java-executor-framework-tutorial-and-best-practices/) 和 [BlockingQueue](https://howtodoinjava.com/java/multi-threading/how-to-use-blockingqueue-and-threadpoolexecutor-in-java/) 为[带来了另一种更有效的实现方式](//howtodoinjava.com/java-5/how-to-use-blockingqueue-and-threadpoolexecutor-in-java/ "How to use BlockingQueue and ThreadPoolExecutor in java")，但管道流方法也值得了解，在某些情况下可能有用。
+Java 线程间通信在很长一段时间以来一直是热门的[面试问题](https://howtodoinjava.com/java-interview-questions/)。 在 JDK 1.5 版本中，[`ExecutorService`](https://howtodoinjava.com/java/multi-threading/java-executor-framework-tutorial-and-best-practices/)和[`BlockingQueue`](https://howtodoinjava.com/java/multi-threading/how-to-use-blockingqueue-and-threadpoolexecutor-in-java/)[带来了另一种更有效的实现方式](//howtodoinjava.com/java-5/how-to-use-blockingqueue-and-threadpoolexecutor-in-java/ "How to use BlockingQueue and ThreadPoolExecutor in java")，但管道流方法也值得了解，在某些情况下可能有用。
 
 ```java
 Table of contents
@@ -17,16 +17,16 @@ Summary
 
 **管道流**就像真实的管道一样。 您可以使用某些方法将事物一端放入管道中。 然后，您可以使用其他方法从另一端的管道流中收到相同的信息。
 
-它们以 [**FIFO 顺序**](https://en.wikipedia.org/wiki/FIFO "fifo") 的先入先出的方式出现，就像从实际的管道中一样。
+它们以 [**FIFO 顺序**](https://en.wikipedia.org/wiki/FIFO "fifo")的先入先出的方式出现，就像从实际的管道中一样。
 
-## PipedReader 和 PipedWriter
+## `PipedReader`和`PipedWriter`
 
-[**PipedReader**](https://docs.oracle.com/javase/7/docs/api/java/io/PipedReader.html) 是 [**Reader**](https://docs.oracle.com/javase/7/docs/api/java/io/Reader.html "Reader") 类的扩展，用于读取字符流。 它的 read（）方法读取连接的 PipedWriter 的流。 同样， [**PipedWriter**](https://docs.oracle.com/javase/7/docs/api/java/io/PipedWriter.html) 是 Writer 类的扩展，它执行 Reader 类所收缩的所有工作。
+[**`PipedReader`**](https://docs.oracle.com/javase/7/docs/api/java/io/PipedReader.html)是[**`Reader`**](https://docs.oracle.com/javase/7/docs/api/java/io/Reader.html "Reader")类的扩展，用于读取字符流。 它的`read()`方法读取连接的`PipedWriter`的流。 同样，[**`PipedWriter`**](https://docs.oracle.com/javase/7/docs/api/java/io/PipedWriter.html) 是`Writer`类的扩展，它执行`Reader`类所收缩的所有工作。
 
 可以通过以下两种方法将作家连接到读者：
 
-1.  使用构造器 PipedWriter（PipedReader pr）
-2.  使用 connect（PipedReader pr）方法
+1.  使用构造器`PipedWriter(PipedReader pr)`
+2.  使用`connect(PipedReader pr)`方法
 
 通过上述任何一种方式连接后，任何线程都可以使用`write(....)`方法在流中写入数据，并且数据将可供读取器使用，并且可以使用`read()`方法进行读取。
 

docs/java/133.md

@@ -4,7 +4,7 @@
 
 通过示例，以编程方式学习在 Java 中创建死锁。 还学习**检测死锁**以及如何**解决源代码**中的死锁情况。
 
-在我以前的文章中，我写了关于 *[当属性文件](//howtodoinjava.com/java-7/auto-reload-of-configuration-when-any-change-happen/ "Auto reload of configuration when any change happen")* 中发生任何更改时自动重载配置的信息，我讨论了有关使用 **Java WatchService** 刷新应用程序配置的信息。 由于配置是共享资源，并且通过[线程](https://docs.oracle.com/javase/6/docs/api/java/lang/Thread.html "Java Thread class")进行访问时，总是有机会编写不正确的代码，而这可能导致死锁。
+在我以前的文章中，我写了关于[当属性文件](//howtodoinjava.com/java-7/auto-reload-of-configuration-when-any-change-happen/ "Auto reload of configuration when any change happen")中发生任何更改时自动重载配置的信息，我讨论了有关使用 Java `WatchService`刷新应用程序配置的信息。 由于配置是共享资源，并且通过[线程](https://docs.oracle.com/javase/6/docs/api/java/lang/Thread.html "Java Thread class")进行访问时，总是有机会编写不正确的代码，而这可能导致死锁。
 
 ## 1\. 死锁
 

docs/java/135.md

@@ -4,69 +4,69 @@
 
 顾名思义，集合是一组对象。 **Java 集合框架**由接口和类组成，这些接口和类有助于处理不同类型的集合，例如**列表，集合，映射，堆栈和队列**等。
 
-这些现成的收集类解决了许多非常常见的问题，在这些问题中，我们需要处理一组同构对象和异类对象。 其中的常见操作涉及**添加，删除，更新，排序，搜索**和更复杂的算法。 这些收集类使用 **Collections API** 为所有此类操作提供了非常透明的支持。
+这些现成的收集类解决了许多非常常见的问题，在这些问题中，我们需要处理一组同构对象和异类对象。 其中的常见操作涉及**添加，删除，更新，排序，搜索**和更复杂的算法。 这些收集类使用**集合 API** 为所有此类操作提供了非常透明的支持。
 
 ## 1\. Java 集合层次结构
 
-借助**核心接口**可以更好地理解 Collections 框架。 集合类实现这些接口并提供具体功能。
+借助**核心接口**可以更好地理解集合框架。 集合类实现这些接口并提供具体功能。
 
 ![Java Collections Hierarchy](img/347b74a5f16525a754f66a2e6a215ef8.png)
 
 Java 集合层次结构
 
-#### 1.1 采集
+#### 1.1 集合
 
-**收集接口**位于层次结构的根部。 集合接口提供所有集合类必须支持（或抛出`UnsupportedOperationException`）的所有通用方法。 它**扩展了`Iterable`**接口，该接口使用“ [**for-each 循环**](https://howtodoinjava.com/java/basics/enhanced-for-each-loop-in-java/) ”语句添加了对集合元素进行迭代的支持。
+**集合接口**位于层次结构的根部。 集合接口提供所有集合类必须支持（或抛出`UnsupportedOperationException`）的所有通用方法。 它扩展了`Iterable`接口，该接口使用“[**`for-each`循环**](https://howtodoinjava.com/java/basics/enhanced-for-each-loop-in-java/)”语句添加了对集合元素进行迭代的支持。
 
-所有其他集合接口和类（Map 除外）都可以扩展或实现此接口。 例如，列表*（已索引，有序）*和集*（已排序）*接口实现了此集合。
+所有其他集合接口和类（`Map`除外）都可以扩展或实现此接口。 例如，列表（已索引，有序）和集（已排序）接口实现了此集合。
 
-#### 1.2 清单
+#### 1.2 列表
 
 **列表**表示元素的**有序**集合。 使用列表，我们可以按元素的整数索引（列表中的位置）访问元素，并在列表中搜索元素。 索引以`0`开头，就像数组一样。
 
-实现`List`接口的一些有用的类是 – **ArrayList** ， **CopyOnWriteArrayList** ， **LinkedList** ，**堆栈**和**向量** 。
+实现`List`接口的一些有用的类是 – `ArrayList`，`CopyOnWriteArrayList`， `LinkedList`，`Stack`和`Vector`。
 
-#### 1.3 组
+#### 1.3 集合
 
-**集**代表**排序的**元素的集合。 集不允许重复的元素。 Set 接口不能保证以任何可预测的顺序返回元素。 尽管某些 Set 实现以其[自然顺序](https://howtodoinjava.com/java/collections/java-comparable-interface/)存储元素并保证此顺序。
+**集合**代表**排序的**元素的集合。 集合不允许重复的元素。`Set`接口不能保证以任何可预测的顺序返回元素。 尽管某些`Set`实现以其[自然顺序](https://howtodoinjava.com/java/collections/java-comparable-interface/)存储元素并保证此顺序。
 
-实现`Set`接口的一些有用的类是 – **ConcurrentSkipListSet** ， **CopyOnWriteArraySet** ， **EnumSet** ， **HashSet** ， **LinkedHashSet** 和 **TreeSet** 。
+实现`Set`接口的一些有用的类是 – `ConcurrentSkipListSet`， `CopyOnWriteArraySet`， `EnumSet`，`HashSet`，`LinkedHashSet`和`TreeSet`。
 
 #### 1.4 映射
 
-**Map** 接口使我们能够将数据存储在*键值对*中（键应该是不可变的）。 映射不能包含重复的键； 每个键最多可以映射到一个值。
+`Map`接口使我们能够将数据存储在*键值对*中（键应该是不可变的）。 映射不能包含重复的键； 每个键最多可以映射到一个值。
 
-Map 接口提供了三个集合视图，这些视图允许将映射的内容作为一组键，值的集合或一组键-值映射来查看。 一些映射实现（例如 TreeMap 类）对其顺序做出特定的保证。 其他的（例如 HashMap 类）则没有。
+`Map`接口提供了三个集合视图，这些视图允许将映射的内容作为一组键，值的集合或一组键值映射来查看。 一些映射实现（例如`TreeMap`类）对其顺序做出特定的保证。 其他的（例如`HashMap`类）则没有。
 
-实现`Map`接口的一些有用的类是 – **ConcurrentHashMap** ， **ConcurrentSkipListMap** ， **EnumMap** ， **HashMap** ，**哈希表** ， **IdentityHashMap** ， **LinkedHashMap** ，**属性**， **TreeMap** 和 **WeakHashMap** 。
+实现`Map`接口的一些有用的类是 – `ConcurrentHashMap`，`ConcurrentSkipListMap`，`EnumMap`，`HashMap`，`HashTable`，`IdentityHashMap`，`LinkedHashMap`，`Property`，`TreeMap`和`WeakHashMap`。
 
-#### 1.5 堆
+#### 1.5 `Stack`
 
-Java **堆栈**接口表示经典的堆栈数据结构，其中的元素可以被推入对象的后进先出（LIFO）堆栈。 在堆栈中，我们将元素推到堆栈的顶部，然后再次从堆栈顶部弹出。
+Java `Stack`接口表示经典的堆栈数据结构，其中的元素可以被推入对象的后进先出（LIFO）堆栈。 在堆栈中，我们将元素推到堆栈的顶部，然后再次从堆栈顶部弹出。
 
-#### 1.6 队列
+#### 1.6 `Queue`
 
-队列数据结构旨在在由使用者线程进行处理之前保存元素（由生产者线程放入）。 除了基本的“收集”操作外，队列还提供其他插入，提取和检查操作。
+队列数据结构旨在在由使用者线程进行处理之前保存元素（由生产者线程放入）。 除了基本的“集合”操作外，队列还提供其他插入，提取和检查操作。
 
 队列通常但不一定以 FIFO（先进先出）的方式对元素进行排序。 一种此类异常情况是优先级队列，该队列根据提供的[比较器](https://howtodoinjava.com/java/collections/java-comparator/)或元素的自然顺序对元素进行排序。
 
-通常，队列不支持阻止插入或检索操作。 阻塞队列实现类实现了 **BlockingQueue** 接口。
+通常，队列不支持阻止插入或检索操作。 阻塞队列实现类实现了`BlockingQueue`接口。
 
-实现`Map`接口的一些有用的类是 – ArrayBlockingQueue，ArrayDeque，ConcurrentLinkedDeque，ConcurrentLinkedQueue，DelayQueue，LinkedBlockingDeque，LinkedBlockingQueue，LinkedList，LinkedTransferQueue，PriorityBlockingQueue，PriorityQueue 和 SynchronousQueue。
+实现`Map`接口的一些有用的类是 – `ArrayBlockingQueue`，`ArrayDeque`，`ConcurrentLinkedDeque`，`ConcurrentLinkedQueue`，`DelayQueue`，`LinkedBlockingDeque`，`LinkedBlockingQueue`，`LinkedList`，`LinkedTransferQueue`，`PriorityBlockingQueue`，`PriorityQueue`和`SynchronousQueue`。
 
-#### 1.7 和
+#### 1.7 `Deque`
 
-一个双端队列（发音为“ ***卡座*** ”），支持两端的元素插入和移除。 当双端队列用作队列时，将产生 [FIFO（先进先出）](https://en.wikipedia.org/wiki/FIFO_(computing_and_electronics))行为。 当双端队列用作堆栈时，将产生 LIFO（后进先出）行为。
+一个双端队列（发音为“DQ”），支持两端的元素插入和移除。 当双端队列用作队列时，将产生 [FIFO（先进先出）](https://en.wikipedia.org/wiki/FIFO_(computing_and_electronics))行为。 当双端队列用作堆栈时，将产生 LIFO（后进先出）行为。
 
-此接口应优先于旧版 Stack 类使用。 当双端队列用作堆栈时，元素从双端队列的开头被压入并弹出。
+此接口应优先于旧版`Stack`类使用。 当双端队列用作堆栈时，元素从双端队列的开头被压入并弹出。
 
-实现此接口的一些常见的已知类是 ArrayDeque，ConcurrentLinkedDeque，LinkedBlockingDeque 和 LinkedList。
+实现此接口的一些常见的已知类是`ArrayDeque`，`ConcurrentLinkedDeque`，`LinkedBlockingDeque`和`LinkedList`。
 
 ## 2\. Java 集合和泛型
 
-有目的的[泛型](https://howtodoinjava.com/java/generics/complete-java-generics-tutorial/)提供类型安全性。 它检测到不兼容的类型（在方法参数中），并在运行时防止 **ClassCastException** 。 同样在 Java 集合中，我们可以定义一个集合类以仅存储某种类型的对象。 所有其他类型均应禁止。 这是通过泛型完成的。
+有目的的[泛型](https://howtodoinjava.com/java/generics/complete-java-generics-tutorial/)提供类型安全性。 它检测到不兼容的类型（在方法参数中），并在运行时防止`ClassCastException`。 同样在 Java 集合中，我们可以定义一个集合类以仅存储某种类型的对象。 所有其他类型均应禁止。 这是通过泛型完成的。
 
-在给定的示例中，允许使用前两个 add（）方法。 第三者将无法编译并给出错误-“类型为`HashMap<Integer,String>`的 put（Integer，String）方法不适用于参数（String，String）”。 它有助于及早发现不兼容的类型，以防止运行时发生不可预测的行为。
+在给定的示例中，允许使用前两个`add（）`方法。 第三者将无法编译并给出错误 - “类型为`HashMap<Integer,String>`的`put(Integer, String)`方法不适用于参数`(String, String)`”。 它有助于及早发现不兼容的类型，以防止运行时发生不可预测的行为。
 
 ```java
 HashMap<Integer, String> map = new HashMap<>();
@@ -78,11 +78,11 @@ map.put("3", "C");	//NOT allowed - Key is string
 
 ```
 
-## 3\. equals（）和 hashCode（）方法
+## 3\. `equals()`和`hashCode()`方法
 
-许多集合类提供特定的功能，例如排序的元素，没有重复的元素等。要实现此行为，添加的元素（对象）必须正确实现 [equals（）和 hashCode（）方法](https://howtodoinjava.com/java/basics/java-hashcode-equals-methods/)。
+许多集合类提供特定的功能，例如排序的元素，没有重复的元素等。要实现此行为，添加的元素（对象）必须正确实现 [`equals()`和`hashCode()`方法](https://howtodoinjava.com/java/basics/java-hashcode-equals-methods/)。
 
-所有 Java 包装器类和 String 类均以其特定实现覆盖这些函数，因此它们在此类集合中的行为正确。 我们还需要确保在用户定义的自定义类中正确覆盖了这些功能。
+所有 Java 包装器类和`String`类均以其特定实现覆盖这些函数，因此它们在此类集合中的行为正确。 我们还需要确保在用户定义的自定义类中正确覆盖了这些功能。
 
 ```java
 SortedSet<Integer> sortedSet = new TreeSet<>();
@@ -100,7 +100,7 @@ System.out.println(sortedSet); 	//[1,2,3]
 
 ## 4\. Java 8 集合
 
-[Java 8](https://howtodoinjava.com/java-8-tutorial/) 是主要版本，它引入了 Java 编程中的 [lambda 样式](https://howtodoinjava.com/java8/complete-lambda-expressions-tutorial-in-java/)。 结果，收集类也得到了改善。 例如，我们可以单行遍历集合，并使用 **forEach** 语句对集合的所有元素执行操作。
+[Java 8](https://howtodoinjava.com/java-8-tutorial/) 是主要版本，它引入了 Java 编程中的 [lambda 样式](https://howtodoinjava.com/java8/complete-lambda-expressions-tutorial-in-java/)。 结果，收集类也得到了改善。 例如，我们可以单行遍历集合，并使用`forEach`语句对集合的所有元素执行操作。
 
 ```java
 ArrayList<Integer> list = new ArrayList<>();
@@ -115,39 +115,39 @@ list.forEach(System.out::print);
 
 ## 5\. Java 集合的好处
 
-*   **Consistent and reusable APIs** – This is any framework does. It provides a consistent set of classes methods which can be used to solve a similar set of problems over and over, without getting unpredictable results. Java collections framework also helps in solving common problems related to a group of objects – in consistent manner.
+*   **一致且可重用的API** – 这是任何框架所做的。 它提供了一组一致的类方法，这些方法可用于一遍又一遍地解决一组类似的问题，而不会得到无法预测的结果。 Java 集合框架还有助于以一致的方式解决与一组对象有关的常见问题。
 
-    所有集合类都具有一致的实现，并提供一些常见的方法，例如 add，get，put，remove 等。无论您要处理哪种数据结构，这些方法都将根据基础实现工作并透明地执行操作。
+    所有集合类都具有一致的实现，并提供一些常见的方法，例如`add`，`get`，`put`，`remove`等。无论您要处理哪种数据结构，这些方法都将根据基础实现工作并透明地执行操作。
 
 *   **更少的开发时间** – 通用且可预测的框架总是会减少开发时间，并有助于快速编写应用程序。 Java 集合还有助于对对象和集合执行一些最重复的常见任务，从而改善时间因素。
 *   **性能** – Java 集合 API 是由一些最杰出的行业人士编写的，它们的性能在大多数情况下都是一流的。 Oracle 和非常热心的 Java 开发人员社区正在进行的开发工作有助于使它变得更好。
-*   **Clean code** – These APIs have been written with all good [coding practices](https://howtodoinjava.com/java-best-practices/) and documented very well. They follow a certain standard across whole Java collection framework. It makes the programmer code look good and clean.
+*   **干净的代码** – 这些 API 都是使用所有良好的[编码惯例](https://howtodoinjava.com/java-best-practices/)编写的，并且记录得很好。 它们在整个 Java 集合框架中遵循特定的标准。 它使程序员的代码看起来干净整洁。
 
     由于一致的类和方法名称，因此代码也更易于阅读。
 
 ## 6\. Java 集合示例
 
 *   [数组](https://howtodoinjava.com/java-array/)
-*   [ArrayList](https://howtodoinjava.com/java-arraylist/)
-*   [链表](https://howtodoinjava.com/java/collections/java-linkedlist-class/)
-*   [HashMap](https://howtodoinjava.com/java-hashmap/)
-*   [哈希表](https://howtodoinjava.com/java/collections/hashtable-class/)
-*   [LinkedHashMap](https://howtodoinjava.com/java/collections/linkedhashmap/)
-*   [TreeMap](https://howtodoinjava.com/java/collections/treemap-class/)
-*   [哈希集](https://howtodoinjava.com/java/collections/java-hashset/)
-*   [LinkedHashSet](https://howtodoinjava.com/java/collections/java-linkedhashset/)
-*   [树集](https://howtodoinjava.com/java/collections/java-treeset-class/)
-*   [可比](https://howtodoinjava.com/java/collections/java-comparable-interface/)
-*   [比较器](https://howtodoinjava.com/java/collections/java-comparator/)
-*   [迭代器](https://howtodoinjava.com/java/collections/java-iterator/)
-*   [ListIterator](https://howtodoinjava.com/java/collections/java-listiterator/)
-*   [分离器](https://howtodoinjava.com/java/collections/java-spliterator/)
-*   [PriorityQueue](https://howtodoinjava.com/java/collections/java-priorityqueue/)
-*   [PriorityBlockingQueue](https://howtodoinjava.com/java/collections/java-priorityblockingqueue/)
-*   [ArrayBlockingQueue](https://howtodoinjava.com/java/collections/java-arrayblockingqueue/)
-*   [LinkedTransferQueue](https://howtodoinjava.com/java/collections/transferqueue-linkedtransferqueue/)
-*   [CopyOnWriteArrayList](https://howtodoinjava.com/java/collections/java-copyonwritearraylist/)
-*   [CopyOnWriteArraySet](https://howtodoinjava.com/java/collections/java-copyonwritearrayset/)
+*   [`ArrayList`](https://howtodoinjava.com/java-arraylist/)
+*   [`LinkedList`](https://howtodoinjava.com/java/collections/java-linkedlist-class/)
+*   [`HashMap`](https://howtodoinjava.com/java-hashmap/)
+*   [`HashMap`](https://howtodoinjava.com/java/collections/hashtable-class/)
+*   [`LinkedHashMap`](https://howtodoinjava.com/java/collections/linkedhashmap/)
+*   [`TreeMap`](https://howtodoinjava.com/java/collections/treemap-class/)
+*   [`HashSet`](https://howtodoinjava.com/java/collections/java-hashset/)
+*   [`LinkedHashSet`](https://howtodoinjava.com/java/collections/java-linkedhashset/)
+*   [`TreeSet`](https://howtodoinjava.com/java/collections/java-treeset-class/)
+*   [`Comparable`](https://howtodoinjava.com/java/collections/java-comparable-interface/)
+*   [`Comparator`](https://howtodoinjava.com/java/collections/java-comparator/)
+*   [`Iterator`](https://howtodoinjava.com/java/collections/java-iterator/)
+*   [`ListIterator`](https://howtodoinjava.com/java/collections/java-listiterator/)
+*   [`Spliterator`](https://howtodoinjava.com/java/collections/java-spliterator/)
+*   [`PriorityQueue`](https://howtodoinjava.com/java/collections/java-priorityqueue/)
+*   [`PriorityBlockingQueue`](https://howtodoinjava.com/java/collections/java-priorityblockingqueue/)
+*   [`ArrayBlockingQueue`](https://howtodoinjava.com/java/collections/java-arrayblockingqueue/)
+*   [`LinkedTransferQueue`](https://howtodoinjava.com/java/collections/transferqueue-linkedtransferqueue/)
+*   [`CopyOnWriteArrayList`](https://howtodoinjava.com/java/collections/java-copyonwritearraylist/)
+*   [`CopyOnWriteArraySet`](https://howtodoinjava.com/java/collections/java-copyonwritearrayset/)
 *   [集合排序](https://howtodoinjava.com/java-sorting-guide/)
 *   [面试问题](https://howtodoinjava.com/interview-questions/useful-java-collection-interview-questions/)
 

docs/java/139.md

@@ -201,7 +201,7 @@ The key is :: 3, and value is :: C
 
 HashMap 类中的方法列表及其简短描述。
 
-1.  **void clear（）**：从 HashMap 中删除所有键-值对。
+1.  **void clear（）**：从 HashMap 中删除所有键值对。
 2.  **对象 clone（）**：返回指定 HashMap 的浅表副本。
 3.  **boolean containsKey（Object key）**：根据是否在映射中找到指定的键，返回`true`或`false`。
 4.  **布尔值 containsValue（Object Value）**：类似于 containsKey（）方法，它查找指定的值而不是键。

docs/java/141.md

@@ -127,7 +127,7 @@ LinkedHashMap 具有五种构造器：
 
 我们应该学习有关 LinkedHashMap 的重要方法如下：
 
-1.  **void clear（）：**它将从映射中删除所有键-值对。
+1.  **void clear（）：**它将从映射中删除所有键值对。
 2.  **void size（）：**它返回此映射中存在的键/值对的数量。
 3.  **void isEmpty（）：**如果此映射不包含键值映射，则返回 true。
 4.  **boolean containsKey（Object key）：**如果映射中存在指定的键，则返回`'true'`。

docs/java/142.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://howtodoinjava.com/java/collections/treemap-class/](https://howtodoinjava.com/java/collections/treemap-class/)
 
-Java 中的 **TreeMap** 用于存储非常类似于[`HashMap`](https://howtodoinjava.com/java-hashmap/)类的键-值对。 区别在于 TreeMap 提供了一种有效的方式来**以排序的顺序**存储键/值对。 这是基于**红黑树**的`NavigableMap`实现。
+Java 中的 **TreeMap** 用于存储非常类似于[`HashMap`](https://howtodoinjava.com/java-hashmap/)类的键值对。 区别在于 TreeMap 提供了一种有效的方式来**以排序的顺序**存储键/值对。 这是基于**红黑树**的`NavigableMap`实现。
 
 在本 **Java TreeMap 教程**中，我们将学习 TreeMap 类，其方法，用例和其他重要细节。
 
@@ -59,7 +59,7 @@ TreeMap 具有五种构造器：
 
 我们应该了解的有关 TreeMap 的重要方法如下：
 
-1.  **void clear（）：**它将从映射中删除所有键-值对。
+1.  **void clear（）：**它将从映射中删除所有键值对。
 2.  **void size（）：**它返回此映射中存在的键/值对的数量。
 3.  **void isEmpty（）：**如果此映射不包含键值映射，则返回 true。
 4.  **boolean containsKey（Object key）：**如果映射中存在指定的键，则返回`'true'`。

docs/java/158.md

@@ -251,7 +251,7 @@ final int hash;
 
 ```
 
-此处，键和值变量用于存储键-值对。 整个条目对象存储在数组中。
+此处，键和值变量用于存储键值对。 整个条目对象存储在数组中。
 
 ```java
 /**
@@ -303,7 +303,7 @@ TreeMap 是 HashMap 的特殊形式。 **它维护 HashMap 类中缺少的键**
 
 #### 19）列表和映射之间的区别？
 
-也许是最简单的问题。 **列表是元素的集合，而 map 是键-值对**的集合。 实际上，有很多差异源自第一个语句。 它们具有**单独的顶层接口，单独的一组通用方法，不同的受支持方法和不同的集合视图**。
+也许是最简单的问题。 **列表是元素的集合，而 map 是键值对**的集合。 实际上，有很多差异源自第一个语句。 它们具有**单独的顶层接口，单独的一组通用方法，不同的受支持方法和不同的集合视图**。
 
 我会花很多时间来回答这个问题，仅作为第一个区别就足够了。