2020-05-20 22:33:53

docs/java/105.md

@@ -4,7 +4,7 @@
 
 用最简单的话来说，您可以将抽象定义为仅捕获与当前视角相关的 Java 对象的那些细节。
 
-例如，`HashMap`存储键值对。 它为您提供了两种方法`get()`和`put()`方法，用于从地图存储和检索键值对。 实际上，这是您想要在应用程序中使用地图时所需的唯一信息。 它是如何工作的，不需要使用它就知道。 这是 Java 中非常抽象的示例。
+例如，`HashMap`存储键值对。 它为您提供了两种方法`get()`和`put()`方法，用于从映射存储和检索键值对。 实际上，这是您想要在应用程序中使用映射时所需的唯一信息。 它是如何工作的，不需要使用它就知道。 这是 Java 中非常抽象的示例。
 
 再看一个**现实生活中的抽象示例**，它可以是电视遥控器。 您知道，当您按遥控器上的任何按钮时，电视上都会应用某些功能，例如更改频道，更改音量级别等。不需要了解远程内部的工作原理，即可正确使用它。 这是一个抽象的例子。
 

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/135.md

@@ -32,11 +32,11 @@ Java 集合层次结构
 
 实现`Set`接口的一些有用的类是– **ConcurrentSkipListSet** ， **CopyOnWriteArraySet** ， **EnumSet** ， **HashSet** ， **LinkedHashSet** 和 **TreeSet** 。
 
-#### 1.4 地图
+#### 1.4 映射
 
 **Map** 界面使我们能够将数据存储在*键值对*中（键应该是不可变的）。 映射不能包含重复的键； 每个键最多可以映射到一个值。
 
-Map 界面提供了三个集合视图，这些视图允许将地图的内容作为一组键，值的集合或一组键-值映射来查看。 一些地图实现（例如 TreeMap 类）对其顺序做出特定的保证。 其他的（例如 HashMap 类）则没有。
+Map 界面提供了三个集合视图，这些视图允许将映射的内容作为一组键，值的集合或一组键-值映射来查看。 一些映射实现（例如 TreeMap 类）对其顺序做出特定的保证。 其他的（例如 HashMap 类）则没有。
 
 实现`Map`接口的一些有用的类是– **ConcurrentHashMap** ， **ConcurrentSkipListMap** ， **EnumMap** ， **HashMap** ，**哈希表** ， **IdentityHashMap** ， **LinkedHashMap** ，**属性**， **TreeMap** 和 **WeakHashMap** 。
 

docs/java/139.md

@@ -4,7 +4,7 @@
 
 Java 中的 **HashMap** 在实现 **Map** 接口的集合类中。 它用于存储**键&值**对。 每个键都映射到映射中的单个值。
 
-键是唯一的。 这意味着我们只能在地图中插入键“ K”一次。 不允许重复的密钥。 虽然值`'V'`可以映射到多个键。
+键是唯一的。 这意味着我们只能在映射中插入键“ K”一次。 不允许重复的密钥。 虽然值`'V'`可以映射到多个键。
 
 ## 1\. java.util.HashMap 类
 
@@ -203,16 +203,16 @@ HashMap 类中的方法列表及其简短描述。
 
 1.  **void clear（）**：从 HashMap 中删除所有键-值对。
 2.  **对象 clone（）**：返回指定 HashMap 的浅表副本。
-3.  **boolean containsKey（Object key）**：根据是否在地图中找到指定的键，返回`true`或`false`。
+3.  **boolean containsKey（Object key）**：根据是否在映射中找到指定的键，返回`true`或`false`。
 4.  **布尔值 containsValue（Object Value）**：类似于 containsKey（）方法，它查找指定的值而不是键。
 5.  **Object get（Object key）**：返回 HashMap 中指定键的值。
 6.  **boolean isEmpty（）**：检查映射是否为空。
 7.  **Set keySet（）**：返回 HashMap 中存储的所有密钥的 **Set** 。
 8.  **对象 put（Key k，Value v）**：将键值对插入 HashMap 中。
 9.  **int size（）**：返回映射的大小，该大小等于存储在 HashMap 中的键值对的数量。
-10.  **集合 values（）**：返回地图中所有值的集合。
+10.  **集合 values（）**：返回映射中所有值的集合。
 11.  **值移除（对象键）**：移除指定键的键值对。
-12.  **void putAll（Map m）**：将地图的所有元素复制到另一个指定的地图。
+12.  **void putAll（Map m）**：将映射的所有元素复制到另一个指定的映射。
 
 ## 6\. HashMap 教程和示例
 
@@ -220,8 +220,8 @@ HashMap 类中的方法列表及其简短描述。
 *   [不同方式对 HashMap 进行迭代的性能比较](https://howtodoinjava.com/java/collections/performance-comparison-of-different-ways-to-iterate-over-hashmap/)
 *   [如何为 HashMap 设计好的自定义键对象](https://howtodoinjava.com/java/collections/design-good-key-for-hashmap/)
 *   [Java 中 HashMap 和 Hashtable 之间的区别](https://howtodoinjava.com/java/collections/difference-between-hashmap-and-a-hashtable/)
-*   [Java 按键对地图进行排序（升序和降序）](https://howtodoinjava.com/sort/java-sort-map-by-key/)
-*   [Java 按值对地图进行排序（升序和降序）](https://howtodoinjava.com/sort/java-sort-map-by-values/)
+*   [Java 按键对映射进行排序（升序和降序）](https://howtodoinjava.com/sort/java-sort-map-by-key/)
+*   [Java 按值对映射进行排序（升序和降序）](https://howtodoinjava.com/sort/java-sort-map-by-values/)
 *   [Java hashCode（）和 equals（）-契约，规则和最佳做法](https://howtodoinjava.com/java/basics/java-hashcode-equals-methods/)
 *   [HashMap 和 ConcurrentHashMap 面试问题](https://howtodoinjava.com/interview-questions/hashmap-concurrenthashmap-interview-questions/)
 *   [Java ConcurrentHashMap 最佳实践](https://howtodoinjava.com/java/multi-threading/best-practices-for-using-concurrenthashmap/)

docs/java/141.md

@@ -117,7 +117,7 @@ LinkedHashMap 具有五种构造器：
 
 1.  **LinkedHashMap（）：**使用默认的初始容量（16）和负载因子（0.75）初始化默认的 LinkedHashMap 实现。
 2.  **LinkedHashMap（int capacity）：**使用指定的容量和负载因子（0.75）初始化 LinkedHashMap。
-3.  **LinkedHashMap（地图地图）：**使用与指定地图相同的地图初始化 LinkedHashMap。
+3.  **LinkedHashMap（映射映射）：**使用与指定映射相同的映射初始化 LinkedHashMap。
 4.  **LinkedHashMap（int capacity，float fillRatio）：**使用指定的初始容量和负载因子初始化 LinkedHashMap。
 5.  **LinkedHashMap（int Capacity，float fillRatio，boolean Order）：**初始化 LinkedHashMap 的容量和填充率以及是否维护插入顺序或访问顺序。
     *   `'true'`启用访问顺序。
@@ -130,7 +130,7 @@ LinkedHashMap 具有五种构造器：
 1.  **void clear（）：**它将从映射中删除所有键-值对。
 2.  **void size（）：**它返回此映射中存在的键/值对的数量。
 3.  **void isEmpty（）：**如果此映射不包含键值映射，则返回 true。
-4.  **boolean containsKey（Object key）：**如果地图中存在指定的键，则返回`'true'`。
+4.  **boolean containsKey（Object key）：**如果映射中存在指定的键，则返回`'true'`。
 5.  **布尔值 containsValue（对象键）：**如果将指定值映射到映射中的至少一个键，则返回`'true'`。
 6.  **Object get（Object key）：**检索由指定的`key`映射的`value`。
 7.  **Object remove（Object key）：**如果存在，它将从映射中删除指定键的键值对。
@@ -203,7 +203,7 @@ true
 
 另外，LinkedHashMap 维护插入顺序，这在我们要维护添加到 Map 的对的顺序时非常有用。
 
-有序访问权限的 LinkedHashMap 通过重写`removeEldestEntry()`方法来强加一个用于在将新映射添加到地图时自动删除陈旧的策略的方法，从而为创建 **LRU 缓存**功能提供了一个很好的起点。 这使您可以使用定义的某些条件使数据过期。
+有序访问权限的 LinkedHashMap 通过重写`removeEldestEntry()`方法来强加一个用于在将新映射添加到映射时自动删除陈旧的策略的方法，从而为创建 **LRU 缓存**功能提供了一个很好的起点。 这使您可以使用定义的某些条件使数据过期。
 
 ## 6\. LinkedHashMap 的性能
 
@@ -226,7 +226,7 @@ Map<Integer, Integer> numbers = Collections.synchronizedMap(new HashMap<>());
 
 ## 8\. 结论
 
-基于以上所有信息，我们可以说，在大多数情况下，最好选择 HashMap 而不是 LinkedHashMap。 仅当我们有某些要求或用例需要保持添加到地图的元素顺序时，我们才更喜欢 LinkedHashMap。
+基于以上所有信息，我们可以说，在大多数情况下，最好选择 HashMap 而不是 LinkedHashMap。 仅当我们有某些要求或用例需要保持添加到映射的元素顺序时，我们才更喜欢 LinkedHashMap。
 
 两者在大多数现实用例中都提供几乎相同的性能。 当我们拥有大量数据时，则仅应考虑它们之间的权衡取舍。
 

docs/java/142.md

@@ -41,7 +41,7 @@ public class TreeMap<K,V>
 *   它存储类似于 HashMap 的键/值对。
 *   它仅允许不同的键。 重复的密钥是不可能的。
 *   它不能具有`null`键，但是可以具有多个`null`值。
-*   它按排序顺序（自然顺序）或在地图创建时提供的[`Comparator`](https://howtodoinjava.com/sort/sort-arraylist-objects-comparable-comparator/)存储键。
+*   它按排序顺序（自然顺序）或在映射创建时提供的[`Comparator`](https://howtodoinjava.com/sort/sort-arraylist-objects-comparable-comparator/)存储键。
 *   它为`containsKey`，`get`，`put`和`remove`操作提供了有保证的 **log（n）**时间成本。
 *   它不是[同步的](https://howtodoinjava.com/java/multi-threading/what-is-thread-safety/)。 使用`Collections.synchronizedSortedMap(new TreeMap())`在并发环境中工作。
 *   通过`iterator`方法返回的迭代器是**故障快速**。
@@ -52,8 +52,8 @@ TreeMap 具有五种构造器：
 
 1.  **TreeMap（）：**使用其键的自然顺序创建一个新的空树形图。
 2.  **TreeMap（Comparator c）：**创建一个新的空树形图，根据给定的比较器排序。
-3.  **TreeMap（地图地图）：**创建一个新的树状地图，其中包含与给定地图相同的映射，并根据其键的自然顺序进行排序。
-4.  **TreeMap（SortedMap 地图）：**创建一个新的树地图，其中包含与指定的已排序地图相同的映射并使用相同的顺序。
+3.  **TreeMap（映射映射）：**创建一个新的树状映射，其中包含与给定映射相同的映射，并根据其键的自然顺序进行排序。
+4.  **TreeMap（SortedMap 映射）：**创建一个新的树映射，其中包含与指定的已排序映射相同的映射并使用相同的顺序。
 
 ## 4\. TreeMap 方法
 
@@ -62,7 +62,7 @@ TreeMap 具有五种构造器：
 1.  **void clear（）：**它将从映射中删除所有键-值对。
 2.  **void size（）：**它返回此映射中存在的键/值对的数量。
 3.  **void isEmpty（）：**如果此映射不包含键值映射，则返回 true。
-4.  **boolean containsKey（Object key）：**如果地图中存在指定的键，则返回`'true'`。
+4.  **boolean containsKey（Object key）：**如果映射中存在指定的键，则返回`'true'`。
 5.  **布尔值 containsValue（对象键）：**如果将指定值映射到映射中的至少一个键，则返回`'true'`。
 6.  **Object get（Object key）：**它检索由指定的`key`映射的`value`，如果此映射不包含该键的映射，则返回 null。
 7.  **Object remove（Object key）：**如果存在，它将从映射中删除指定键的键值对。
@@ -71,7 +71,7 @@ TreeMap 具有五种构造器：
 10.  **对象 lastKey（）：**返回树图中当前的最后一个（最大）键。
 11.  **Object ceilingKey（Object key）：**它返回大于或等于给定键的最小键；如果没有这样的键，则返回 null。
 12.  **对象 HigherKey（对象密钥）：**返回严格大于指定键的最小键。
-13.  **NavigableMapDescendingMap（）：**它返回此地图中包含的映射的**逆序视图**。
+13.  **NavigableMapDescendingMap（）：**它返回此映射中包含的映射的**逆序视图**。
 
 ## 5\. Java TreeMap 示例
 
@@ -185,7 +185,7 @@ TreeMap 在内存管理中具有更好的性能，因为它不在内部维护数
 
 ## 8\. TreeMap 中的并发
 
-Map，HashMap 和 TreeMap 的两个版本均未同步，程序员需要管理对地图的并发访问。
+Map，HashMap 和 TreeMap 的两个版本均未同步，程序员需要管理对映射的并发访问。
 
 我们可以使用 **Collections.synchronizedSortedMap（new TreeMap（））**明确获取树图的同步视图。
 

docs/java/157.md

@@ -182,13 +182,13 @@ System.out.println(numbersSet);
 
 ```
 
-## 4\. 排序地图
+## 4\. 排序映射
 
-映射是键值对的集合。 因此，地图可以通过两种方式进行排序，即**按键**排序或**按值**排序。
+映射是键值对的集合。 因此，映射可以通过两种方式进行排序，即**按键**排序或**按值**排序。
 
-#### 4.1 按键对地图排序
+#### 4.1 按键对映射排序
 
-按键对地图进行排序的最好，最有效的方法是在 **TreeMap** 对象中添加所有地图项。 TreeMap 按键对条目集进行排序。
+按键对映射进行排序的最好，最有效的方法是在 **TreeMap** 对象中添加所有映射项。 TreeMap 按键对条目集进行排序。
 
 ```java
 HashMap<Integer, String> map = new HashMap<>();
@@ -213,7 +213,7 @@ System.out.println(treeMap);
 
 ```
 
-#### 4.2 按值对地图排序
+#### 4.2 按值对映射排序
 
 在 Java 8 中，Map.Entry 类具有静态方法 **compareByValue（）**，可帮助您按值排序。 此方法返回一个**比较器**，该比较器以自然顺序比较值上的`Map.Entry`。
 

docs/java/158.md

@@ -174,7 +174,7 @@ Set 还对 equals 和 hashCode 操作的行为增加了更强的约定，从而
 
 #### 9）HashSet 如何存储元素？
 
-您必须知道 HashMap 存储具有一个条件的键值对，即键将是唯一的。 HashSet 使用地图的此功能来确保元素的唯一性。 在 HashSet 类中，映射声明如下：
+您必须知道 HashMap 存储具有一个条件的键值对，即键将是唯一的。 HashSet 使用映射的此功能来确保元素的唯一性。 在 HashSet 类中，映射声明如下：
 
 ```java
 private transient HashMap<E,Object> map;
@@ -215,7 +215,7 @@ NavigableMap 是 SortedMap 的子类型，不允许使用 null 键。 因此，
 
 #### 11）为什么要使用 Map 界面？ 什么是实现 Map 接口的主要类？
 
-Map 接口是一种特殊的集合类型，它是**，用于存储键值对**。 因此，它不会扩展 Collection 接口。 该界面提供了在地图的各种视图上添加，删除，搜索或迭代的方法。
+Map 接口是一种特殊的集合类型，它是**，用于存储键值对**。 因此，它不会扩展 Collection 接口。 该界面提供了在映射的各种视图上添加，删除，搜索或迭代的方法。
 
 实现 Map 接口的主要类有： **HashMap，Hashtable，EnumMap，IdentityHashMap，LinkedHashMap 和 Properties。**
 
@@ -301,7 +301,7 @@ TreeMap 是 HashMap 的特殊形式。 **它维护 HashMap 类中缺少的键**
 *   列表允许重复元素，但 Set 不允许重复。
 *   List 不会阻止插入空元素（随您喜欢），但是 Set 将只允许一个空元素。
 
-#### 19）列表和地图之间的区别？
+#### 19）列表和映射之间的区别？
 
 也许是最简单的问题。 **列表是元素的集合，而 map 是键-值对**的集合。 实际上，有很多差异源自第一个语句。 它们具有**单独的顶层接口，单独的一组通用方法，不同的受支持方法和不同的集合视图**。
 

docs/java/16.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://howtodoinjava.com/java-string/](https://howtodoinjava.com/java-string/)
 
-**Java 字符串**表示[不变的](https://howtodoinjava.com/java/string/java-interview-question-why-strings-are-immutable/)字符序列，并且一旦创建就无法更改。 字符串的类型为`java.lang.String`类。 在此页面中，学习有关使用字符串字面值和[构造器](https://howtodoinjava.com/oops/java-constructors/)，字符串方法以及与字符串转换和格式设置有关的各种字符串示例创建字符串的信息。
+**Java 字符串**表示[不可变的](https://howtodoinjava.com/java/string/java-interview-question-why-strings-are-immutable/)字符序列，并且一旦创建就无法更改。 字符串的类型为`java.lang.String`类。 在此页面中，学习有关使用字符串字面值和[构造器](https://howtodoinjava.com/oops/java-constructors/)，字符串方法以及与字符串转换和格式设置有关的各种字符串示例创建字符串的信息。
 
 ## 1\. 用 Java 创建字符串
 

docs/java/18.md

@@ -33,7 +33,7 @@ Java 文档本身具有一些准则，[此链接中](https://docs.oracle.com/jav
 
 4.  #### 具有可变实例变量时要特别注意
 
-    始终记住，实例变量将是**可变的**或**不可变的**。 标识它们并返回具有所有可变对象复制内容的新对象。 不变的变量可以安全地返回而无需额外的努力。
+    始终记住，实例变量将是**可变的**或**不可变的**。 标识它们并返回具有所有可变对象复制内容的新对象。 不可变的变量可以安全地返回而无需额外的努力。
 
     一种更复杂的方法是使构造器`private`，并在**工厂方法**中构造实例。
 
@@ -181,7 +181,7 @@ class TestMain
 
 作为最佳设计实践，始终旨在使您的应用程序 Java 类不可变。 这样，您始终可以减少程序中与[并发](https://howtodoinjava.com/java-concurrency-tutorial/)相关的缺陷的担心。
 
-如何编写一个不变的类？ 这也可能是[面试问题](https://howtodoinjava.com/java-interview-questions/)。
+如何编写一个不可变的类？ 这也可能是[面试问题](https://howtodoinjava.com/java-interview-questions/)。
 
 学习愉快！
 

docs/java/193.md

@@ -35,12 +35,12 @@ Java 8 发行之前的主要类是：
 新的 date api 尝试解决旧类的上述问题。 它主要包含以下类：
 
 *   [`java.time.LocalDate`](https://howtodoinjava.com/java/date-time/compare-localdates/)：表示 ISO 日历中的年-月-日，对于表示没有时间的日期很有用。 它可用于表示仅日期的信息，例如出生日期或结婚日期。
-*   [`java.time.LocalTime`](https://howtodoinjava.com/java/date-time/java-localtime/)：仅及时处理。 这对于表示基于人的时间（例如电影时间或本地图书馆的开放和关闭时间）很有用。
+*   [`java.time.LocalTime`](https://howtodoinjava.com/java/date-time/java-localtime/)：仅及时处理。 这对于表示基于人的时间（例如电影时间或本映射书馆的开放和关闭时间）很有用。
 *   [`java.time.LocalDateTime`](https://howtodoinjava.com/java/date-time/compare-localdatetime/)：处理日期和时间，没有时区。 它是 *LocalDate* 与 *LocalTime* 的组合。
 *   [`java.time.ZonedDateTime`](https://howtodoinjava.com/java/date-time/zoneddatetime-comparison/)：将 *LocalDateTime* 类与 *ZoneId* 类中给出的区域信息组合在一起。 它代表完整的日期时间戳以及时区信息。
 *   `java.time.OffsetTime`：处理时间与格林威治/ UTC 有相应时区偏移的时间，没有时区 ID。
 *   `java.time.OffsetDateTime`：处理具有与格林威治/ UTC 相对应的时区偏移的日期和时间，没有时区 ID。
-*   `java.time.Clock`：提供对任何给定时区中的当前时刻，日期和时间的访问。 尽管使用 Clock 类是可选的，但是此功能使我们可以测试其他时区的代码，也可以使用时间不变的固定时钟来测试您的代码。
+*   `java.time.Clock`：提供对任何给定时区中的当前时刻，日期和时间的访问。 尽管使用 Clock 类是可选的，但是此功能使我们可以测试其他时区的代码，也可以使用时间不可变的固定时钟来测试您的代码。
 *   `java.time.Instant`：表示时间轴上的纳秒的开始（自 EPOCH 开始），对于生成表示机器时间的时间戳很有用。 在纪元之前发生的瞬间具有负值，在纪元之后发生的瞬间具有正值。
 *   `java.time.Duration`：两个瞬间之间的时差，以秒或纳秒为单位，并且不使用基于日期的构造，例如年，月和日，尽管该类提供了转换为天，小时和分钟的方法。
 *   `java.time.Period`：以基于日期的值（年，月，日）定义日期之间的差异。

docs/java/194.md

@@ -55,7 +55,7 @@ public class JavaDateValidations
 ## 2\. SimpleDateFormat – Java 7
 
 *   如果您仍然对 Java 7 感到震惊，并且由于某些旧应用程序的依赖性而无法升级，则可以使用`SimpleDateFormat`进行日期验证。
-*   尽管`SimpleDateFormat`不是线程安全的或不变的，但它仍然可以很好地达到目的。 不要在具有同步功能的多线程环境中使用此类。
+*   尽管`SimpleDateFormat`不是线程安全的或不可变的，但它仍然可以很好地达到目的。 不要在具有同步功能的多线程环境中使用此类。
 *   不要忘记使用[`setLenient()`](https://howtodoinjava.com/java/date-time/strict-date-validation-simpledateformat-setlenient/)方法来指定宽大因素。 使用宽大的解析，解析器可能会使用启发式方法来解释与该对象的格式不完全匹配的输入。 在严格分析的情况下，输入内容必须与此对象的格式匹配。
 *   然后，使用 SimpleDateFormat 的`parse(dateString)`方法，该方法将引发已检查的异常`ParseException`，该异常表示将日期字符串解析为`java.util.Date`对象时发生了一些错误。
 

docs/java/195.md

@@ -134,7 +134,7 @@ Exception in thread "main" java.time.temporal.UnsupportedTemporalTypeException:
 
 如果您仍然停留在 Java 7 上并且由于某些旧版应用程序的依赖性而无法升级，则可以使用`SimpleDateFormat`进行日期格式化。
 
-尽管`SimpleDateFormat`不是线程安全的或不变的，但它仍然可以很好地达到目的。 不要在具有同步功能的多线程环境中使用此类。
+尽管`SimpleDateFormat`不是线程安全的或不可变的，但它仍然可以很好地达到目的。 不要在具有同步功能的多线程环境中使用此类。
 
 ```java
 import java.text.SimpleDateFormat;

docs/java/208.md

@@ -288,7 +288,7 @@ System.out.println( east.equals( eastNew ) );    //true
 
 ## 6\. 枚举集合– EnumSet 和 EnumMap
 
-`java.util`包中添加了两个类以支持枚举– [`EnumSet`](https://docs.oracle.com/javase/7/docs/api/java/util/EnumSet.html)（用于枚举的高性能 Set 实现；枚举集的所有成员必须具有相同的枚举类型）和[`EnumMap`](https://docs.oracle.com/javase/7/docs/api/java/util/EnumMap.html)（高枚举， 与枚举键配合使用的性能地图实现）。
+`java.util`包中添加了两个类以支持枚举– [`EnumSet`](https://docs.oracle.com/javase/7/docs/api/java/util/EnumSet.html)（用于枚举的高性能 Set 实现；枚举集的所有成员必须具有相同的枚举类型）和[`EnumMap`](https://docs.oracle.com/javase/7/docs/api/java/util/EnumMap.html)（高枚举， 与枚举键配合使用的性能映射实现）。
 
 #### 6.1 java.util.EnumSet
 

docs/java/209.md

@@ -93,7 +93,7 @@ https://sit.domain.com:2019/
 
 很多时候，我们将拥有枚举的值，并且我们将需要**通过字符串**值获取枚举名称。 这可以通过反向查找来实现。
 
-在反向查找中，枚举在内部维护 ***值-枚举*** 的映射作为键值对。 搜索了此地图，应用程序需要查找与其关联的字符串值有关的枚举。
+在反向查找中，枚举在内部维护 ***值-枚举*** 的映射作为键值对。 搜索了此映射，应用程序需要查找与其关联的字符串值有关的枚举。
 
 ```java
 import java.util.HashMap;

docs/java/31.md

@@ -4,11 +4,11 @@
 
 启动 Java 程序时传递的程序参数称为**命令行参数**。
 
-可以从[控制台](https://howtodoinjava.com/java/io/java-io-how-to-read-input-from-console/)或从编辑器启动 Java 程序。 要启动程序，我们必须使用命令提示符或系统控制台中的`"java className"`命令。 启动程序时，我们可以使用以下语法传递附加参数（无参数数量限制）。
+可以从[控制台](https://howtodoinjava.com/java/io/java-io-how-to-read-input-from-console/)或从编辑器启动 Java 程序。 要启动程序，我们必须使用命令提示符或系统控制台中的`java className`命令。 启动程序时，我们可以使用以下语法传递附加参数（无参数数量限制）。
 
 ## 1\. 命令行参数语法
 
-在下面给出的语法中，我们将 5 个参数传递给 Main 类`MyClass`。 MyClass 具有[`main()`](https://howtodoinjava.com/java/basics/main-method/)方法，该方法以 **[字符串](https://howtodoinjava.com/java-string/)数组**的形式接受这些参数。
+在下面给出的语法中，我们将 5 个参数传递给启动类`MyClass`。`MyClass`具有[`main()`](https://howtodoinjava.com/java/basics/main-method/)方法，该方法以[字符串](https://howtodoinjava.com/java-string/)数组的形式接受这些参数。
 
 ```java
 $ java MyClass arg1 arg2 arg3 arg4 arg5
@@ -56,6 +56,6 @@ $ java Main 1 2 3 4
 *   **命令行参数**可用于在启动应用程序时指定配置信息。
 *   对参数的最大数量没有限制。 我们可以指定任意数量的参数。
 *   参数作为字符串传递。
-*   传递的参数将作为 main（）方法参数中的字符串[数组](https://howtodoinjava.com/java-array/)检索。
+*   传递的参数将作为`main()`方法参数中的字符串[数组](https://howtodoinjava.com/java-array/)检索。
 
 学习愉快！
\ No newline at end of file

docs/java/32.md

@@ -4,7 +4,7 @@
 
 正确地**比较浮点**或**比较双**不仅是 Java 特定的问题。 当今几乎所有编程语言都可以观察到它。 使用 [IEEE 754](https://en.wikipedia.org/wiki/IEEE_754) 标准格式存储浮点数和双精度数。 实际的存储和转换如何工作，不在本文的讨论范围之内。
 
-现在，只需了解在计算和转换期间，可以在这些数字中引入*较小的舍入误差*。 这就是为什么不建议仅依赖*相等运算符（==）*到**比较浮点数**的原因。
+现在，只需了解在计算和转换期间，可以在这些数字中引入*较小的舍入误差*。 这就是为什么不建议仅依赖相等运算符（`==`）**比较浮点数**的原因。
 
 让我们学习**如何比较 Java** 中的浮点值。
 
@@ -16,9 +16,9 @@ Table of Contents
 3\. Compare with BigDecimal [Recommended]
 ```
 
-## 1\. 双精度比较 -- 简单比较[不推荐]
+## 1\. 双精度比较 -- 简单比较（不推荐）
 
-首先看一下简单比较，以了解*与==运算符*比较 double 到底有什么问题。 在给定的程序中，我使用两种方法创建相同的浮点数（即`1.1`）：
+首先看一下简单比较，以了解用`==`运算符比较`double`到底有什么问题。 在给定的程序中，我使用两种方法创建相同的浮点数（即`1.1`）：
 
 1.  添加`.1` 11 次。
 2.  将`.1`乘以 11。
@@ -61,7 +61,7 @@ f1 and f2 are not equal
 
 ## 2\. 双精度比较 -– 基于阈值的比较[推荐]
 
-现在，当我们知道相等运算符的问题时，让我们解决它。 使用编程，我们无法更改存储或计算这些浮点数的方式。 因此，我们必须采用一种解决方案，在该解决方案中，我们同意确定两个可以容忍的值的差异，并且仍然认为数字相等。 该商定的值差被称为**阈值**或**ε**。
+现在，当我们知道相等运算符的问题时，让我们解决它。 使用编程，我们无法更改存储或计算这些浮点数的方式。 因此，我们必须采用一种解决方案，在该解决方案中，我们同意确定两个可以容忍的值的差异，并且仍然认为数字相等。 该商定的值差被称为**阈值**或`ε`。
 
 因此，现在要使用“基于阈值的**浮点比较**”，我们可以使用`Math.abs()`方法计算两个数字之间的差并将其与阈值进行比较。
 
@@ -99,27 +99,27 @@ f1 and f2 are equal using threshold
 
 ```
 
-## 3\. 比较`double`与`BigDecimal`[推荐]
+## 3\. 比较`double`与`BigDecimal`（推荐）
 
 在[`BigDecimal`](https://docs.oracle.com/javase/10/docs/api/java/math/BigDecimal.html)类中，可以指定要使用的**舍入模式**和**精确度**。 使用精确的精度极限，可以解决舍入误差。
 
-最好的部分是`BigDecimal`数字是[不变的](https://howtodoinjava.com/java/basics/how-to-make-a-java-class-immutable/)，即，如果创建具有`"1.23"`值的`BigDecimal` BD，则该对象将保持`"1.23"`且不能更改。 此类提供了许多方法，可用于对其值进行数值运算。
+最好的部分是`BigDecimal`数字是[不可变的](https://howtodoinjava.com/java/basics/how-to-make-a-java-class-immutable/)，即，如果创建具有`"1.23"`值的`BigDecimal`，则该对象将保持`"1.23"`且不能更改。 此类提供了许多方法，可用于对其值进行数值运算。
 
 您可以使用`compareTo()`方法与`BigDecimal`数字进行比较。 比较时会忽略比例。
 
-> **a.compareTo（b）;**
+> **`a.compareTo(b);`**
 > 
 > 方法返回：
 > 
-> -1 –如果是< b）
+> -1 – 如果是`a < b`
 > 
-> 0 –如果 a == b
+> 0 – 如果`a == b`
 > 
-> 1 –如果是> b
+> 1 – 如果是`a > b`
 
-Never use the `equals()` method to compare `BigDecimal` instances. That is because this equals function will compare the scale. If the scale is different, `equals()` will return false, even if they are the same number mathematically.
+切勿使用`equals()`方法比较`BigDecimal`实例。这是因为此`equals`函数将比较比例。 如果比例不同，即使在数学上相同，`equals()`也将返回`false`。
 
-Java 程序将`BigDecimal`类与 double 进行比较。
+Java 程序将`BigDecimal`类与`double`进行比较。
 
 ```java
 private static void testBdEquality() 

docs/java/33.md

@@ -32,7 +32,7 @@ method(T parameters...)
 
 #### 1\. 尾递归
 
-当递归方法调用是该方法内部执行的最后一条语句时（通常与 **return 语句**一起使用），则递归方法为**尾递归**。
+当递归方法调用是该方法内部执行的最后一条语句时（通常与`return`语句一起使用），则递归方法为**尾递归**。
 
 ```java
 method(T parameters...) 
@@ -70,7 +70,7 @@ method(T parameters...)
 
 斐波那契数列是一个数字序列，其中每个数字都定义为两个数字之和。
 
-例如– 1、1、2、3、5、8、13、21、34，依此类推…
+例如 -1、1、2、3、5、8、13、21、34，依此类推…
 
 此函数为我们提供从 1 开始的第 n 个位置的斐波那契数。
 
@@ -85,7 +85,7 @@ public int fibonacci(int n)
 
 ```
 
-让我们测试一下此功能以打印 n = 10 的斐波那契数列；
+让我们测试一下此功能以打印`n = 10`的斐波那契数列；
 
 ```java
 public static void main(String[] args) 
@@ -120,7 +120,7 @@ public static int gcd(int p, int q) {
 
 ```
 
-Let’s test this function to print the fibonacci series upto n = 10;
+让我们测试一下此功能以打印`n = 10`的斐波那契数列：
 
 ```java
 public static void main(String[] args) 
@@ -140,6 +140,6 @@ public static void main(String[] args)
 
 ```
 
-让我知道您有关 Java 中**递归的问题。**
+让我知道您有关 Java 中**递归的问题**。
 
 学习愉快！
\ No newline at end of file

docs/java/34.md

@@ -2,13 +2,13 @@
 
 > 原文： [https://howtodoinjava.com/java/basics/pairs-in-java/](https://howtodoinjava.com/java/basics/pairs-in-java/)
 
-使用**对**类，例如在 Java 中学习如何使用键值对。 `javafx.util.Pair`，`ImmutablePair`，`MmutablePair`（通用语言）和`io.vavr.Tuple2`类。
+使用**偶对**类，例如`javafx.util.Pair`，`ImmutablePair`，`MmutablePair`（通用语言）和`io.vavr.Tuple2`类，在 Java 中学习如何使用键值对
 
 > 阅读更多： [Java 中的元组](https://howtodoinjava.com/java/basics/java-tuples/)
 
 ## 1\. 为什么需要偶对？
 
-偶对提供了一种将简单键值关联的便捷方法。 在 Java 中，地图用于存储键值对。 地图存储成对的集合并作为整体进行操作。
+偶对提供了一种将简单键值关联的便捷方法。 在 Java 中，映射用于存储键值对。 映射存储成对的集合并作为整体进行操作。
 
 有时，我们需要处理一些要求，其中键值对应独立存在。 例如
 
@@ -21,11 +21,11 @@ Java 核心 API 具有`javafx.util.Pair`作为最接近的匹配，用于具有
 
 `Pair`类提供以下方法。
 
-*   `boolean equals​(Object o)` –测试此对与另一个对象的相等性。
-*   `K getKey()` –获取该对的密钥。
-*   `V getValue()` –获取该对的值。
-*   `int hashCode()` –为此对生成哈希码。
-*   `String toString()` –此对的字符串表示形式。
+*   `boolean equals​(Object o)` – 测试此对与另一个对象的相等性。
+*   `K getKey()` – 获取该对的键。
+*   `V getValue()` – 获取该对的值。
+*   `int hashCode()` – 为此对生成哈希码。
+*   `String toString()` – 此对的字符串表示形式。
 
 让我们看一个 **Java 程序来创建和使用**对。
 
@@ -45,12 +45,12 @@ pair.equals(new Pair<>(100, "example.com"));		//false	- different value
 
 ## 3\. `Pair`，`ImmutablePair`和`MutablePair` – Apache 公用语言
 
-Commons lang 库有一个有用的类，可以用于偶对，即 [org.apache.commons.lang3.tuple.Pair](https://commons.apache.org/proper/commons-lang/javadocs/api-3.1/org/apache/commons/lang3/tuple/Pair.html) 。 它有两个子类，也可以用于相同目的，即 [ImmutablePair](https://commons.apache.org/proper/commons-lang/javadocs/api-3.1/org/apache/commons/lang3/tuple/ImmutablePair.html) 和 [MutablePair](https://commons.apache.org/proper/commons-lang/javadocs/api-3.1/org/apache/commons/lang3/tuple/MutablePair.html) 。
+Commons lang 库有一个有用的类，可以用于偶对，即[`org.apache.commons.lang3.tuple.Pair`](https://commons.apache.org/proper/commons-lang/javadocs/api-3.1/org/apache/commons/lang3/tuple/Pair.html)。 它有两个子类，也可以用于相同目的，即[`ImmutablePair`](https://commons.apache.org/proper/commons-lang/javadocs/api-3.1/org/apache/commons/lang3/tuple/ImmutablePair.html)和[`MutablePair`](https://commons.apache.org/proper/commons-lang/javadocs/api-3.1/org/apache/commons/lang3/tuple/MutablePair.html)。
 
 *   `Pair`类是由两个元素组成的偶对。
 *   `Pair`将元素称为“左”和“右”。
 *   `Pair`还实现了`Map.Entry`接口，其中键为“左”，值为“右”。
-*   `ImmutablePair`是`Pair`上的[不变](https://howtodoinjava.com/java/basics/how-to-make-a-java-class-immutable/)表示。 如果将易变的对象存储在该对中，那么该对本身将有效地变为易变的。 该类也不是`final`，因此子类可能会添加不良行为。
+*   `ImmutablePair`是`Pair`上的[不变](https://howtodoinjava.com/java/basics/how-to-make-a-java-class-immutable/)表示。 如果将可变的对象存储在该对中，那么该对本身将有效地变为可变的。 该类也不是`final`，因此子类可能会添加不良行为。
 *   如果存储的对象是线程安全的，则`ImmutablePair`是[线程安全的](https://howtodoinjava.com/java/multi-threading/what-is-thread-safety/)。
 
 ```java

docs/java/62.md

@@ -117,7 +117,7 @@ public class ImmutableCollections {
 
 ```
 
-## 创建不可变地图
+## 创建不可变映射
 
 `Map`工厂方法与`List`或`Set`重载工厂方法相同。 唯一的区别是方法的签名采用交替的键和值作为参数。 例如
 

docs/java/79.md

@@ -45,7 +45,7 @@ while (true) {
 
 在此示例中，我们将看到一个观看目录的示例，该目录中包含所有子目录和文件。 我们将维护监视键和目录`Map<WatchKey, Path> keys`的映射，以正确识别已修改的目录。
 
-下面的方法将向观察者注册一个目录，然后将目录和密钥存储在地图中。
+下面的方法将向观察者注册一个目录，然后将目录和密钥存储在映射中。
 
 ```java
 private void registerDirectory(Path dir) throws IOException 
@@ -72,7 +72,7 @@ private void walkAndRegisterDirectories(final Path start) throws IOException {
 
 ```
 
-请注意，无论何时创建新目录，我们都会在 watchservice 中注册该目录，并将新密钥添加到地图中。
+请注意，无论何时创建新目录，我们都会在 watchservice 中注册该目录，并将新密钥添加到映射中。
 
 ```java
 WatchEvent.Kind kind = event.kind();