2020-05-21 15:11:02

docs/java/101.md

-# Java OOP 概念–面向对象的原则
+# Java OOP 概念 – 面向对象的原则
 
 > 原文： [https://howtodoinjava.com/oops/object-oriented-principles/](https://howtodoinjava.com/oops/object-oriented-principles/)
 
@@ -45,7 +45,7 @@ Abstraction captures only those details about an object that is relevant to the
 
     ```
 
-    因此，如果您想获取某个员工的信息，则可以从`Employee`对象中询问该信息–就像您在现实生活中一样，请询问此人本身。
+    因此，如果您想获取某个员工的信息，则可以从`Employee`对象中询问该信息 – 就像您在现实生活中一样，请询问此人本身。
 
 2.  #### 控制抽象
 
@@ -72,7 +72,7 @@ Abstraction captures only those details about an object that is relevant to the
 
 **将类**中的数据和方法与实现隐藏（通过访问控制）结合起来通常称为 OOP 中的[封装](https://howtodoinjava.com/oops/encapsulation-in-java-and-its-relation-with-abstraction/)。 结果是具有特征和行为的数据类型。 封装本质上既具有信息隐藏又具有实现隐藏。
 
-> “ **不管有什么变化，都将其封装**” –著名的设计原理
+> “ **不管有什么变化，都将其封装**” – 著名的设计原理
 
 **信息隐藏**是通过使用[访问控制修饰符](https://howtodoinjava.com/oops/java-access-modifiers/)（公共，私有，受保护的）完成的，而`implementation hiding`是通过创建类的接口来实现的。
 

docs/java/102.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://howtodoinjava.com/oops/java-access-modifiers/](https://howtodoinjava.com/oops/java-access-modifiers/)
 
-Java 访问修饰符–公共，受保护，私有和默认
+Java 访问修饰符 – 公共，受保护，私有和默认
 
 Java 提供**四个访问修饰符**来设置类，变量，方法和[构造器](https://howtodoinjava.com/oops/java-constructors/)的访问级别，即**公共**，**私有**，和**默认为**。 这些访问级别修饰符确定其他类是否可以使用特定字段或调用特定方法。
 
@@ -10,10 +10,10 @@ Java 提供**四个访问修饰符**来设置类，变量，方法和[构造器]
 
 简而言之，让我们快速比较这些访问修饰符。
 
-1.  **公开** –随处可见
-2.  **受保护的** –可在同一程序包和子类中访问
-3.  **默认** –仅在同一程序包中可访问
-4.  **私有** –仅可在同一班级访问
+1.  **公开** – 随处可见
+2.  **受保护的** – 可在同一程序包和子类中访问
+3.  **默认** – 仅在同一程序包中可访问
+4.  **私有** – 仅可在同一班级访问
 
 可以严格按以下顺序将访问说明符**排序为**：
 

docs/java/103.md

@@ -30,7 +30,7 @@ Private Constructor
 
 1.  **Default Constructor (no-arg constructor)**
 
-    如果程序员在类定义中不提供任何构造器– JVM 在运行时为该类提供默认构造器。
+    如果程序员在类定义中不提供任何构造器 – JVM 在运行时为该类提供默认构造器。
 
     程序员还可以覆盖类中的默认构造器。 让我们看一下语法。
 
@@ -70,7 +70,7 @@ Private Constructor
 
     ```
 
-    在上面的类中，我们定义了 3 个构造器来处理 3 种情况–应用程序可能需要如何创建 employee 对象，即不使用名称，仅使用名字以及同时使用名字和姓氏。
+    在上面的类中，我们定义了 3 个构造器来处理 3 种情况 – 应用程序可能需要如何创建 employee 对象，即不使用名称，仅使用名字以及同时使用名字和姓氏。
 
     ```java
     Employee employee1 = new Employee();
@@ -116,7 +116,7 @@ public Employee(String firstName, String lastName) {
 
 #### 调用超类构造器
 
-要从父类或父类调用构造器，请使用 **super** 关键字。 super 关键字的用法类似于`this`关键字–唯一的区别是`super`引用超类，`this`引用当前实例。
+要从父类或父类调用构造器，请使用 **super** 关键字。 super 关键字的用法类似于`this`关键字 – 唯一的区别是`super`引用超类，`this`引用当前实例。
 
 ```java
 public Employee() {	

docs/java/111.md

@@ -25,7 +25,7 @@ public class ArrayList<E> extends AbstractList<E>
 
 #### Java 扩展示例
 
-让我们从头开始创建一些东西，以更好地了解使用`extends`关键字的 Java 继承的工作方式。 我创建了两个类– `ParentClass`和`ChildClass`，其中 **ChildClass 扩展 ParentClass** 。
+让我们从头开始创建一些东西，以更好地了解使用`extends`关键字的 Java 继承的工作方式。 我创建了两个类 – `ParentClass`和`ChildClass`，其中 **ChildClass 扩展 ParentClass** 。
 
 ```java
 public class ParentClass {

docs/java/112.md

@@ -4,7 +4,7 @@
 
 **Java 实例**运算符（也称为类型比较[运算符](https://howtodoinjava.com/java/basics/operators-in-java/)）用于测试对象是否为指定类型（类，子类或接口）的实例。
 
-它返回–
+它返回 – 
 
 *   **是**-如果变量是指定类的实例，则它是父类或实现指定接口或父接口
 *   **否**-如果变量不是类的实例或接口的实现； 或变量为空

docs/java/113.md

@@ -95,7 +95,7 @@ public class Animal implements Moveable, Crawlable
 
 ## 3\. 多重继承期间可能发生的冲突
 
-在上面的示例中，我们有两个不同的接口和两个不同的方法–因此没有冲突。 如果**两个接口都决定定义一个具有相同名称**的新方法，该怎么办？ 好了，他们可以毫无问题地进行定义。 但是，当`Animal`实例调用其名称时，将调用哪种方法。
+在上面的示例中，我们有两个不同的接口和两个不同的方法 – 因此没有冲突。 如果**两个接口都决定定义一个具有相同名称**的新方法，该怎么办？ 好了，他们可以毫无问题地进行定义。 但是，当`Animal`实例调用其名称时，将调用哪种方法。
 
 那是矛盾的情况。
 

docs/java/118.md

-# Java 并发性–线程安全性？
+# Java 并发性 – 线程安全性？
 
 > 原文： [https://howtodoinjava.com/java/multi-threading/what-is-thread-safety/](https://howtodoinjava.com/java/multi-threading/what-is-thread-safety/)
 

docs/java/12.md

@@ -27,7 +27,7 @@ Java 提供**类型包装器**，它们是**封装对象内原始类型**的类
 
 ## 2\. 何时使用包装器类
 
-在场景中使用 Java 包装器类–
+在场景中使用 Java 包装器类 – 
 
 *   当两个方法要引用基本类型的相同实例时，请将包装器类作为方法参数传递。
 *   Java 中的泛型仅适用于对象，不支持原始类型。
@@ -38,7 +38,7 @@ Java 提供**类型包装器**，它们是**封装对象内原始类型**的类
 
 #### 3.1 包装器类的原始类型
 
-有两种方法可以将原始类型转换为相应包装类的对象–
+有两种方法可以将原始类型转换为相应包装类的对象 – 
 
 1.  使用**构造器**
 2.  使用**静态工厂方法**（例如`valueOf()`）（字符除外）

docs/java/120.md

-# Java 比较和交换示例– CAS 算法
+# Java 比较和交换示例 – CAS 算法
 
 > 原文： [https://howtodoinjava.com/java/multi-threading/compare-and-swap-cas-algorithm/](https://howtodoinjava.com/java/multi-threading/compare-and-swap-cas-algorithm/)
 

docs/java/121.md

@@ -6,7 +6,7 @@
 
 **同步的**关键字有助于编写应用程序的[并发](https://howtodoinjava.com/java-concurrency-tutorial/)部分，以保护此块中的共享资源。
 
-`synchronized`关键字可以与–
+`synchronized`关键字可以与 – 
 
 *   一个代码块
 *   一个方法
@@ -117,7 +117,7 @@ TWO :: 3
 
 #### 2.2 内部工作
 
-与同步块类似，线程必须使用同步方法来获取关联的监视对象上的锁。 如果采用同步方法，则锁定对象为–
+与同步块类似，线程必须使用同步方法来获取关联的监视对象上的锁。 如果采用同步方法，则锁定对象为 – 
 
 *   **'.class'对象**-如果该方法是静态的。
 *   **'此'对象**-如果方法不是静态的。 “ this”是指在其中调用同步方法的当前对象的引用。

docs/java/122.md

@@ -94,7 +94,7 @@ public class DemoClass
 
 ```
 
-## 3\. 对象级别锁与类级别锁–重要说明
+## 3\. 对象级别锁与类级别锁 – 重要说明
 
 1.  Java 中的同步保证了没有两个线程可以同时或并发执行需要相同锁的同步方法。
 2.  `synchronized`关键字只能与方法和代码块一起使用。 这些方法或块都可以是*静态*或*非静态*。

docs/java/125.md

-# Java 并发性– yield（）和 join（）之间的区别
+# Java 并发性 – yield（）和 join（）之间的区别
 
 > 原文： [https://howtodoinjava.com/java/multi-threading/difference-between-yield-and-join-in-threads-in-java/](https://howtodoinjava.com/java/multi-threading/difference-between-yield-and-join-in-threads-in-java/)
 

docs/java/126.md

@@ -4,7 +4,7 @@
 
 了解 Java 中 sleep（）和 wait（）方法之间的**区别。 了解何时使用哪种方法以及它们带来了 [Java 并发](https://howtodoinjava.com/java-concurrency-tutorial/)带来什么效果。**
 
-## 1\. Java sleep（）和 wait（）–讨论
+## 1\. Java sleep（）和 wait（） – 讨论
 
 **sleep（）**是一种用于暂停该过程几秒钟或我们想要的时间的方法。 但是，在使用 **wait（）**方法的情况下，线程进入等待状态，直到我们调用`notify()`或`notifyAll()`时，线程才会自动返回。
 
@@ -16,7 +16,7 @@
 
 > 阅读更多：[使用 wait（）和 notify（）](https://howtodoinjava.com/java/multi-threading/wait-notify-and-notifyall-methods/)
 
-## 2\. Java sleep（）和 wait（）–示例
+## 2\. Java sleep（）和 wait（） – 示例
 
 ```java
 synchronized(LOCK) {   
@@ -35,34 +35,34 @@ synchronized(LOCK)
 
 > 阅读更多： [yield（）和 join（）之间的区别](https://howtodoinjava.com/java/multi-threading/difference-between-yield-and-join-in-threads-in-java/)
 
-## 3\. Java sleep（）vs wait（）–摘要
+## 3\. Java sleep（）vs wait（） – 摘要
 
 简而言之，让我们对以上所有要点进行分类以记住。
 
 #### 3.1 调用方法
 
-*   `wait()` –调用对象； 当前线程必须在锁对象上同步。
-*   `sleep()` –调用线程； 始终当前正在执行的线程。
+*   `wait()` – 调用对象； 当前线程必须在锁对象上同步。
+*   `sleep()` – 调用线程； 始终当前正在执行的线程。
 
 #### 3.2 已同步
 
-*   `wait()` –同步多个线程时，一个线程一个对象访问一个对象。
-*   `sleep()` –同步时，多个线程等待休眠线程的休眠。
+*   `wait()` – 同步多个线程时，一个线程一个对象访问一个对象。
+*   `sleep()` – 同步时，多个线程等待休眠线程的休眠。
 
 #### 3.3 锁定时间
 
-*   `wait()` –释放其他对象有机会执行的锁定。
-*   `sleep()` –如果指定了超时或有人中断，请保持锁定至少 t 次。
+*   `wait()` – 释放其他对象有机会执行的锁定。
+*   `sleep()` – 如果指定了超时或有人中断，请保持锁定至少 t 次。
 
 #### 3.4 唤醒条件
 
-*   `wait()` –直到从对象调用 notify（），notifyAll（）
-*   `sleep()` –直到至少时间到期或调用 interrupt（）。
+*   `wait()` – 直到从对象调用 notify（），notifyAll（）
+*   `sleep()` – 直到至少时间到期或调用 interrupt（）。
 
 #### 3.5 用法
 
-*   `sleep()` –用于时间同步
-*   `wait()` –用于多线程同步。
+*   `sleep()` – 用于时间同步
+*   `wait()` – 用于多线程同步。
 
 希望以上信息将为您的知识库增加一些价值。
 

docs/java/127.md

-# 锁和监视器之间的区别– Java 并发
+# 锁和监视器之间的区别 – Java 并发
 
 > 原文： [https://howtodoinjava.com/java/multi-threading/multithreading-difference-between-lock-and-monitor/](https://howtodoinjava.com/java/multi-threading/multithreading-difference-between-lock-and-monitor/)
 

docs/java/128.md

@@ -111,9 +111,9 @@ Future result is -  - 2; And Task done is true
 
 ```
 
-在这里，我们使用`submit()`方法发送了一个`Callable`对象，该对象将在执行程序中执行。 此方法接收`Callable`对象作为参数，并返回一个`Future`对象，我们可以将其用于两个主要目标–
+在这里，我们使用`submit()`方法发送了一个`Callable`对象，该对象将在执行程序中执行。 此方法接收`Callable`对象作为参数，并返回一个`Future`对象，我们可以将其用于两个主要目标 – 
 
-1.  **我们可以控制任务的状态** –我们可以取消任务并检查任务是否完成。 为此，我们使用`isDone()`方法检查任务是否完成。
+1.  **我们可以控制任务的状态** – 我们可以取消任务并检查任务是否完成。 为此，我们使用`isDone()`方法检查任务是否完成。
 2.  **We can get the result returned by the call() method**. For this purpose, we have used the `get()` method. This method waits until the `Callable` object has finished the execution of the `call()` method and has returned its result.
 
     如果在`get()`方法等待结果时线程被中断，则它将引发`InterruptedException`异常。 如果`call()`方法引发异常，则此方法引发`ExecutionException`异常。

docs/java/131.md

@@ -96,7 +96,7 @@ class TestTwo implements Runnable {
 
 请不要忘记在帖子结尾阅读最佳实践。
 
-## 2\. Java 执行程序框架–可多运行
+## 2\. Java 执行程序框架 – 可多运行
 
 不必每个`Runnable`都在单独的线程中执行。 有时，我们需要在单个线程中执行多个作业，并且每个作业都是`Runnable`的实例。 要设计此类解决方案，应使用**多可运行**。 这个多可运行对象不过是需要执行的可运行对象的集合。 唯一的补充是，该多可运行库本身也是**可运行库**。
 

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/)
 

docs/java/135.md

@@ -24,13 +24,13 @@ Java 集合层次结构
 
 **列表**表示元素的**有序**集合。 使用列表，我们可以按元素的整数索引（列表中的位置）访问元素，并在列表中搜索元素。 索引以`0`开头，就像数组一样。
 
-实现`List`接口的一些有用的类是– **ArrayList** ， **CopyOnWriteArrayList** ， **LinkedList** ，**堆栈**和**向量** 。
+实现`List`接口的一些有用的类是 – **ArrayList** ， **CopyOnWriteArrayList** ， **LinkedList** ，**堆栈**和**向量** 。
 
 #### 1.3 组
 
 **集**代表**排序的**元素的集合。 集不允许重复的元素。 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 映射
 
@@ -38,7 +38,7 @@ Java 集合层次结构
 
 Map 界面提供了三个集合视图，这些视图允许将映射的内容作为一组键，值的集合或一组键-值映射来查看。 一些映射实现（例如 TreeMap 类）对其顺序做出特定的保证。 其他的（例如 HashMap 类）则没有。
 
-实现`Map`接口的一些有用的类是– **ConcurrentHashMap** ， **ConcurrentSkipListMap** ， **EnumMap** ， **HashMap** ，**哈希表** ， **IdentityHashMap** ， **LinkedHashMap** ，**属性**， **TreeMap** 和 **WeakHashMap** 。
+实现`Map`接口的一些有用的类是 – **ConcurrentHashMap** ， **ConcurrentSkipListMap** ， **EnumMap** ， **HashMap** ，**哈希表** ， **IdentityHashMap** ， **LinkedHashMap** ，**属性**， **TreeMap** 和 **WeakHashMap** 。
 
 #### 1.5 堆
 
@@ -52,7 +52,7 @@ Java **堆栈**接口表示经典的堆栈数据结构，其中的元素可以
 
 通常，队列不支持阻止插入或检索操作。 阻塞队列实现类实现了 **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 和
 
@@ -119,7 +119,7 @@ list.forEach(System.out::print);
 
     所有集合类都具有一致的实现，并提供一些常见的方法，例如 add，get，put，remove 等。无论您要处理哪种数据结构，这些方法都将根据基础实现工作并透明地执行操作。
 
-*   **更少的开发时间** –通用且可预测的框架总是会减少开发时间，并有助于快速编写应用程序。 Java 集合还有助于对对象和集合执行一些最重复的常见任务，从而改善时间因素。
+*   **更少的开发时间** – 通用且可预测的框架总是会减少开发时间，并有助于快速编写应用程序。 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.
 

docs/java/137.md

@@ -14,13 +14,13 @@ ArrayList 层次结构
 
 ## 1\. ArrayList 功能
 
-ArrayList 具有以下功能–
+ArrayList 具有以下功能 – 
 
 1.  **有序** – arraylist 中的元素保留其顺序，默认情况下是其添加到列表的顺序。
-2.  **基于索引的** –可以使用索引位置随机访问元素。 索引以`'0'`开头。
-3.  **动态调整大小** –当需要添加的元素数量超过当前大小时，ArrayList 动态增长。
-4.  **不同步** –默认情况下，ArrayList 不同步。 程序员需要适当地使用`synchronized`关键字，或简单地使用 **Vector** 类。
-5.  **允许重复** –我们可以在 arraylist 中添加重复元素。 不能成组放置。
+2.  **基于索引的** – 可以使用索引位置随机访问元素。 索引以`'0'`开头。
+3.  **动态调整大小** – 当需要添加的元素数量超过当前大小时，ArrayList 动态增长。
+4.  **不同步** – 默认情况下，ArrayList 不同步。 程序员需要适当地使用`synchronized`关键字，或简单地使用 **Vector** 类。
+5.  **允许重复** – 我们可以在 arraylist 中添加重复元素。 不能成组放置。
 
 ## 2\. ArrayList 的内部工作
 
@@ -105,7 +105,7 @@ while(iterator.hasNext()) {
 [ArrayList add（）方法示例](https://howtodoinjava.com/java/collections/arraylist/arraylist-add-example/)
 [ArrayList addAll（）方法示例](https://howtodoinjava.com/java/collections/arraylist/arraylist-addall-method-example/)
 [ArrayList clear（）方法示例](https://howtodoinjava.com/java/collections/arraylist/clear-empty-arraylist/)
-[ArrayList 克隆 （）–如何克隆 ArrayList](https://howtodoinjava.com/java/collections/arraylist/arraylist-clone-deep-copy/)
+[ArrayList 克隆 （） – 如何克隆 ArrayList](https://howtodoinjava.com/java/collections/arraylist/arraylist-clone-deep-copy/)
 [ArrayList contains（）方法示例](https://howtodoinjava.com/java/collections/arraylist/arraylist-contains/)
 [ArrayList sureCapacity（）方法示例](https://howtodoinjava.com/java/collections/arraylist/arraylist-ensurecapacity-method/)
 [ArrayList forEach（ ）方法示例](https://howtodoinjava.com/java/collections/arraylist/arraylist-foreach/)

docs/java/139.md

@@ -71,7 +71,7 @@ Entry 类的所有实例都存储在声明为`'transient Entry[] table'`的数
 
 让我们快速浏览一些示例，以在 Java 中使用 HashMap。
 
-#### 4.1 添加键值– HashMap.put（）
+#### 4.1 添加键值 – HashMap.put（）
 
 ```java
 import java.util.HashMap;
@@ -99,7 +99,7 @@ public class HashMapExample
 
 ```
 
-#### 4.2 通过键获取价值– HashMap.get（）
+#### 4.2 通过键获取价值 – HashMap.get（）
 
 ```java
 HashMap<Integer, String> map = new HashMap<>();
@@ -121,7 +121,7 @@ The value is :: B
 
 ```
 
-#### 4.3 通过键删除配对– HashMap.remove（）
+#### 4.3 通过键删除配对 – HashMap.remove（）
 
 ```java
 HashMap<Integer, String> map = new HashMap<>();

docs/java/155.md

@@ -21,7 +21,7 @@ Table of Contents
 
 ## 1\. CopyOnWriteArrayList 层次结构
 
-`CopyOnWriteArrayList`类实现以下接口– List，RandomAccess，[可克隆](https://howtodoinjava.com/java/cloning/a-guide-to-object-cloning-in-java/)和[可序列化](https://howtodoinjava.com/java/serialization/custom-serialization-readobject-writeobject/)。
+`CopyOnWriteArrayList`类实现以下接口 – List，RandomAccess，[可克隆](https://howtodoinjava.com/java/cloning/a-guide-to-object-cloning-in-java/)和[可序列化](https://howtodoinjava.com/java/serialization/custom-serialization-readobject-writeobject/)。
 
 ```java
 public class CopyOnWriteArrayList<E>

docs/java/158.md

@@ -118,7 +118,7 @@ public interface Collection extends Iterable {
 
 由于存在如此大的差异，因此在 Map 界面中未使用 Collection 界面，而是在单独的层次结构中构建。
 
-## Java 集合访谈–列出接口问题
+## Java 集合访谈 – 列出接口问题
 
 #### 5）为什么要使用 List 接口？ 什么是实现 List 接口的主要类？
 
@@ -160,7 +160,7 @@ List numsList = Arrays.asList(nums);
 
 ```
 
-## Java 集合面试–设置接口问题
+## Java 集合面试 – 设置接口问题
 
 #### 8）为什么要使用 Set 接口？ 什么是实现 Set 接口的主要类？
 
@@ -211,7 +211,7 @@ private static final Object PRESENT = new Object();
 
 NavigableMap 是 SortedMap 的子类型，不允许使用 null 键。 因此，本质上， **TreeSet 也不支持空键**。 如果您尝试在 TreeSet 中添加 null 元素，它将抛出 NullPointerException。
 
-## Java 集合面试– Map 接口问题
+## Java 集合面试 – Map 接口问题
 
 #### 11）为什么要使用 Map 界面？ 什么是实现 Map 接口的主要类？
 
@@ -291,7 +291,7 @@ TreeMap 是 HashMap 的特殊形式。 **它维护 HashMap 类中缺少的键**
 
 请注意，**所有插入映射的键都必须实现 Comparable 接口**（这是确定顺序的必要条件）。 此外，所有这些键必须相互可比较：k1.compareTo（k2）不得为映射中的任何键 k1 和 k2 抛出 ClassCastException。 如果用户尝试将键放入违反此约束的映射中（例如，用户尝试将字符串键放入其键为整数的映射中），则 put（Object key，Object value）调用将引发 ClassCastException 。
 
-## Java 集合访谈–讲述差异问题
+## Java 集合访谈 – 讲述差异问题
 
 #### 18）Set 和 List 之间的区别？
 

docs/java/16.md

@@ -155,7 +155,7 @@
 
     ```
 
-2.  [`int indexOf(String str)`](https://howtodoinjava.com/java/string/java-string-indexof-method-example/) –返回指定子字符串`str`首次出现的索引。
+2.  [`int indexOf(String str)`](https://howtodoinjava.com/java/string/java-string-indexof-method-example/) – 返回指定子字符串`str`首次出现的索引。
 
     ```java
     String blogName = "howtodoinjava.com";
@@ -263,7 +263,7 @@
 
     ```
 
-4.  [`String.replaceAll(String regex, String replacement)`](https://howtodoinjava.com/java/string/java-string-replaceall-example/) –用替换字符串替换所有出现的与正则表达式参数匹配的子字符串。
+4.  [`String.replaceAll(String regex, String replacement)`](https://howtodoinjava.com/java/string/java-string-replaceall-example/) – 用替换字符串替换所有出现的与正则表达式参数匹配的子字符串。
 
 5.  [`String[] split（String regex, int limit）`](https://howtodoinjava.com/java/string/java-string-split-example/) – 拆分字符串并返回与给定正则表达式匹配的子字符串数组。 `limit`是数组中元素的最大数量。
 

docs/java/165.md

-# Java –创建新文件
+# Java – 创建新文件
 
 > 原文： [https://howtodoinjava.com/java/io/how-to-create-a-new-file-in-java/](https://howtodoinjava.com/java/io/how-to-create-a-new-file-in-java/)
 
@@ -8,7 +8,7 @@
 
 ## 1\. 使用 java.io.File 类创建文件
 
-使用[`File.createNewFile()`](https://docs.oracle.com/javase/7/docs/api/java/io/File.html#createNewFile())方法创建新文件。 此方法返回布尔值–
+使用[`File.createNewFile()`](https://docs.oracle.com/javase/7/docs/api/java/io/File.html#createNewFile())方法创建新文件。 此方法返回布尔值 – 
 
 *   `true`如果文件创建成功。
 *   `false`如果文件已经存在或由于某种原因操作失败。
@@ -47,7 +47,7 @@ out.close();
 
 ```
 
-## 3）使用 java.nio.file.Files 创建文件– Java NIO
+## 3）使用 java.nio.file.Files 创建文件 – Java NIO
 
 [Files.write（）](https://docs.oracle.com/javase/7/docs/api/java/nio/file/Files.html#write(java.nio.file.Path,%20java.lang.Iterable,%20java.nio.charset.Charset,%20java.nio.file.OpenOption...))是**创建文件**的最佳方法，如果您尚未使用它，则应该是将来的首选方法。
 

docs/java/166.md

-# Java –写入文件
+# Java – 写入文件
 
 > 原文： [https://howtodoinjava.com/java/io/java-write-to-file/](https://howtodoinjava.com/java/io/java-write-to-file/)
 

docs/java/167.md

-# Java –附加到文件
+# Java – 附加到文件
 
 > 原文： [https://howtodoinjava.com/java/io/java-append-to-file/](https://howtodoinjava.com/java/io/java-append-to-file/)
 

docs/java/169.md

@@ -72,7 +72,7 @@ Learn to grow.
 
 ```
 
-## Files.lines（）–在 Java 8 中将文件读取为字符串
+## Files.lines（） – 在 Java 8 中将文件读取为字符串
 
 [lines（）](https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html#lines-java.nio.file.Path-java.nio.charset.Charset-)方法**从文件中读取所有行以流**，并随着[流](//howtodoinjava.com/java8/java-8-tutorial-streams-by-examples/)被消耗而懒惰地填充。 使用指定的字符集将文件中的字节解码为字符。
 
@@ -120,7 +120,7 @@ Welcome to howtodoinjava.com blog.
 Learn to grow.
 ```
 
-## 将整个文件读到字符串– Files.readAllBytes（）[≥Java 7]
+## 将整个文件读到字符串 – Files.readAllBytes（）[≥Java 7]
 
 [readAllBytes（）](https://docs.oracle.com/javase/7/docs/api/java/nio/file/Files.html#readAllBytes(java.nio.file.Path))方法*从文件*读取所有字节。 该方法可确保在读取所有字节或引发 I/O 错误或其他运行时异常时关闭文件。
 
@@ -168,7 +168,7 @@ Welcome to howtodoinjava.com blog.
 Learn to grow.
 ```
 
-## 逐行读取文件– BufferedReader [< Java 7]
+## 逐行读取文件 – BufferedReader [< Java 7]
 
 如果仍不使用 Java 7 或更高版本，则使用 [BufferedReader](https://docs.oracle.com/javase/7/docs/api/java/io/BufferedReader.html) 类。 `readLine()`方法**一次读取一行文件**，然后返回内容。
 

docs/java/17.md

-# Java 创建类–如何创建对象？
+# Java 创建类 – 如何创建对象？
 
 > 原文： [https://howtodoinjava.com/java/basics/how-to-create-a-class-in-java/](https://howtodoinjava.com/java/basics/how-to-create-a-class-in-java/)
 

docs/java/171.md

-# Java –逐行读取文件– LineNumberReader
+# Java – 逐行读取文件 – LineNumberReader
 
 > 原文： [https://howtodoinjava.com/java/io/java-io-linenumberreader-example-to-read-file-line-by-line/](https://howtodoinjava.com/java/io/java-io-linenumberreader-example-to-read-file-line-by-line/)
 

docs/java/175.md

-# 从资源文件夹读取文件– Spring 示例
+# 从资源文件夹读取文件 – Spring 示例
 
 > 原文： [https://howtodoinjava.com/java/io/read-file-from-resources-folder/](https://howtodoinjava.com/java/io/read-file-from-resources-folder/)
 
@@ -78,7 +78,7 @@ File Found : true
 Test Content
 ```
 
-## 在春季读取文件– ResourceUtils.getFile（）
+## 在春季读取文件 – ResourceUtils.getFile（）
 
 如果您的应用程序是基于 **spring** 或 **spring boot** 的应用程序，则您可以直接利用`ResourceUtils`类。
 

docs/java/176.md

-# Java –读写 UTF-8 编码数据
+# Java – 读写 UTF-8 编码数据
 
 > 原文： [https://howtodoinjava.com/java/io/how-to-read-write-utf-8-encoded-data-in-java/](https://howtodoinjava.com/java/io/how-to-read-write-utf-8-encoded-data-in-java/)
 

docs/java/178.md

-# Java 文件复制–用 Java 复制文件的 4 种方法
+# Java 文件复制 – 用 Java 复制文件的 4 种方法
 
 > 原文： [https://howtodoinjava.com/java/io/4-ways-to-copy-files-in-java/](https://howtodoinjava.com/java/io/4-ways-to-copy-files-in-java/)
 

docs/java/179.md

-# Java FilenameFilter 示例–查找/删除某些扩展名的文件
+# Java FilenameFilter 示例 – 查找/删除某些扩展名的文件
 
 > 原文： [https://howtodoinjava.com/java/io/how-to-find-delete-files-of-certain-extension-filenamefilter-example/](https://howtodoinjava.com/java/io/how-to-find-delete-files-of-certain-extension-filenamefilter-example/)
 

docs/java/181.md

-# Java –创建临时文件
+# Java – 创建临时文件
 
 > 原文： [https://howtodoinjava.com/java/io/create-a-temporary-file-in-java/](https://howtodoinjava.com/java/io/create-a-temporary-file-in-java/)
 

docs/java/182.md

-# Java –写入临时文件
+# Java – 写入临时文件
 
 > 原文： [https://howtodoinjava.com/java/io/write-data-to-temporary-file-in-java/](https://howtodoinjava.com/java/io/write-data-to-temporary-file-in-java/)
 

docs/java/183.md

-# Java –删除临时文件
+# Java – 删除临时文件
 
 > 原文： [https://howtodoinjava.com/java/io/how-to-delete-temporary-file-in-java/](https://howtodoinjava.com/java/io/how-to-delete-temporary-file-in-java/)
 

docs/java/184.md

-# Java –读取控制台输入
+# Java – 读取控制台输入
 
 > 原文： [https://howtodoinjava.com/java/io/java-io-how-to-read-input-from-console/](https://howtodoinjava.com/java/io/java-io-how-to-read-input-from-console/)
 

docs/java/185.md

-# Java –使用 Scanner 类读取类型安全输入
+# Java – 使用 Scanner 类读取类型安全输入
 
 > 原文： [https://howtodoinjava.com/java/io/read-typesafe-input-scanner-class/](https://howtodoinjava.com/java/io/read-typesafe-input-scanner-class/)
 

docs/java/188.md

-# Java –创建受密码保护的 Zip 文件
+# Java – 创建受密码保护的 Zip 文件
 
 > 原文： [https://howtodoinjava.com/java/io/how-to-create-password-protected-zip-files-in-java/](https://howtodoinjava.com/java/io/how-to-create-password-protected-zip-files-in-java/)
 

docs/java/189.md

-# Java –解压缩带有子目录的文件
+# Java – 解压缩带有子目录的文件
 
 > 原文： [https://howtodoinjava.com/java/io/unzip-file-with-subdirectories/](https://howtodoinjava.com/java/io/unzip-file-with-subdirectories/)
 

docs/java/193.md

-# Java –日期和时间 API
+# Java – 日期和时间 API
 
 > 原文： [https://howtodoinjava.com/java-date-and-time-apis/](https://howtodoinjava.com/java-date-and-time-apis/)
 
@@ -94,26 +94,26 @@ System.out.println(formattedDate);	//	03-05-2020 13:46
 
 ## 4\. 更多例子
 
-[Java –获取两个日期之间的所有日期](https://howtodoinjava.com/java/date-time/dates-between-two-dates/)
+[Java – 获取两个日期之间的所有日期](https://howtodoinjava.com/java/date-time/dates-between-two-dates/)
 [Java 8-获取下一个和上一个日期](https://howtodoinjava.com/java/date-time/java8-next-previous-date/)
 [Java 8-获取当前日期时间](https://howtodoinjava.com/java/date-time/current-date-time/)
-[Java 8 –获取当前时间戳](https://howtodoinjava.com/java/date-time/get-current-timestamp/)
-[Java 8 –日期比较](https://howtodoinjava.com/java/date-time/compare-dates/)
+[Java 8 – 获取当前时间戳](https://howtodoinjava.com/java/date-time/get-current-timestamp/)
+[Java 8 – 日期比较](https://howtodoinjava.com/java/date-time/compare-dates/)
 [Java 8-转换为 EST 时区](https://howtodoinjava.com/java/date-time/convert-date-time-to-est-est5edt/)
-[Java 8 –测量经过时间](https://howtodoinjava.com/java/date-time/execution-elapsed-time/)
-[Java 8 –添加日期至今](https://howtodoinjava.com/java/date-time/add-days-to-date-localdatetime/)
-[Java 8 –两个日期之间的差额](https://howtodoinjava.com/java/date-time/duration-between-two-dates/)
+[Java 8 – 测量经过时间](https://howtodoinjava.com/java/date-time/execution-elapsed-time/)
+[Java 8 – 添加日期至今](https://howtodoinjava.com/java/date-time/add-days-to-date-localdatetime/)
+[Java 8 – 两个日期之间的差额](https://howtodoinjava.com/java/date-time/duration-between-two-dates/)
 [Java 8 – 两个日期之间的差异](https://howtodoinjava.com/java/date-time/calculate-difference-between-two-dates-in-java/)
-[Java 8 –加或减 N 个工作日](https://howtodoinjava.com/java/date-time/add-subtract-business-days/)
-[Java 8 –计算两个日期之间的工作日](https://howtodoinjava.com/java/date-time/calculate-business-days/)
+[Java 8 – 加或减 N 个工作日](https://howtodoinjava.com/java/date-time/add-subtract-business-days/)
+[Java 8 – 计算两个日期之间的工作日](https://howtodoinjava.com/java/date-time/calculate-business-days/)
 [Java 8 – 计算两个日期之间的天数](https://howtodoinjava.com/java/date-time/calculate-days-between-dates/)
-[Java –获取当前用户区域设置](https://howtodoinjava.com/java/date-time/how-to-get-current-user-locale-in-java/)
-[Java –检查给定的年份是否为 leap 年？](https://howtodoinjava.com/java/date-time/check-leap-year/)
-[Java –解析字符串至今](https://howtodoinjava.com/java/date-time/java-parse-string-to-date/)
-[Java –将 XMLGregorianCalendar 格式设置为“ MM / dd / yyyy hh：mm a z”模式](https://howtodoinjava.com/java/date-time/format-xmlgregoriancalendar-to-date-pattern/)
-[Java –将 XMLGregorianCalendar 格式化为字符串](https://howtodoinjava.com/java/date-time/xmlgregoriancalendar-date-string-example/)
-[Java –以 12 小时格式格式化日期/时间戳](https://howtodoinjava.com/java/date-time/format-time-12-hours-pattern/)
-[Java –时区转换](https://howtodoinjava.com/java/date-time/convert-date-between-timezones/)
+[Java – 获取当前用户区域设置](https://howtodoinjava.com/java/date-time/how-to-get-current-user-locale-in-java/)
+[Java – 检查给定的年份是否为 leap 年？](https://howtodoinjava.com/java/date-time/check-leap-year/)
+[Java – 解析字符串至今](https://howtodoinjava.com/java/date-time/java-parse-string-to-date/)
+[Java – 将 XMLGregorianCalendar 格式设置为“ MM / dd / yyyy hh：mm a z”模式](https://howtodoinjava.com/java/date-time/format-xmlgregoriancalendar-to-date-pattern/)
+[Java – 将 XMLGregorianCalendar 格式化为字符串](https://howtodoinjava.com/java/date-time/xmlgregoriancalendar-date-string-example/)
+[Java – 以 12 小时格式格式化日期/时间戳](https://howtodoinjava.com/java/date-time/format-time-12-hours-pattern/)
+[Java – 时区转换](https://howtodoinjava.com/java/date-time/convert-date-between-timezones/)
 [Java – 严格日期验证](https://howtodoinjava.com/java/date-time/strict-date-validation-simpledateformat-setlenient/)
 
 学习愉快！

docs/java/194.md

-# Java –日期验证
+# Java – 日期验证
 
 > 原文： [https://howtodoinjava.com/java/date-time/date-validation/](https://howtodoinjava.com/java/date-time/date-validation/)
 

docs/java/195.md

-# Java –日期格式
+# Java – 日期格式
 
 > 原文： [https://howtodoinjava.com/java/date-time/java-date-formatting/](https://howtodoinjava.com/java/date-time/java-date-formatting/)
 
@@ -92,12 +92,12 @@ public class DateFormatting
 | `A` | 毫秒 | Number | 1234 |
 | `n` | 纳秒 | Number | 987654321 |
 | `N` | 纳秒级 | Number | 1234560000 |
-| `V` | 时区编号 | 区域编号 | America / Los_Angeles 或 Z 或–08：30 |
+| `V` | 时区编号 | 区域编号 | America / Los_Angeles 或 Z 或 – 08：30 |
 | `z` | 时区名称 | 区域名称 | 太平洋标准时间（PST） |
-| `X` | 区域偏移 *Z* 为零 | 偏移量 X | Z 或–08 或–0830 或–08：30 或–083015 或–08：30：15 |
-| `x` | 区域偏移 | 偏移 x | +0000 或–08 或–0830 或–08：30 或–083015 或–08：30：15 |
-| `Z` | Zone offset | 偏移 Z | +0000 或–0800 或–08：00 |
-| `O` | 局部区域偏移 | 偏移量 | GMT + 8 或 GMT + 08：00 或 UTC–08：00 |
+| `X` | 区域偏移 *Z* 为零 | 偏移量 X | Z 或 – 08 或 – 0830 或 – 08：30 或 – 083015 或 – 08：30：15 |
+| `x` | 区域偏移 | 偏移 x | +0000 或 – 08 或 – 0830 或 – 08：30 或 – 083015 或 – 08：30：15 |
+| `Z` | Zone offset | 偏移 Z | +0000 或 – 0800 或 – 08：00 |
+| `O` | 局部区域偏移 | 偏移量 | GMT + 8 或 GMT + 08：00 或 UTC – 08：00 |
 | `p` | 垫下 | 垫编辑 | 1 |
 
 #### 1.3 UnsupportedTemporalTypeException

docs/java/199.md

@@ -141,7 +141,7 @@ ZonedDateTime zonedDateTime2 = now.minusYears(1);
 [在 Java 中将 LocalDate 转换为 ZonedDateTime](https://howtodoinjava.com/java/date-time/localdate-zoneddatetime-conversion/)
 [ZonedDateTime 时区转换示例](https://howtodoinjava.com/java/date-time/convert-date-between-timezones/)
 [比较 ZonedDateTime 实例](https://howtodoinjava.com/java/date-time/zoneddatetime-comparison/)
-[Java 8 –将字符串解析为 UTC 中的日期时间](https://howtodoinjava.com/java8/parse-string-to-date-time-utc-gmt/)
+[Java 8 – 将字符串解析为 UTC 中的日期时间](https://howtodoinjava.com/java8/parse-string-to-date-time-utc-gmt/)
 
 在评论中向我发送有关 **Java 8 ZonedDateTime** 类的问题。
 

docs/java/200.md

-# Java 8 –句点
+# Java 8 – 句点
 
 > 原文： [https://howtodoinjava.com/java/date-time/java8-period/](https://howtodoinjava.com/java/date-time/java8-period/)
 
@@ -33,10 +33,10 @@ System.out.println(periodBetween.get(ChronoUnit.DAYS));	//8
 
 `Period`分类以下方法，以不同单位表示时间段：
 
-*   **of Days（整数天）** –表示天数的期间。
-*   **of Months（整数月）** –表示月数的期间。
-*   周的**（以周为单位）** –表示周数的期间。
-*   **of Years（int years）** –表示年数的期间。
+*   **of Days（整数天）** – 表示天数的期间。
+*   **of Months（整数月）** – 表示月数的期间。
+*   周的**（以周为单位）** – 表示周数的期间。
+*   **of Years（int years）** – 表示年数的期间。
 
 ```java
 Period fromDays = Period.ofDays(150);	// 150 days
@@ -102,15 +102,15 @@ System.out.println(periodBetween.get(ChronoUnit.WEEKS));
 
 我们可以从给定的`Period`对象中添加或减去一段时间。 支持加减法的方法有：
 
-*   **加（句点）** –返回给定周期的副本，其中添加了指定的周期。
-*   **plusYears（）** –返回给定期间的副本，其中添加了指定的年份。
-*   **plusMonths（）** –返回给定期间的副本，其中添加了指定的月份。
-*   **plusDays（）** –返回给定期间的副本，其中添加了指定的日期。
+*   **加（句点）** – 返回给定周期的副本，其中添加了指定的周期。
+*   **plusYears（）** – 返回给定期间的副本，其中添加了指定的年份。
+*   **plusMonths（）** – 返回给定期间的副本，其中添加了指定的月份。
+*   **plusDays（）** – 返回给定期间的副本，其中添加了指定的日期。
 *   **minus（period）**-返回给定周期的副本，减去指定周期。
 *   **minusYears（）**-返回给定期间的副本，其中减去指定的年份。
-*   **minusMonths（）** –返回给定期间的副本，其中减去指定的月份。
-*   **minusDays（）** –返回给定期间的副本，其中减去指定天数。
-*   **multipliedBy（scalar）** –返回一个新实例，该实例中的每个元素都乘以指定的标量。
+*   **minusMonths（）** – 返回给定期间的副本，其中减去指定的月份。
+*   **minusDays（）** – 返回给定期间的副本，其中减去指定天数。
+*   **multipliedBy（scalar）** – 返回一个新实例，该实例中的每个元素都乘以指定的标量。
 
 ```java
 Period period = Period.ofDays(5);

docs/java/201.md

@@ -109,7 +109,7 @@ System.out.println(localTimeString);		// 02:53 PM
 
 ## 7\. 更多例子
 
-1.  [Java 8 ResolverStyle.STRICT –严格的日期验证和解析](https://howtodoinjava.com/java8/resolverstyle-strict-date-parsing/)
+1.  [Java 8 ResolverStyle.STRICT – 严格的日期验证和解析](https://howtodoinjava.com/java8/resolverstyle-strict-date-parsing/)
 
 学习愉快！
 

docs/java/205.md

-# Java 日期–解析，格式和转换
+# Java 日期 – 解析，格式和转换
 
 > 原文： [https://howtodoinjava.com/java/date-time/java-date-examples/](https://howtodoinjava.com/java/date-time/java-date-examples/)
 

docs/java/206.md

-# Java 语言环境–创建和设置默认语言环境
+# Java 语言环境 – 创建和设置默认语言环境
 
 > 原文： [https://howtodoinjava.com/java/date-time/java-locale-api-examples/](https://howtodoinjava.com/java/date-time/java-locale-api-examples/)
 
@@ -119,8 +119,8 @@ Locale.setDefault(Locale.FRANCE);
 
 `Locale.Category`枚举表示两个区域设置类别：
 
-1.  `Locale.Category.DISPLAY` –适用于**应用程序的用户界面**，例如资源束消息。
-2.  `Locale.Category.FORMAT` –用于日期和数字格式，具体取决于特定的区域信息
+1.  `Locale.Category.DISPLAY` – 适用于**应用程序的用户界面**，例如资源束消息。
+2.  `Locale.Category.FORMAT` – 用于日期和数字格式，具体取决于特定的区域信息
 
 ```java
 Locale.setDefault(Locale.Category.DISPLAY, Locale.US);

docs/java/208.md

@@ -286,9 +286,9 @@ System.out.println( east.equals( eastNew ) );    //true
 
 > 您可以使用`'=='`运算符或`equals()`方法比较**枚举类型**，因为默认情况下枚举是 singlton 且可比较。
 
-## 6\. 枚举集合– EnumSet 和 EnumMap
+## 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

@@ -71,7 +71,7 @@ Output:
 https://prod.domain.com:1088/
 ```
 
-## 4\. 按名称获取枚举–枚举字符串参数
+## 4\. 按名称获取枚举 – 枚举字符串参数
 
 如果您想使用它的名称获取枚举常量，请使用`valueOf()`方法。
 
@@ -89,7 +89,7 @@ Output:
 https://sit.domain.com:2019/
 ```
 
-## 5\. 反向查找–从值中获取枚举名称
+## 5\. 反向查找 – 从值中获取枚举名称
 
 很多时候，我们将拥有枚举的值，并且我们将需要**通过字符串**值获取枚举名称。 这可以通过反向查找来实现。
 

docs/java/213.md

@@ -115,7 +115,7 @@ finally {
 
 我们来看一些示例，以了解在不同情况下执行流程的流程。
 
-#### 3.1 尝试，捕获并最终阻止–没有发生异常
+#### 3.1 尝试，捕获并最终阻止 – 没有发生异常
 
 如果没有发生异常，那么 JVM 将仅执行 finally 块。 捕获块将被跳过。
 
@@ -143,7 +143,7 @@ finally block
 
 ```
 
-#### 3.2 尝试，捕获并最终阻止–发生异常
+#### 3.2 尝试，捕获并最终阻止 – 发生异常
 
 如果 try 块中发生异常，则 JVM 将首先执行 catch 块，然后最后执行。
 
@@ -174,7 +174,7 @@ finally block
 
 ```
 
-#### 3.3 尝试并最终阻止–未处理异常
+#### 3.3 尝试并最终阻止 – 未处理异常
 
 如果提供的 catch 块未处理异常，则 JVM 默认异常处理程序将处理该异常。 在这种情况下，将执行**最终块**，然后执行默认的异常处理机制。
 
@@ -204,7 +204,7 @@ java.lang.NullPointerException: Null occurred
 
 ```
 
-#### 3.4 尝试，捕获并最终阻止–多个捕获块
+#### 3.4 尝试，捕获并最终阻止 – 多个捕获块
 
 如果有多个 catch 块与 try 块相关联，则异常由顺序处理的第一个 catch 块处理，该异常可以处理异常类型或其父类型。
 
@@ -245,7 +245,7 @@ finally block
 
 ```
 
-#### 3.5 尝试，捕获并最终阻止–捕获块引发异常
+#### 3.5 尝试，捕获并最终阻止 – 捕获块引发异常
 
 在 catch 块中处理另一个异常时，有时可能会出现异常。 它将如何处理？
 

docs/java/215.md

@@ -63,7 +63,7 @@ public static void main(String[] args)
 
 ```
 
-在上述情况下，您将获得消息– `Unhandled exception type FileNotFoundException`的编译时错误。
+在上述情况下，您将获得消息 – `Unhandled exception type FileNotFoundException`的编译时错误。
 
 为了使程序能够编译，您必须在`try-catch`块中处理此错误情况。 下面给出的代码将完全可以编译。
 

docs/java/218.md

-# Java 自定义异常–最佳实践
+# Java 自定义异常 – 最佳实践
 
 > 原文： [https://howtodoinjava.com/java/exception-handling/best-practices-for-for-exception-handling/](https://howtodoinjava.com/java/exception-handling/best-practices-for-for-exception-handling/)
 

docs/java/222.md

-# Java Generics PECS –生产者扩展了超级消费者
+# Java Generics PECS – 生产者扩展了超级消费者
 
 > 原文： [https://howtodoinjava.com/java/generics/java-generics-what-is-pecs-producer-extends-consumer-super/](https://howtodoinjava.com/java/generics/java-generics-what-is-pecs-producer-extends-consumer-super/)
 

docs/java/224.md

@@ -50,8 +50,8 @@ Summary
 
 它是初始且非常基本的算法，分为两个阶段运行：
 
-1.  **标记活动对象** –找出所有仍然存在的对象。
-2.  **删除无法访问的对象** –摆脱所有其他东西–所谓的已死和未使用的对象。
+1.  **标记活动对象** – 找出所有仍然存在的对象。
+2.  **删除无法访问的对象** – 摆脱所有其他东西 – 所谓的已死和未使用的对象。
 
 首先，GC 将某些特定对象定义为**垃圾收集根**。 例如当前执行方法的局部变量和输入参数，活动线程，已加载类的静态字段和 JNI 引用。 现在，GC 遍历了内存中的整个对象图，从这些根开始，然后是从根到其他对象的引用。 GC 访问的每个对象都被标记为活动对象。
 
@@ -83,7 +83,7 @@ Summary
 
     ![Deletion with copying - Mark and Sweep](img/5481c5dae55b344897819a3390178bb1.png)
 
-    删除并复制–扫一扫
+    删除并复制 – 扫一扫
 
 Before reading further, I will sincerely advise you to read [java memory management](https://howtodoinjava.com/java/garbage-collection/revisiting-memory-management-and-garbage-collection-mechanisms-in-java/) first. It talks about young generation, old generation and permanent generation in pretty detail.
 
@@ -149,7 +149,7 @@ G1（垃圾优先）垃圾收集器已在 Java 7 中提供，旨在长期替代
 
 ![Memory regions marked - G1](img/7bc3cfdab6956394dddfd4c034897af4.png)
 
-标记为– G1 的内存区域
+标记为 – G1 的内存区域
 
 G1 跟踪每个区域包含的实时数据量。 此信息用于确定包含最多垃圾的区域。 因此它们是首先收集的。 这就是为什么将其命名为**垃圾优先**集合的原因。
 
@@ -204,7 +204,7 @@ G1 跟踪每个区域包含的实时数据量。 此信息用于确定包含最
 
 ## 总结
 
-因此，在此 **Java 垃圾回收教程**中，我们学习了以下内容–
+因此，在此 **Java 垃圾回收教程**中，我们学习了以下内容 – 
 
 1.  对象生命周期分为三个阶段，即对象创建，对象使用和对象销毁。
 2.  `mark-sweep`，`mark-sweep-compact`和`mark-copy`机制如何运作。

docs/java/226.md

-# Java 内存管理–垃圾回收算法
+# Java 内存管理 – 垃圾回收算法
 
 > 原文： [https://howtodoinjava.com/java/garbage-collection/revisiting-memory-management-and-garbage-collection-mechanisms-in-java/](https://howtodoinjava.com/java/garbage-collection/revisiting-memory-management-and-garbage-collection-mechanisms-in-java/)
 
@@ -21,7 +21,7 @@ Table of Contents
 
 [Java 中的内存管理](http://www.oracle.com/technetwork/java/javase/memorymanagement-whitepaper-150215.pdf "java memory management")是垃圾收集器的职责。 这与 Java 之前的实践相反，在 Java 之前，程序员负责分配程序中的内存。
 
-正式而言，**垃圾收集器负责** –
+正式而言，**垃圾收集器负责** – 
 
 *   分配内存
 *   确保所有引用的对象都保留在内存中，并且

docs/java/228.md

-# Java 序列化–做正确的序列化
+# Java 序列化 – 做正确的序列化
 
 > 原文： [https://howtodoinjava.com/java/serialization/a-mini-guide-for-implementing-serializable-interface-in-java/](https://howtodoinjava.com/java/serialization/a-mini-guide-for-implementing-serializable-interface-in-java/)
 
@@ -22,10 +22,10 @@ Table of contents
 
 对类的不兼容更改是指不能保持互操作性的那些更改。 下面给出了在演化类时可能发生的不兼容更改（考虑默认序列化或[反序列化](https://howtodoinjava.com/java/serialization/how-deserialization-process-happen-in-java/)）：
 
-1.  **删除字段** –如果在类中删除了字段，则写入的流将不包含其值。 当较早的类读取流时，该字段的值将设置为默认值，因为流中没有可用的值。 但是，此默认值可能会不利地损害早期版本履行其契约的能力。
-2.  **将类上移或下移** –不允许这样做，因为流中的数据显示顺序错误。
-3.  **将非静态字段更改为静态或将非瞬态字段更改为瞬态** –当依赖默认序列化时，此更改等效于从类中删除字段。 该版本的类不会将该数据写入流，因此该类的早期版本将无法读取该数据。 与删除字段时一样，早期版本的字段将被初始化为默认值，这可能导致类以意外方式失败。
-4.  **更改原始字段的声明类型** –该类的每个版本都使用其声明类型写入数据。 尝试读取该字段的早期版本的类将失败，因为流中的数据类型与该字段的类型不匹配。
+1.  **删除字段** – 如果在类中删除了字段，则写入的流将不包含其值。 当较早的类读取流时，该字段的值将设置为默认值，因为流中没有可用的值。 但是，此默认值可能会不利地损害早期版本履行其契约的能力。
+2.  **将类上移或下移** – 不允许这样做，因为流中的数据显示顺序错误。
+3.  **将非静态字段更改为静态或将非瞬态字段更改为瞬态** – 当依赖默认序列化时，此更改等效于从类中删除字段。 该版本的类不会将该数据写入流，因此该类的早期版本将无法读取该数据。 与删除字段时一样，早期版本的字段将被初始化为默认值，这可能导致类以意外方式失败。
+4.  **更改原始字段的声明类型** – 该类的每个版本都使用其声明类型写入数据。 尝试读取该字段的早期版本的类将失败，因为流中的数据类型与该字段的类型不匹配。
 5.  **更改 writeObject 或 readObject 方法，使其不再写入或读取默认字段数据**，或对其进行更改，以使其尝试写入或读取以前的版本时不进行读取。 默认字段数据必须一致地出现在流中或不出现在流中。
 6.  **将类从可序列化更改为可外部化，反之亦然**是不兼容的更改，因为流将包含与可用类的实现不兼容的数据。
 7.  **将类从非枚举类型更改为枚举类型，反之亦然**，因为流将包含与可用类的实现不兼容的数据。
@@ -34,14 +34,14 @@ Table of contents
 
 ## 2\. Java 序列化兼容更改
 
-1.  **添加字段** –当重构的类具有流中未出现的字段时，对象中的该字段将被初始化为其类型的默认值。 如果需要特定于类的初始化，则该类可以提供一个 readObject 方法，该方法可以将字段初始化为非默认值。
-2.  **添加类** –流将包含流中每个对象的类型层次结构。 将流中的此层次结构与当前类进行比较可以检测到其他类。 由于流中没有用于初始化对象的信息，因此该类的字段将被初始化为默认值。
-3.  **删除类** –将流中的类层次结构与当前类的层次结构进行比较可以检测到某个类已被删除。 在这种情况下，从该流中读取与该类相对应的字段和对象。 [原始字段](https://howtodoinjava.com/java/basics/primitive-data-types-in-java/)被丢弃，但是创建了由已删除类引用的对象，因为可以在流中稍后引用它们。 当流被垃圾回收或重置时，它们将被垃圾回收。
-4.  **添加 writeObject / readObject 方法** –如果读取流的版本具有这些方法，则通常希望 readObject 读取通过默认序列化写入流中的所需数据。 在读取任何可选数据之前，应先调用 defaultReadObject。 通常，writeObject 方法将调用 defaultWriteObject 写入所需的数据，然后再写入可选数据。
-5.  **删除 writeObject / readObject 方法** –如果读取流的类没有这些方法，则默认情况下将序列化读取所需数据，而可选数据将被丢弃。
-6.  **添加 java.io.Serializable** –这等同于添加类型。 该类的流中将没有任何值，因此其字段将被初始化为默认值。 对子类化不可序列化类的支持要求该类的超级类型具有 no-arg 构造器，并且该类本身将被初始化为默认值。 如果 no-arg 构造器不可用，则抛出`InvalidClassException`。
-7.  **更改对字段的访问** –公共，打包，保护和私有的[访问修饰符](https://howtodoinjava.com/oops/java-access-modifiers/)对序列化为字段分配值的能力没有影响。
-8.  **将字段从静态更改为非静态，或将瞬态更改为非瞬态** –当依赖默认序列化来计算可序列化字段时，此更改等效于将字段添加到类中。 新字段将被写入流，但是较早的类将忽略该值，因为序列化不会为[静态](https://howtodoinjava.com/java/basics/java-static-keyword/)或[瞬态](https://howtodoinjava.com/java/basics/transient-keyword-in-java-with-real-time-example/)字段分配值。
+1.  **添加字段** – 当重构的类具有流中未出现的字段时，对象中的该字段将被初始化为其类型的默认值。 如果需要特定于类的初始化，则该类可以提供一个 readObject 方法，该方法可以将字段初始化为非默认值。
+2.  **添加类** – 流将包含流中每个对象的类型层次结构。 将流中的此层次结构与当前类进行比较可以检测到其他类。 由于流中没有用于初始化对象的信息，因此该类的字段将被初始化为默认值。
+3.  **删除类** – 将流中的类层次结构与当前类的层次结构进行比较可以检测到某个类已被删除。 在这种情况下，从该流中读取与该类相对应的字段和对象。 [原始字段](https://howtodoinjava.com/java/basics/primitive-data-types-in-java/)被丢弃，但是创建了由已删除类引用的对象，因为可以在流中稍后引用它们。 当流被垃圾回收或重置时，它们将被垃圾回收。
+4.  **添加 writeObject / readObject 方法** – 如果读取流的版本具有这些方法，则通常希望 readObject 读取通过默认序列化写入流中的所需数据。 在读取任何可选数据之前，应先调用 defaultReadObject。 通常，writeObject 方法将调用 defaultWriteObject 写入所需的数据，然后再写入可选数据。
+5.  **删除 writeObject / readObject 方法** – 如果读取流的类没有这些方法，则默认情况下将序列化读取所需数据，而可选数据将被丢弃。
+6.  **添加 java.io.Serializable** – 这等同于添加类型。 该类的流中将没有任何值，因此其字段将被初始化为默认值。 对子类化不可序列化类的支持要求该类的超级类型具有 no-arg 构造器，并且该类本身将被初始化为默认值。 如果 no-arg 构造器不可用，则抛出`InvalidClassException`。
+7.  **更改对字段的访问** – 公共，打包，保护和私有的[访问修饰符](https://howtodoinjava.com/oops/java-access-modifiers/)对序列化为字段分配值的能力没有影响。
+8.  **将字段从静态更改为非静态，或将瞬态更改为非瞬态** – 当依赖默认序列化来计算可序列化字段时，此更改等效于将字段添加到类中。 新字段将被写入流，但是较早的类将忽略该值，因为序列化不会为[静态](https://howtodoinjava.com/java/basics/java-static-keyword/)或[瞬态](https://howtodoinjava.com/java/basics/transient-keyword-in-java-with-real-time-example/)字段分配值。
 
 ## 3\. serialVersionUID
 
@@ -52,7 +52,7 @@ serialVersionUID 是`Serializable`类的通用版本标识符。 反序列化使
 
 ## 4\. readObject 和 writeObject 方法
 
-1.  反序列化必须视为任何构造器：**在反序列化**结束时验证对象状态–这意味着 readObject 几乎应始终在 Serializable 类中实现，以便执行此验证。
+1.  反序列化必须视为任何构造器：**在反序列化**结束时验证对象状态 – 这意味着 readObject 几乎应始终在 Serializable 类中实现，以便执行此验证。
 2.  如果构造器**为可变对象字段制作防御性副本**，则必须读取对象。
 
 ## 5\. 更多序列化最佳实践

docs/java/229.md

-# Java serialVersionUID –如何生成 serialVersionUID
+# Java serialVersionUID – 如何生成 serialVersionUID
 
 > 原文： [https://howtodoinjava.com/java/serialization/serialversionuid/](https://howtodoinjava.com/java/serialization/serialversionuid/)
 
-**Java 序列化**是将对象转换为字节流的过程，因此我们可以执行类似的操作，例如将其存储在磁盘上或通过网络发送。 反序列化是相反的过程–将字节流转换为内存中的对象。
+**Java 序列化**是将对象转换为字节流的过程，因此我们可以执行类似的操作，例如将其存储在磁盘上或通过网络发送。 反序列化是相反的过程 – 将字节流转换为内存中的对象。
 
 在序列化期间，java 运行时将版本号与每个可序列化的类相关联。 称为 **serialVersionUID** 的数字，在反序列化期间用于验证序列化对象的发送者和接收者是否已加载了该对象的与序列化兼容的类。 如果接收者为对象加载的类`serialVersionUID`与相应发送者的类不同，则反序列化将导致`InvalidClassException`。
 

docs/java/23.md

-# Java 静态–变量，方法，块，类和导入语句
+# Java 静态 – 变量，方法，块，类和导入语句
 
 > 原文： [https://howtodoinjava.com/java/basics/java-static-keyword/](https://howtodoinjava.com/java/basics/java-static-keyword/)
 

docs/java/230.md

-# Java 外部化示例–更有效的序列化
+# Java 外部化示例 – 更有效的序列化
 
 > 原文： [https://howtodoinjava.com/java/serialization/java-externalizable-example/](https://howtodoinjava.com/java/serialization/java-externalizable-example/)
 
@@ -94,7 +94,7 @@ public void writeExternal(ObjectOutput out) throws IOException {
 
 ## 可外部化的 readExternal（）示例
 
-唯一需要记住的是– [readExternal（）](https://docs.oracle.com/javase/7/docs/api/java/io/Externalizable.html#readExternal%28java.io.ObjectInput%29)方法必须读取与`writeExternal()`写入的序列相同且类型相同的值。
+唯一需要记住的是 – [readExternal（）](https://docs.oracle.com/javase/7/docs/api/java/io/Externalizable.html#readExternal%28java.io.ObjectInput%29)方法必须读取与`writeExternal()`写入的序列相同且类型相同的值。
 
 ```java
 public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {

docs/java/232.md

@@ -91,7 +91,7 @@ private static void serializeToXML (UserSettings settings) throws IOException
 
 ```
 
-请注意，如果要写入的对象的属性的默认值未更改，则 XmlEncoder 不会将其写出。 例如，在我们的示例中，**字段 Three** 的类型为`boolean`，其默认值为`false` –因此，它已从 XML 内容中省略。 这样可以灵活地更改类版本之间的*默认*值。
+请注意，如果要写入的对象的属性的默认值未更改，则 XmlEncoder 不会将其写出。 例如，在我们的示例中，**字段 Three** 的类型为`boolean`，其默认值为`false` – 因此，它已从 XML 内容中省略。 这样可以灵活地更改类版本之间的*默认*值。
 
 ## 使用 XMLDecoder 反序列化从 XML 到 Java 对象
 

docs/java/238.md

@@ -14,9 +14,9 @@ String 对象的哈希码计算为：
 > 
 > 哪里：
 > 
-> s [i] –字符串的第 i 个字符
-> n –字符串的长度，
-> ^ –表示幂
+> s [i] – 字符串的第 i 个字符
+> n – 字符串的长度，
+> ^ – 表示幂
 
 字符串 **hashCode（）**覆盖`Object.hashCode()`。 它以**整数**值的形式返回哈希码。
 

docs/java/241.md

@@ -12,11 +12,11 @@
 
 ## 1.1 方法返回类型
 
-此方法的结果为整数值，其中–
+此方法的结果为整数值，其中 – 
 
-1.  **正整数** –表示字符串对象在字典上跟随自变量字符串。
-2.  **负整数** –表示按字典顺序在自变量字符串之前的字符串对象。
-3.  **零** –表示两个字符串相等。
+1.  **正整数** – 表示字符串对象在字典上跟随自变量字符串。
+2.  **负整数** – 表示按字典顺序在自变量字符串之前的字符串对象。
+3.  **零** – 表示两个字符串相等。
 
 ## 1.2 方法实现
 

docs/java/242.md

-# Java 字符串 equals（）方法– Java 比较字符串
+# Java 字符串 equals（）方法 – Java 比较字符串
 
 > 原文： [https://howtodoinjava.com/java/string/string-equals-method/](https://howtodoinjava.com/java/string/string-equals-method/)
 

docs/java/243.md

-# Java 字符串 equalsIgnoreCase（）方法–不区分大小写的比较
+# Java 字符串 equalsIgnoreCase（）方法 – 不区分大小写的比较
 
 > 原文： [https://howtodoinjava.com/java/string/string-equalsignorecase-method/](https://howtodoinjava.com/java/string/string-equalsignorecase-method/)
 

docs/java/244.md

@@ -8,7 +8,7 @@
 
 ## 1\. charAt（）方法参数
 
-唯一的方法参数是`index`。 它必须是`int`类型。 <codex>索引</codex>参数必须为–
+唯一的方法参数是`index`。 它必须是`int`类型。 <codex>索引</codex>参数必须为 – 
 
 1.  等于大于“ 0”
 2.  少于字符串字符的长度，即`str.length()-1`

docs/java/249.md

@@ -8,8 +8,8 @@
 
 字符串 **replace（）**方法是 Java 中的重载方法。 它有两个变体。
 
-1.  `public String replace(char oldChar, char newChar)` –返回一个字符串，该字符串是用`newChar`替换此字符串中所有出现的`oldChar`的结果。
-2.  `public String replace(CharSequence target, CharSequence replacement)` –返回将此字符串中所有出现的`target`子字符串替换为`replacement`子字符串而产生的字符串。
+1.  `public String replace(char oldChar, char newChar)` – 返回一个字符串，该字符串是用`newChar`替换此字符串中所有出现的`oldChar`的结果。
+2.  `public String replace(CharSequence target, CharSequence replacement)` – 返回将此字符串中所有出现的`target`子字符串替换为`replacement`子字符串而产生的字符串。
 
 ## 2\. Java 字符串 replace（char oldChar，char newChar）示例
 

docs/java/252.md

@@ -9,8 +9,8 @@
 
 其中**方法参数**为：
 
-*   **beginIndex** –起始索引，包括端点。
-*   **endIndex** –结束索引，不包括。
+*   **beginIndex** – 起始索引，包括端点。
+*   **endIndex** – 结束索引，不包括。
 
 ## 1\. Java String substring（int beginIndex）示例
 

docs/java/253.md

@@ -6,8 +6,8 @@
 
 **startsWith（）**方法是重载方法，具有两种形式：
 
-1.  **boolean startsWith（String str）** –如果`str`是字符串的前缀，则返回`true`。
-2.  **boolean startsWith（String str，int fromIndex int）** –如果字符串从指定索引`fromIndex`开始以`str`开头，则返回`true`。
+1.  **boolean startsWith（String str）** – 如果`str`是字符串的前缀，则返回`true`。
+2.  **boolean startsWith（String str，int fromIndex int）** – 如果字符串从指定索引`fromIndex`开始以`str`开头，则返回`true`。
 
 ## 1\. 字符串 startsWith（String str）示例
 

docs/java/258.md

@@ -99,7 +99,7 @@ Start index: 20 End index: 25  - Brian
 
 与点类似，在字符类中使用管道时，管道也不是元字符。 在角色类中，它只是一个简单的角色。
 
-例如，要匹配单词“ First”或“ 1st”，我们可以编写正则表达式–“（First | 1st）”或简写为`"(Fir|1)st"`。
+例如，要匹配单词“ First”或“ 1st”，我们可以编写正则表达式 – “（First | 1st）”或简写为`"(Fir|1)st"`。
 
 ## 3\. Java Regex API
 
@@ -107,7 +107,7 @@ Java 具有内置的 API（`java.util.regex`）以使用正则表达式。 我
 
 Java Regex API 提供 1 个接口和 3 个类：
 
-*   **模式** –必须将指定为字符串的正则表达式首先编译为此类的实例。 然后，可以使用所得的模式来创建`Matcher`对象，该对象可以将任意字符序列与正则表达式进行匹配。
+*   **模式** – 必须将指定为字符串的正则表达式首先编译为此类的实例。 然后，可以使用所得的模式来创建`Matcher`对象，该对象可以将任意字符序列与正则表达式进行匹配。
 
     ```java
     Pattern p = Pattern.compile("abc");
@@ -116,9 +116,9 @@ Java Regex API 提供 1 个接口和 3 个类：
 
     ```
 
-*   **Matcher** –此类提供执行匹配操作的方法。
-*   **MatchResult（接口）** –这是匹配操作的结果。 它包含用于确定与正则表达式匹配的结果的查询方法。
-*   **PatternSyntaxException** –引发未经检查的异常，表示正则表达式模式中的语法错误。
+*   **Matcher** – 此类提供执行匹配操作的方法。
+*   **MatchResult（接口）** – 这是匹配操作的结果。 它包含用于确定与正则表达式匹配的结果的查询方法。
+*   **PatternSyntaxException** – 引发未经检查的异常，表示正则表达式模式中的语法错误。
 
 详细了解这些类和重要方法。
 
@@ -133,16 +133,16 @@ Java Regex API 提供 1 个接口和 3 个类：
 此类的实例为 [**不可变的**](https://howtodoinjava.com/java/basics/how-to-make-a-java-class-immutable/) ，可以安全地由多个并发线程使用。
 
 *   **谓词 asPredicate（）**-创建可用于匹配字符串的 [Java 8 谓词](https://howtodoinjava.com/java8/how-to-use-predicate-in-java-8/)。
-*   **静态模式编译（String regex）** –用于将给定的正则表达式编译为模式。
-*   **静态模式编译（String regex，int flags）** –用于将给定的正则表达式编译为带有给定标志的模式。
+*   **静态模式编译（String regex）** – 用于将给定的正则表达式编译为模式。
+*   **静态模式编译（String regex，int flags）** – 用于将给定的正则表达式编译为带有给定标志的模式。
 *   **int flags（）**-用于返回此模式的匹配标志。
-*   **Matcher matcher（字符序列输入）** –用于创建匹配器，该匹配器将根据该模式匹配给定的输入。
-*   **静态布尔匹配（字符串正则表达式，CharSequence 输入）** –用于编译给定的正则表达式，并尝试将给定的输入与其匹配。
-*   **字符串 pattern（）** –用于返回从中编译此模式的正则表达式。
-*   **静态字符串 quote（String s）** –用于返回指定字符串的字面模式串。
-*   **String [] split（字符序列输入）** –用于在此模式的匹配项附近拆分给定的输入序列。
-*   **String [] split（CharSequence input，int limit）** –用于在此模式的匹配项附近分割给定的输入序列。
-*   **流 splitAsStream（CharSequence 输入）** –根据该模式的匹配从给定的输入序列创建[流](https://howtodoinjava.com/java8/java-streams-by-examples/)。
+*   **Matcher matcher（字符序列输入）** – 用于创建匹配器，该匹配器将根据该模式匹配给定的输入。
+*   **静态布尔匹配（字符串正则表达式，CharSequence 输入）** – 用于编译给定的正则表达式，并尝试将给定的输入与其匹配。
+*   **字符串 pattern（）** – 用于返回从中编译此模式的正则表达式。
+*   **静态字符串 quote（String s）** – 用于返回指定字符串的字面模式串。
+*   **String [] split（字符序列输入）** – 用于在此模式的匹配项附近拆分给定的输入序列。
+*   **String [] split（CharSequence input，int limit）** – 用于在此模式的匹配项附近分割给定的输入序列。
+*   **流 splitAsStream（CharSequence 输入）** – 根据该模式的匹配从给定的输入序列创建[流](https://howtodoinjava.com/java8/java-streams-by-examples/)。
 
 #### 3.2 比赛班
 
@@ -152,17 +152,17 @@ Java Regex API 提供 1 个接口和 3 个类：
 
 此类的实例是**而不是[线程安全的](https://howtodoinjava.com/java/multi-threading/what-is-thread-safety/)** 。
 
-*   **boolean find（）** –主要用于搜索文本中多个出现的正则表达式。
-*   **布尔值 find（int start）** –用于从给定索引开始搜索文本中正则表达式的出现。
-*   **int start（）** –用于获取使用`find()`方法找到的匹配项的开始索引。
-*   **int end（）** –用于获取使用`find()`方法找到的匹配项的结束索引。 它返回最后一个匹配字符旁边的字符索引。
-*   **int groupCount（）** –用于查找匹配的子序列的总数。
-*   **字符串 group（）** –用于查找匹配的子序列。
-*   **布尔值 matchs（）** –用于测试正则表达式是否与模式匹配。
-*   **boolean lookingAt（）** –尝试从区域的开头开始，将模式与输入序列进行匹配。
-*   **字符串 quoteReplacement（String s）** –返回指定字符串的字面替换字符串。
-*   **Matcher reset（）** –重置此匹配器。
-*   **MatchResult toMatchResult（）** –以`MatchResult`的形式返回此匹配器的匹配状态。
+*   **boolean find（）** – 主要用于搜索文本中多个出现的正则表达式。
+*   **布尔值 find（int start）** – 用于从给定索引开始搜索文本中正则表达式的出现。
+*   **int start（）** – 用于获取使用`find()`方法找到的匹配项的开始索引。
+*   **int end（）** – 用于获取使用`find()`方法找到的匹配项的结束索引。 它返回最后一个匹配字符旁边的字符索引。
+*   **int groupCount（）** – 用于查找匹配的子序列的总数。
+*   **字符串 group（）** – 用于查找匹配的子序列。
+*   **布尔值 matchs（）** – 用于测试正则表达式是否与模式匹配。
+*   **boolean lookingAt（）** – 尝试从区域的开头开始，将模式与输入序列进行匹配。
+*   **字符串 quoteReplacement（String s）** – 返回指定字符串的字面替换字符串。
+*   **Matcher reset（）** – 重置此匹配器。
+*   **MatchResult toMatchResult（）** – 以`MatchResult`的形式返回此匹配器的匹配状态。
 
 ## 4\. Java Regex 示例
 

docs/java/259.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://howtodoinjava.com/regex/regex-alphanumeric-characters/](https://howtodoinjava.com/regex/regex-alphanumeric-characters/)
 
-我们可以使用给定的[正则表达式](https://howtodoinjava.com/java-regular-expression-tutorials/)来验证用户输入，使其仅允许**字母数字**字符。 字母数字字符都是字母和数字，即**字母 A–Z，a–z 和数字 0–9** 。
+我们可以使用给定的[正则表达式](https://howtodoinjava.com/java-regular-expression-tutorials/)来验证用户输入，使其仅允许**字母数字**字符。 字母数字字符都是字母和数字，即**字母 A – Z，a – z 和数字 0 – 9** 。
 
 ## 1\. 字母数字正则表达式模式
 

docs/java/260.md

-# Java Regex –信用卡号验证
+# Java Regex – 信用卡号验证
 
 > 原文： [https://howtodoinjava.com/regex/java-regex-validate-credit-card-numbers/](https://howtodoinjava.com/regex/java-regex-validate-credit-card-numbers/)
 

docs/java/261.md

-# Java Regex –加拿大邮政编码验证
+# Java Regex – 加拿大邮政编码验证
 
 > 原文： [https://howtodoinjava.com/regex/canada-postal-code-validation/](https://howtodoinjava.com/regex/canada-postal-code-validation/)
 
@@ -8,7 +8,7 @@
 
 加拿大邮政编码是一个六位字符的字符串，构成加拿大邮政地址的一部分。
 
-有效的加拿大邮政编码为–
+有效的加拿大邮政编码为 – 
 
 *   格式为 A1A 1A1，其中 A 是字母，1 是数字。
 *   用空格分隔第三个和第四个字符。

docs/java/263.md

@@ -10,7 +10,7 @@
 
 我们使用`'3[01]|[12][0-9]|0?[1-9]'`来匹配 3，后跟 0 或 1，或者匹配 1 或 2，后跟任意数字，或者匹配一个可选的 0，后跟 1 到 9。因此，您必须选择您希望您的正则表达式的简单或准确的程度。
 
-## 1\. Java 日期验证正则表达式–允许省略前导零
+## 1\. Java 日期验证正则表达式 – 允许省略前导零
 
 > 正则表达式：^ [0-3]？[0-9] / [0-3]？[0-9] /（？：[0-9] {2}）？[0-9] {2} $
 
@@ -49,7 +49,7 @@ for(String date : dates)
 
 ```
 
-## 2\. Java 日期验证正则表达式–要求前导零
+## 2\. Java 日期验证正则表达式 – 要求前导零
 
 > 正则表达式：^ [0-3] [0-9] / [0-3] [0-9] /（？：[0-9] [0-9]）？[0-9] [0-9] $
 
@@ -93,7 +93,7 @@ for(String date : dates)
 
 ```
 
-## 3\. Java 日期验证正则表达式–将“ mm / dd / yyyy”与所需的前导零匹配
+## 3\. Java 日期验证正则表达式 – 将“ mm / dd / yyyy”与所需的前导零匹配
 
 > 正则表达式：^（1 [0-2] | 0 [1-9]）/（3 [01] | [12] [0-9] | 0 [1-9]）/ [0-9] {4} $
 
@@ -132,7 +132,7 @@ for(String date : dates)
 
 ```
 
-## 4\. Java 日期验证正则表达式–将“ dd / mm / yyyy”与所需的前导零匹配
+## 4\. Java 日期验证正则表达式 – 将“ dd / mm / yyyy”与所需的前导零匹配
 
 用于验证日期格式`dd/mm/yyyy`的正则表达式。
 

docs/java/268.md

@@ -6,7 +6,7 @@
 
 所有编程语言都提供了一种有效的方法来检查文本的长度。 但是，在某些情况下，使用正则表达式检查文本长度会很有用，特别是当长度只是确定主题文本是否适合所需样式的多个规则之一时。
 
-例如，遵循正则表达式可确保文本长度在 1 到 10 个字符之间，并另外将文本限制为大写字母 A–Z。 您可以修改正则表达式以允许任何最小或最大文本长度，或允许使用除 A–Z 之外的其他字符。
+例如，遵循正则表达式可确保文本长度在 1 到 10 个字符之间，并另外将文本限制为大写字母 A – Z。 您可以修改正则表达式以允许任何最小或最大文本长度，或允许使用除 A – Z 之外的其他字符。
 
 > **正则表达式：^ [A-Z] {1,10} $**
 

docs/java/27.md

@@ -25,7 +25,7 @@ What's maximum amount of RAM that will be allocated to java on a 32-bit machine
 
 > `2 ^ 32 = 4,294,967,296`，即约 4.29 GB
 
-因此，理论上，在 32 位系统中，每个进程最多可以分配 4GB 的内存。 在 Windows 上打破这一点的是如何处理进程地址空间。 **Windows 将进程地址空间减少一半**。 其中一半保留给操作系统（用户进程无法使用），另一半保留给用户。 盒中有多少 RAM 无关紧要，一个 32 位进程只能使用 2GB RAM。 更糟糕的是– **地址空间必须是连续的**，因此实际上，**在 Windows 计算机**上通常只剩下 1.5-1.8GB 的堆空间。
+因此，理论上，在 32 位系统中，每个进程最多可以分配 4GB 的内存。 在 Windows 上打破这一点的是如何处理进程地址空间。 **Windows 将进程地址空间减少一半**。 其中一半保留给操作系统（用户进程无法使用），另一半保留给用户。 盒中有多少 RAM 无关紧要，一个 32 位进程只能使用 2GB RAM。 更糟糕的是 – **地址空间必须是连续的**，因此实际上，**在 Windows 计算机**上通常只剩下 1.5-1.8GB 的堆空间。
 
 精通技术的读者可能知道，现代芯片支持 [**PAE**](https://en.wikipedia.org/wiki/Physical_Address_Extension "Physical Address Extension") ，这是一种处理器技术，它允许操作系统使用更多的内存（最大为 64 GB），但它也需要特殊的应用程序支持，大多数应用程序没有或不一定需要它。
 
@@ -49,7 +49,7 @@ RAM 的每个进程限制也大大提高了 -- 在 64 位 Windows 上，**而不
 
 请注意，高可用内存并非免费提供。 它确实会花费运行时间，例如
 
-1）与 32 位相比，在 64 位上需要更多 30-50％的堆。 为什么？ 主要是由于 64 位架构中的内存布局。 首先–在 64 位 JVM 上，对象标头是 12 个字节。 其次，对象引用可以是 4 个字节，也可以是 8 个字节，具体取决于 JVM 标志和堆的大小。 与 32 位标头上的 8 个字节和引用标本上的 4 个字节相比，这无疑增加了一些开销。
+1）与 32 位相比，在 64 位上需要更多 30-50％的堆。 为什么？ 主要是由于 64 位架构中的内存布局。 首先 – 在 64 位 JVM 上，对象标头是 12 个字节。 其次，对象引用可以是 4 个字节，也可以是 8 个字节，具体取决于 JVM 标志和堆的大小。 与 32 位标头上的 8 个字节和引用标本上的 4 个字节相比，这无疑增加了一些开销。
 
 2）较长的垃圾收集暂停。 建立更多的堆意味着 GC 在清除未使用的对象时还有更多工作要做。 在现实生活中，这意味着在构建大于 12-16GB 的堆时，您必须格外小心。 如果不进行微调和测量，则很容易在几分钟内引入完整的 GC 暂停，这可能会导致显示停止。
 

docs/java/272.md

-# Java Regex –英国邮政编码验证
+# Java Regex – 英国邮政编码验证
 
 > 原文： [https://howtodoinjava.com/regex/uk-postcode-validation/](https://howtodoinjava.com/regex/uk-postcode-validation/)
 

docs/java/273.md

-# Java Regex –美国邮政编码验证
+# Java Regex – 美国邮政编码验证
 
 > 原文： [https://howtodoinjava.com/regex/us-postal-zip-code-validation/](https://howtodoinjava.com/regex/us-postal-zip-code-validation/)
 

docs/java/279.md

-# 如何创建路径– Java NIO
+# 如何创建路径 – Java NIO
 
 > 原文： [https://howtodoinjava.com/java7/nio/how-to-define-path-in-java-nio/](https://howtodoinjava.com/java7/nio/how-to-define-path-in-java-nio/)
 

docs/java/280.md

-# 使用缓冲区– Java NIO 2.0
+# 使用缓冲区 – Java NIO 2.0
 
 > 原文： [https://howtodoinjava.com/java7/nio/java-nio-2-0-working-with-buffers/](https://howtodoinjava.com/java7/nio/java-nio-2-0-working-with-buffers/)
 

docs/java/281.md

-# Java Channels 教程– NIO 2.0
+# Java Channels 教程 – NIO 2.0
 
 > 原文： [https://howtodoinjava.com/java7/nio/java-nio-2-0-channels/](https://howtodoinjava.com/java7/nio/java-nio-2-0-channels/)
 

docs/java/282.md

-# 3 种读取文件的方法– Java NIO
+# 3 种读取文件的方法 – Java NIO
 
 > 原文： [https://howtodoinjava.com/java7/nio/3-ways-to-read-files-using-java-nio/](https://howtodoinjava.com/java7/nio/3-ways-to-read-files-using-java-nio/)
 

docs/java/283.md

-# Java 8 –逐行读取文件
+# Java 8 – 逐行读取文件
 
 > 原文： [https://howtodoinjava.com/java8/read-file-line-by-line/](https://howtodoinjava.com/java8/read-file-line-by-line/)
 
 在本 [Java 8 教程](https://howtodoinjava.com/java-8-tutorial/)中，学习**使用[流 API](https://howtodoinjava.com/java8/java-streams-by-examples/) 逐行读取**文件。 另外，还要学习遍历行并根据某些条件过滤文件内容。
 
-## 1\. Java 8 读取文件–逐行
+## 1\. Java 8 读取文件 – 逐行
 
 在此示例中，我将读取文件内容为`stream`，并一次读取每一行，并检查其中是否包含单词`"password"`。
 
@@ -34,7 +34,7 @@ in mind.
 
 ```
 
-## 2\. Java 8 读取文件–过滤行流
+## 2\. Java 8 读取文件 – 过滤行流
 
 在此示例中，我们将文件内容读取为行流 as。 然后，我们将过滤掉所有带有单词`"password"`的行。
 
@@ -67,7 +67,7 @@ password
 
 我们将读取给定文件的内容，并检查是否有任何一行包含单词`"password"`，然后将其打印出来。
 
-## 3\. Java 7 –使用 FileReader 读取文件
+## 3\. Java 7 – 使用 FileReader 读取文件
 
 到 Java 7 为止，我们可以通过[`FileReader`](https://docs.oracle.com/javase/7/docs/api/java/io/FileReader.html)以各种方式读取文件。
 

docs/java/284.md

-# Java 内存映射文件– Java MappedByteBuffer
+# Java 内存映射文件 – Java MappedByteBuffer
 
 > 原文： [https://howtodoinjava.com/java7/nio/memory-mapped-files-mappedbytebuffer/](https://howtodoinjava.com/java7/nio/memory-mapped-files-mappedbytebuffer/)
 

docs/java/285.md

-# Java NIO –分散/聚集或矢量 IO
+# Java NIO – 分散/聚集或矢量 IO
 
 > 原文： [https://howtodoinjava.com/java7/nio/java-nio-2-0-scatter-gather-or-vectored-io/](https://howtodoinjava.com/java7/nio/java-nio-2-0-scatter-gather-or-vectored-io/)
 

docs/java/286.md

-# 通道之间的数据传输– Java NIO
+# 通道之间的数据传输 – Java NIO
 
 > 原文： [https://howtodoinjava.com/java7/nio/java-nio-2-0-how-to-transfer-copy-data-between-channels/](https://howtodoinjava.com/java7/nio/java-nio-2-0-how-to-transfer-copy-data-between-channels/)
 

docs/java/32.md

@@ -59,7 +59,7 @@ f1 and f2 are not equal
 
 查看控制台中打印的两个值。 将`f1`计算为`1.0999999999999999`。 其舍入问题恰恰是内部引起的。 因此，不建议将**浮点数与`'=='`运算符进行比较。**
 
-## 2\. 双精度比较 -– 基于阈值的比较[推荐]
+## 2\. 双精度比较 - – 基于阈值的比较[推荐]
 
 现在，当我们知道相等运算符的问题时，让我们解决它。 使用编程，我们无法更改存储或计算这些浮点数的方式。 因此，我们必须采用一种解决方案，在该解决方案中，我们同意确定两个可以容忍的值的差异，并且仍然认为数字相等。 该商定的值差被称为**阈值**或`ε`。
 

docs/java/37.md

@@ -30,10 +30,10 @@
 
 *   **变体**字段包含一个值，该值标识 UUID 的布局。
 *   **版本**字段包含一个描述此 UUID 类型的值。 UUID 有五种不同的基本类型。
-    1.  基于时间的 UUID（版本 1）– 根据时间和节点 ID 生成
-    2.  DCE（分布式计算环境）安全性（版本 2）– 由标识符（通常是组或用户 ID），时间和节点 ID 生成
-    3.  基于名称（版本 3）– 由 [MD5](https://howtodoinjava.com/java/io/how-to-generate-sha-or-md5-file-checksum-hash-in-java/) （128 位）的名称空间标识符和名称的哈希值生成
-    4.  随机生成的 UUID（版本 4）– 使用随机或伪随机数生成
+    1.  基于时间的 UUID（版本 1） – 根据时间和节点 ID 生成
+    2.  DCE（分布式计算环境）安全性（版本 2） – 由标识符（通常是组或用户 ID），时间和节点 ID 生成
+    3.  基于名称（版本 3） – 由 [MD5](https://howtodoinjava.com/java/io/how-to-generate-sha-or-md5-file-checksum-hash-in-java/) （128 位）的名称空间标识符和名称的哈希值生成
+    4.  随机生成的 UUID（版本 4） – 使用随机或伪随机数生成
     5.  基于名称的使用 SHA-1 散列（版本 5）**推荐的** – 由 [SHA-1](https://howtodoinjava.com/security/how-to-generate-secure-password-hash-md5-sha-pbkdf2-bcrypt-examples/) （160 位）散列处理的名称空间标识符和名称。 Java 不提供其实现。 我们将创造自己的。
 
 ## 3\. Java UUID 示例

docs/java/39.md

@@ -84,7 +84,7 @@ for (String name : names)
 
 有时，我们想确定两个文件是否具有相同的内容。 该 API 有助于比较文件的内容。
 
-`mismatch()`方法比较两个文件路径并返回`long`值。 `long`表示两个文件内容中第一个不匹配字节的位置。 如果文件“相等”，则返回值为`–1`。
+`mismatch()`方法比较两个文件路径并返回`long`值。 `long`表示两个文件内容中第一个不匹配字节的位置。 如果文件“相等”，则返回值为` – 1`。
 
 ```java
 Path helloworld1 = tempDir.resolve("helloworld1.txt");
@@ -139,7 +139,7 @@ System.out.println(isWeekend); 	//true or false - based on current day
 
 ```
 
-> 要使用此预览功能，请记住，我们必须在应用程序启动期间使用`–enable-preview`标志明确指示 JVM。
+> 要使用此预览功能，请记住，我们必须在应用程序启动期间使用` – enable-preview`标志明确指示 JVM。
 
 向我提供有关 Java 12 中这些新 **API 更改的问题。**
 

docs/java/4.md

-# 什么是 Java JDK，JRE 和 JVM –深入分析
+# 什么是 Java JDK，JRE 和 JVM – 深入分析
 
 > 原文： [https://howtodoinjava.com/java/basics/jdk-jre-jvm/](https://howtodoinjava.com/java/basics/jdk-jre-jvm/)
 
@@ -125,27 +125,27 @@ JRE 可以作为 JDK 的一部分下载，也可以单独下载。 JRE 与平台
 
 JDK 附带的几个重要组件如下：
 
-*   **appletviewer** –此工具可用于在没有 Web 浏览器的情况下运行和调试 Java applet
-*   **apt** –注释处理工具
-*   **extcheck** –一种检测 JAR 文件冲突的实用程序
-*   **javadoc** –文档生成器，可从源代码注释自动生成文档
-*   **jar** –归档程序，它将相关的类库打包到单个 JAR 文件中。 该工具还有助于管理 JAR 文件
+*   **appletviewer** – 此工具可用于在没有 Web 浏览器的情况下运行和调试 Java applet
+*   **apt** – 注释处理工具
+*   **extcheck** – 一种检测 JAR 文件冲突的实用程序
+*   **javadoc** – 文档生成器，可从源代码注释自动生成文档
+*   **jar** – 归档程序，它将相关的类库打包到单个 JAR 文件中。 该工具还有助于管理 JAR 文件
 *   **jarsigner** – jar 签名和验证工具
-*   **javap** –类文件反汇编程序
+*   **javap** – 类文件反汇编程序
 *   **javaws** -用于 JNLP 应用程序的 Java Web Start 启动器
 *   **JConsole** -Java 监视和管理控制台
 *   **jhat** – Java 堆分析工具
 *   **jrunscript** – Java 命令行脚本外壳
-*   **jstack** –打印 Java 线程的 Java 堆栈跟踪的实用程序
-*   **keytool** –用于操作密钥库的工具
-*   **policytool** –策略创建和管理工具
+*   **jstack** – 打印 Java 线程的 Java 堆栈跟踪的实用程序
+*   **keytool** – 用于操作密钥库的工具
+*   **policytool** – 策略创建和管理工具
 *   **xjc** – XML 绑定 Java API（JAXB）API 的一部分。 它接受 XML 模式并生成 Java 类
 
 与 JRE 一样，JDK 也依赖于平台。 因此，在为您的计算机下载 JDK 软件包时请多加注意。
 
 ## 5\. JDK，JRE 和 JVM 之间的区别
 
-基于以上讨论，我们可以得出以下三个方面的关系–
+基于以上讨论，我们可以得出以下三个方面的关系 – 
 
 > JRE = JVM + 运行 Java 应用程序的库。
 > 

docs/java/46.md

-# 字符串`lines()`–获取行流– Java 11
+# 字符串`lines()` – 获取行流 – Java 11
 
 > 原文： [https://howtodoinjava.com/java11/string-to-stream-of-lines/](https://howtodoinjava.com/java11/string-to-stream-of-lines/)
 

docs/java/52.md

@@ -38,7 +38,7 @@ String str = "Hello world";
 
 在上面的示例中，两个语句都是等效的。 在第一句话中，`str`的类型由分配类型`String`的类型确定。
 
-> 阅读更多： [Java var –局部变量类型推断](https://howtodoinjava.com/java10/var-local-variable-type-inference/)
+> 阅读更多： [Java var – 局部变量类型推断](https://howtodoinjava.com/java10/var-local-variable-type-inference/)
 
 ## JEP 322：基于时间的发行版本控制
 
@@ -52,7 +52,7 @@ $FEATURE.$INTERIM.$UPDATE.$PATCH
 
 也有长期发行（LTS）。 它主要针对企业客户。 LTS 版本的产品将提供 Oracle 的首要和持续的支持，目标是每三年一次。 此外，这些版本的更新将至少提供三年。
 
-> 阅读更多： [Java 版本–基于时间的发行版本控制](https://howtodoinjava.com/java10/java-version/)
+> 阅读更多： [Java 版本 – 基于时间的发行版本控制](https://howtodoinjava.com/java10/java-version/)
 
 ## JEP 304：垃圾收集器接口
 

docs/java/53.md

@@ -66,7 +66,7 @@ version.patch();
 
 它主要针对企业客户。 LTS 版本的产品将提供 Oracle 的首要和持续的支持，目标是每三年一次。 此外，这些版本的更新将至少提供三年。
 
-这将导致“ LTS”在 java –versions 的输出中突出显示。 例如`11.0.2+13-LTS`
+这将导致“ LTS”在 java – versions 的输出中突出显示。 例如`11.0.2+13-LTS`
 
 学习愉快！
 

docs/java/54.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://howtodoinjava.com/java10/var-local-variable-type-inference/](https://howtodoinjava.com/java10/var-local-variable-type-inference/)
 
-Java 一直在努力减少语法的冗长性。 首先是 [Diamond 运算符](https://howtodoinjava.com/java-7/improved-type-inference-in-java-7/)，现在是`var`（局部变量类型– [JEP 286](https://openjdk.java.net/jeps/286) ）在 Java 中声明变量。 当您使用`var`声明变量时，基本上，而不是声明变量类型，而是根据设置的类型假定其类型。 例如
+Java 一直在努力减少语法的冗长性。 首先是 [Diamond 运算符](https://howtodoinjava.com/java-7/improved-type-inference-in-java-7/)，现在是`var`（局部变量类型 – [JEP 286](https://openjdk.java.net/jeps/286) ）在 Java 中声明变量。 当您使用`var`声明变量时，基本上，而不是声明变量类型，而是根据设置的类型假定其类型。 例如
 
 ```java
 var str = "Hello world";
@@ -17,7 +17,7 @@ String str = "Hello world";
 
 ## `var`同时声明和初始化
 
-使用`var`时，必须在同一位置初始化变量。 您不能将声明和初始化放在不同的位置。 如果未在适当位置初始化变量，则会出现编译错误– `Cannot use 'var' on variable without initializer`。
+使用`var`时，必须在同一位置初始化变量。 您不能将声明和初始化放在不同的位置。 如果未在适当位置初始化变量，则会出现编译错误 – `Cannot use 'var' on variable without initializer`。
 
 ```java
 var i;	//Invalid Declaration - - Cannot use 'var' on variable without initializer
@@ -102,6 +102,6 @@ public class Application {
 
 ## `var`不会影响性能
 
-请记住，在 Java 中，类型不是在运行时推断的，而是在编译时推断的。 这意味着生成的字节码与显式类型声明相同–它确实包含有关类型的信息。 这意味着在运行时无需额外的处理。
+请记住，在 Java 中，类型不是在运行时推断的，而是在编译时推断的。 这意味着生成的字节码与显式类型声明相同 – 它确实包含有关类型的信息。 这意味着在运行时无需额外的处理。
 
 学习愉快！
\ No newline at end of file

docs/java/56.md

@@ -61,7 +61,7 @@ Java 8 允许您在接口中编写默认方法，这是广受赞赏的功能。
 3.  私有静态方法可以在其他静态和非静态接口方法中使用。
 4.  私有非静态方法不能在私有静态方法内部使用。
 
-在接口中使用私有方法的示例–
+在接口中使用私有方法的示例 – 
 
 ```java
 public interface CustomCalculator 
@@ -83,7 +83,7 @@ public interface CustomCalculator
 
 ```
 
-> [Java 9 –接口](//howtodoinjava.com/java9/java9-private-interface-methods/)中的私有方法
+> [Java 9 – 接口](//howtodoinjava.com/java9/java9-private-interface-methods/)中的私有方法
 
 ## HTTP/2 客户端
 
@@ -238,7 +238,7 @@ Java 9 引入了两种与流进行交互的新方法，即`takeWhile` / `dropWhi
 
 此增强与将应用程序类打包到 jar 文件中的方式有​​关。 以前，您必须将所有类打包到一个 jar 文件中，并放到另一个要使用它的应用程序的类路径中。
 
-现在，通过使用多发行版功能，一个 jar 可以包含一个类的不同版本–与不同的 JDK 版本兼容。 有关类的不同版本以及通过加载的类应选择哪个类的 JDK 版本的信息存储在`MANIFEST.MF`文件中。 在这种情况下，`MANIFEST.MF`文件在其主要部分中包含条目`Multi-Release: true`。
+现在，通过使用多发行版功能，一个 jar 可以包含一个类的不同版本 – 与不同的 JDK 版本兼容。 有关类的不同版本以及通过加载的类应选择哪个类的 JDK 版本的信息存储在`MANIFEST.MF`文件中。 在这种情况下，`MANIFEST.MF`文件在其主要部分中包含条目`Multi-Release: true`。
 
 此外，META-INF 包含一个 versions 子目录，该目录的整数子目录（从 9（对于 Java 9）开始）存储特定于版本的类和资源文件。 例如
 
@@ -280,8 +280,8 @@ JAR content root
 
 从 Java 9 开始， [@Deprecated](http://download.java.net/java/jdk9/docs/api/java/lang/Deprecated.html) 注解将具有两个属性，即`forRemoval`和`since`。
 
-1.  *forRemoval* –指示带注释的元素是否在将来的版本中会被删除。
-2.  从开始的 *–它返回已弃用带注释元素的版本。*
+1.  *forRemoval* – 指示带注释的元素是否在将来的版本中会被删除。
+2.  从开始的 * – 它返回已弃用带注释元素的版本。*
 
 强烈建议在文档中使用@deprecated javadoc 标记说明不赞成使用程序元素的原因。 该文档还应该建议并链接到建议的替代 API（如果适用）。 替换 API 的语义通常会有所不同，因此也应讨论此类问题。
 

docs/java/58.md

@@ -71,7 +71,7 @@ Java 9 Module System has a “**java.base**” Module. It’s known as **Base Mo
 
 ![Create Java Modular Project - Step 2](img/343527eeaeb514e37962d328424298b2.png)
 
-创建 Java 模块化项目–步骤 2
+创建 Java 模块化项目 – 步骤 2
 
 #### 创建 Java 模块
 

docs/java/6.md

@@ -83,11 +83,11 @@ $ export CLASSPATH=/dependency/*:/location
 
 ## 3\. 使用`-classpath`参数执行 Java 程序
 
-除了将`classpath`设置为环境变量之外，您还可以在使用`–classpath`参数启动应用程序时将其他`classpath`传递给 Java 运行时。
+除了将`classpath`设置为环境变量之外，您还可以在使用` – classpath`参数启动应用程序时将其他`classpath`传递给 Java 运行时。
 
 ```java
-$ javac –classpath C:\dependency\framework.jar MyApp.Java
-$ java –classpath C:\dependency\framework.jar MyApp
+$ javac – classpath C:\dependency\framework.jar MyApp.Java
+$ java – classpath C:\dependency\framework.jar MyApp
 
 ```
 

docs/java/62.md

@@ -14,7 +14,7 @@ Create Immutable Map
 
 ## 创建不可变列表
 
-使用`List.of()`静态工厂方法创建不可变列表。 它具有以下不同的重载版本–
+使用`List.of()`静态工厂方法创建不可变列表。 它具有以下不同的重载版本 – 
 
 ```java
 static <E> List<E>	of()

docs/java/63.md

-# 接口中的私有方法– Java 9
+# 接口中的私有方法 – Java 9
 
 > 原文： [https://howtodoinjava.com/java9/java9-private-interface-methods/](https://howtodoinjava.com/java9/java9-private-interface-methods/)
 
@@ -156,7 +156,7 @@ static method
 
 我正在创建具有两个功能的计算器类。 第一个函数将接受一些整数并将所有偶数相加。 第二个函数将接受一些整数并将所有奇数相加。
 
-#### CustomCalculator.java –接口
+#### CustomCalculator.java – 接口
 
 ```java
 import java.util.function.IntPredicate;
@@ -181,7 +181,7 @@ public interface CustomCalculator
 
 ```
 
-#### Main.java –类
+#### Main.java – 类
 
 ```java
 public class Main implements CustomCalculator {

docs/java/67.md

@@ -133,7 +133,7 @@ public class StreamBuilders
 
 Please note that it is not a true conversion. It’s just collecting the elements from the stream into a collection or array.
 
-#### 3.1 将流转换为列表– Stream.collect（Collectors.toList（））
+#### 3.1 将流转换为列表 – Stream.collect（Collectors.toList（））
 
 ```java
 public class StreamBuilders {
@@ -150,7 +150,7 @@ public class StreamBuilders {
 
 ```
 
-#### 3.2 将 Stream 转换为数组– Stream.toArray（EntryType [] :: new）
+#### 3.2 将 Stream 转换为数组 – Stream.toArray（EntryType [] :: new）
 
 ```java
 public class StreamBuilders {
@@ -429,27 +429,27 @@ public class StreamBuilders {
 
 #### 其他例子
 
-[Java 8 –流 map（）与 flatMap（）](https://howtodoinjava.com/java8/stream-map-vs-flatmap/)
-[Java 8 –无限流](https://howtodoinjava.com/java8/java-infinite-stream/)
-[Java 8 –流最大和最小](https://howtodoinjava.com/java8/stream-max-min-examples/)
-[Java 8 –随机数流](https://howtodoinjava.com/java8/stream-random-numbers-range/)
-[Java 8 –元素流数](https://howtodoinjava.com/java8/stream-count-elements-example/)
-[Java 8 –获取流](https://howtodoinjava.com/java8/java-stream-get-last-element/)
-的最后一个元素 [Java 8 –在流中查找或删除重复项](https://howtodoinjava.com/java8/stream-find-remove-duplicates/)
+[Java 8 – 流 map（）与 flatMap（）](https://howtodoinjava.com/java8/stream-map-vs-flatmap/)
+[Java 8 – 无限流](https://howtodoinjava.com/java8/java-infinite-stream/)
+[Java 8 – 流最大和最小](https://howtodoinjava.com/java8/stream-max-min-examples/)
+[Java 8 – 随机数流](https://howtodoinjava.com/java8/stream-random-numbers-range/)
+[Java 8 – 元素流数](https://howtodoinjava.com/java8/stream-count-elements-example/)
+[Java 8 – 获取流](https://howtodoinjava.com/java8/java-stream-get-last-element/)
+的最后一个元素 [Java 8 – 在流中查找或删除重复项](https://howtodoinjava.com/java8/stream-find-remove-duplicates/)
 [Java 8 – IntStream](https://howtodoinjava.com/java8/intstream-examples/)
 [Java 8 – IntStream 到集合](https://howtodoinjava.com/java8/convert-intstream-collection-array/)
 [Java 8 – IntPredicate](https://howtodoinjava.com/java8/java8-intpredicate/)
-[Java 8 –流不同](https://howtodoinjava.com/java8/java-stream-distinct-examples/)
-[Java 8 –受多个字段不同的流](https://howtodoinjava.com/java8/stream-distinct-by-multiple-fields/)
-[Java 8 –行流](https://howtodoinjava.com/java8/read-file-line-by-line-in-java-8-streams-of-lines-example/)
-[Java 8 –流 if-else 逻辑](https://howtodoinjava.com/java8/stream-if-else-logic/)
-[Java 8 –流重用–遍历流多次？](https://howtodoinjava.com/java8/java-stream-reuse/)
-[Java 8 –将流转换为映射](https://howtodoinjava.com/java8/collect-stream-to-map/)
-[Java 8 –将流转换为数组](https://howtodoinjava.com/java8/convert-stream-to-array/)
-[Java 8 –将流转换为列表](https://howtodoinjava.com/java8/convert-stream-to-list/)
-[Java 8 –将 Iterable 或 Iterator 转换为流](https://howtodoinjava.com/java8/iterable-iterator-to-stream/)
-[Java 8 –对数字和字符串排序](https://howtodoinjava.com/java8/stream-sorting/)
-[Java 8 –对多个字段上的对象排序](https://howtodoinjava.com/java8/sort-stream-multiple-fields/)
-[Java 8 –连接字符串流](https://howtodoinjava.com/java8/join-stream-of-strings/)
-[Java 8 –合并流](https://howtodoinjava.com/java8/stream-concat-example/)
+[Java 8 – 流不同](https://howtodoinjava.com/java8/java-stream-distinct-examples/)
+[Java 8 – 受多个字段不同的流](https://howtodoinjava.com/java8/stream-distinct-by-multiple-fields/)
+[Java 8 – 行流](https://howtodoinjava.com/java8/read-file-line-by-line-in-java-8-streams-of-lines-example/)
+[Java 8 – 流 if-else 逻辑](https://howtodoinjava.com/java8/stream-if-else-logic/)
+[Java 8 – 流重用 – 遍历流多次？](https://howtodoinjava.com/java8/java-stream-reuse/)
+[Java 8 – 将流转换为映射](https://howtodoinjava.com/java8/collect-stream-to-map/)
+[Java 8 – 将流转换为数组](https://howtodoinjava.com/java8/convert-stream-to-array/)
+[Java 8 – 将流转换为列表](https://howtodoinjava.com/java8/convert-stream-to-list/)
+[Java 8 – 将 Iterable 或 Iterator 转换为流](https://howtodoinjava.com/java8/iterable-iterator-to-stream/)
+[Java 8 – 对数字和字符串排序](https://howtodoinjava.com/java8/stream-sorting/)
+[Java 8 – 对多个字段上的对象排序](https://howtodoinjava.com/java8/sort-stream-multiple-fields/)
+[Java 8 – 连接字符串流](https://howtodoinjava.com/java8/join-stream-of-strings/)
+[Java 8 – 合并流](https://howtodoinjava.com/java8/stream-concat-example/)
 [Java 9 – Stream API 改进](https://howtodoinjava.com/java9/stream-api-improvements/)
\ No newline at end of file