2021-06-06 23:45:11

new/design-pattern-best-prac-java/3.md

@@ -244,7 +244,7 @@ public class Number implements Expression
 }
 ```
 
-现在我们到了困难的部分。我们需要实施运营商。运算符是复合表达式，由两个表达式组成：
+现在我们到了困难的部分。我们需要实现运营商。运算符是复合表达式，由两个表达式组成：
 
 ```java
 public class Plus implements Expression 
@@ -610,7 +610,7 @@ public class CarCaretaker
 
 # 实现
 
-策略模式的结构实际上与状态模式相同。然而，实施和意图完全不同：
+策略模式的结构实际上与状态模式相同。然而，实现和意图完全不同：
 
 ![](img/9a79967e-6311-4c2a-a326-13cc1913487d.png)
 

new/design-pattern-best-prac-java/4.md

@@ -491,7 +491,7 @@ class PrintTextHexDecorator implements PrintText
 *   `Abstraction`：这是抽象组件
 *   `Implementation`：这是抽象实现
 *   `Refined`：精制成分
-*   `SpecificImplementation`：这是具体实施
+*   `SpecificImplementation`：这是具体实现
 
 # 示例
 

new/java-coding-prob/06.md

@@ -2196,7 +2196,7 @@ DirectoryStream.Filter<Path> hiddenFilter
 
 只有前两个文件（`file1.txt`和`file2.txt`相同。任何其他比较都应显示至少存在一个不匹配。
 
-一种解决方法是使用`MappedByteBuffer`。这个解决方案是超级快速和易于实施。我们只需打开两个`FileChannels`（每个文件一个），然后逐字节进行比较，直到找到第一个不匹配或 EOF。如果文件的字节长度不同，则我们假设文件不相同，并立即返回：
+一种解决方法是使用`MappedByteBuffer`。这个解决方案是超级快速和易于实现。我们只需打开两个`FileChannels`（每个文件一个），然后逐字节进行比较，直到找到第一个不匹配或 EOF。如果文件的字节长度不同，则我们假设文件不相同，并立即返回：
 
 ```java
 private static final int MAP_SIZE = 5242880; // 5 MB in bytes

new/java-coding-prob/08.md

@@ -422,7 +422,7 @@ double sumAllDoubles
 
 环绕执行模式对于消除特定于打开和关闭资源（I/O 操作）的*样板*代码非常有用。
 
-# 169 实施工厂模式
+# 169 实现工厂模式
 
 简而言之，工厂模式允许我们创建多种对象，而无需向调用者公开实例化过程。通过这种方式，我们可以隐藏创建对象的复杂和/或敏感过程，并向调用者公开直观且易于使用的对象工厂
 
@@ -536,7 +536,7 @@ Melon melon = (Melon) MelonFactory.newInstance("Gac", 2000, "red");
 
 完成！现在，我们有一个工厂的`Melon`通过函数式接口。
 
-# 170 实施策略模式
+# 170 实现策略模式
 
 经典的策略模式非常简单。它由一个表示一系列算法（策略）的接口和该接口的几个实现（每个实现都是一个策略）组成。
 
@@ -833,9 +833,9 @@ fireStation.registerFireStation((String address) -> {
 
 完成！不再有*样板*代码。
 
-# 173 实施借贷模式
+# 173 实现借贷模式
 
-在这个问题上，我们将讨论如何实施借贷模式。假设我们有一个包含三个数字的文件（比如说，`double`），每个数字都是一个公式的系数。例如，数字`x`、`y`、`z`是以下两个公式的系数：`x + y - z`和`x - y * sqrt(z)`。同样的，我们也可以写出其他的公式。
+在这个问题上，我们将讨论如何实现借贷模式。假设我们有一个包含三个数字的文件（比如说，`double`），每个数字都是一个公式的系数。例如，数字`x`、`y`、`z`是以下两个公式的系数：`x + y - z`和`x - y * sqrt(z)`。同样的，我们也可以写出其他的公式。
 
 在这一点上，我们有足够的经验来认识到这个场景听起来很适合行为参数化。这一次，我们没有定义自定义函数式接口，而是使用一个名为`Function<T, R>`的内置函数式接口。此函数式接口表示接受一个参数并生成结果的函数。其抽象方法的签名为`R apply(T t)`。
 

new/java-proj/3.md

@@ -596,7 +596,7 @@ public class ArrayListSortable implements Sortable {
 
 下一节课是`StringComparator`。这非常简单，我不在这里列出它；我将把它留给您来实现可以比较两个`Strings`的`java.util.Comparator`接口。这应该不难，特别是因为这个类已经是以前版本的`BubbleSortTest`类的一部分（提示这是一个匿名类，我们存储在名为`stringCompare`的变量中）。
 
-我们还必须实施`ArrayListSwapper`，这也不应该是一个很大的惊喜：
+我们还必须实现`ArrayListSwapper`，这也不应该是一个很大的惊喜：
 
 ```java
 package packt.java189fundamentals.ch03.main.bubble.simple;

new/java-proj/5.md

@@ -969,7 +969,7 @@ a.lock(); b.lock(); a.unlock(); c.lock()
 
 这个类是`ReadWriteLock`的一个实现。`ReadWriteLock`是一种可用于并行读访问和独占写访问的锁。这意味着多个线程可以读取受锁保护的资源，但是当一个线程写入资源时，没有其他线程可以访问它，甚至在此期间也不能读取它。`ReadWriteLock`只是`readLock()`和`writeLock()`方法返回的两个`Lock`对象。为了获得对`ReadWriteLock`的读访问权，代码必须调用`myLock.readLock().lock()`，并获得对写锁`myLock.writeLock().lock()`的访问权。获取其中一个锁并在实现中释放它与另一个锁是耦合的。例如，要获取写锁，任何线程都不应该具有活动的读锁。
 
-使用不同的锁有几个复杂的地方。例如，可以获取读锁，但只要具有读锁，就无法获取写锁。必须先释放读锁才能获得写锁。这只是一个简单的细节，但这是一个新手程序员有很多次麻烦。为什么要这样实施？为什么程序要获得一个写锁，当它仍然不确定是否要写入资源时，从锁定其他线程的概率更高的意义上讲，写锁的成本更高？代码想要读取它，并且基于内容，它可能稍后决定要编写它。
+使用不同的锁有几个复杂的地方。例如，可以获取读锁，但只要具有读锁，就无法获取写锁。必须先释放读锁才能获得写锁。这只是一个简单的细节，但这是一个新手程序员有很多次麻烦。为什么要这样实现？为什么程序要获得一个写锁，当它仍然不确定是否要写入资源时，从锁定其他线程的概率更高的意义上讲，写锁的成本更高？代码想要读取它，并且基于内容，它可能稍后决定要编写它。
 
 问题不在于执行。库的开发人员决定了这个规则，并不是因为他们喜欢这样，也不是因为他们知道并行算法和死锁的可能性。当两个线程有`readLock`并且每个线程都决定将锁升级到`writeLock`时，它们本质上会创建死锁。每个人都会在等待`writeLock`的时候拿着`readLock`，没有人会得到它。
 

new/java-proj/6.md

@@ -968,7 +968,7 @@ public class GameSessionSaver {
 }
 ```
 
-当我们保存会话并将表转换为映射时，我们使用一个`HashMap`。在这种情况下，实施是重要的。`HashMap`类实现了`Serializable`接口；因此，我们可以安全地将其放入会话中。仅此一点并不能保证`HashMap`中的所有内容都是`Serializable`。本例中的键和值是字符串，幸运的是，`String`类还实现了`Serializable`接口。这样，转换后的`HashMap`对象可以安全地存储在会话中。
+当我们保存会话并将表转换为映射时，我们使用一个`HashMap`。在这种情况下，实现是重要的。`HashMap`类实现了`Serializable`接口；因此，我们可以安全地将其放入会话中。仅此一点并不能保证`HashMap`中的所有内容都是`Serializable`。本例中的键和值是字符串，幸运的是，`String`类还实现了`Serializable`接口。这样，转换后的`HashMap`对象可以安全地存储在会话中。
 
 还要注意的是，尽管序列化可能很慢，但是在会话中存储`HashMap`是如此频繁，以至于它实现了自己的序列化机制。此实现经过优化，避免了序列化依赖于映射的内部结构。
 

new/java-proj/7.md

@@ -157,7 +157,7 @@ MVC 是一种广泛使用的设计模式，它直接由 Spring 支持。当您
 
 另一方面，这正是我们喜欢做的，关注业务代码，避免框架提供的所有样板文件。
 
-既然我们知道了什么是 **JSON**、**REST**，以及通用的模型-视图-控制器设计模式，那么让我们看看 Spring 是如何管理它们的，以及如何将这些技术付诸实施。
+既然我们知道了什么是 **JSON**、**REST**，以及通用的模型-视图-控制器设计模式，那么让我们看看 Spring 是如何管理它们的，以及如何将这些技术付诸实现。
 
 # Spring 框架
 

new/java-proj/8.md

@@ -868,7 +868,7 @@ return order.getItems().stream()
 
 我们已经简单地提到过，`stream()`方法是`Collection`接口的一部分。任何实现`Collection`接口的类都会有这个方法，即使是那些在 Java8 中引入流之前实现的类。这是因为`stream()`方法在接口中实现为`default`方法。这样，如果我们碰巧实现了一个实现这个接口的类，即使我们不需要流，我们也可以免费获得它。
 
-为了支持接口的向后兼容性，引入了 Java8 中的`default`方法。JDK 的一些接口将被修改以支持 Lambda 和函数式编程。一个例子是`stream()`方法。在 Java8 之前的特性集中，实现一些修改过的接口的类应该已经被修改过了。他们将被要求实施新方法。这样的变化是不向后兼容的，Java 作为一种语言和 JDK 非常关注向后兼容。为此，介绍了`default`方法。这使得开发人员可以扩展接口并保持其向后兼容，从而为新方法提供默认实现。与此相反，java8JDK 的全新函数式接口也有`default`方法，尽管 JDK 中没有以前的版本，它们没有什么可兼容的。在 Java9 中，接口也被扩展，现在它们不仅可以包含`default`和`static`方法，还可以包含`private`方法。这样，接口就相当于抽象类，尽管接口中除了常量`static`字段外没有其他字段。这个接口功能扩展是一个备受批评的特性，它只会带来允许多类继承的其他语言所面临的编程风格和结构问题。Java 一直在避免这种情况，直到 Java8 和 Java9 出现。
+为了支持接口的向后兼容性，引入了 Java8 中的`default`方法。JDK 的一些接口将被修改以支持 Lambda 和函数式编程。一个例子是`stream()`方法。在 Java8 之前的特性集中，实现一些修改过的接口的类应该已经被修改过了。他们将被要求实现新方法。这样的变化是不向后兼容的，Java 作为一种语言和 JDK 非常关注向后兼容。为此，介绍了`default`方法。这使得开发人员可以扩展接口并保持其向后兼容，从而为新方法提供默认实现。与此相反，java8JDK 的全新函数式接口也有`default`方法，尽管 JDK 中没有以前的版本，它们没有什么可兼容的。在 Java9 中，接口也被扩展，现在它们不仅可以包含`default`和`static`方法，还可以包含`private`方法。这样，接口就相当于抽象类，尽管接口中除了常量`static`字段外没有其他字段。这个接口功能扩展是一个备受批评的特性，它只会带来允许多类继承的其他语言所面临的编程风格和结构问题。Java 一直在避免这种情况，直到 Java8 和 Java9 出现。
 这有什么好处？注意接口中的`default`方法和`private`方法。明智地使用它们，如果有的话。
 
 这个流的元素是`OrderItem`对象。我们需要为每个`OrderItem`设置`ProductInformation`。

new/java-proj/9.md

@@ -909,7 +909,7 @@ Git 在这个方向上走得很远。它非常支持分支创建和合并，以
 
 为企业编程，甚至为中等规模的项目编程，都离不开外部库的使用。在 Java 世界中，我们使用的大多数库都是开源的，而且或多或少是免费的。当我们购买图书馆时，通常有一个由采购部门执行的标准流程。在这种情况下，有一个关于如何选择供应商和库的书面策略。在“自由”软件的情况下，他们通常不关心，尽管他们应该关心。在这种情况下，选择过程主要取决于 IT 部门，因此，在选择图书馆之前，即使图书馆是免费的，也要知道要考虑的要点。
 
-在上一段中，我把“免费”放在引号之间。这是因为没有软件是真正免费的。没有什么像他们说的那样是免费的午餐。您已经听过很多次了，但是对于您将要选择的开放源代码库或框架来说，这可能并不明显。任何购买或实施的主要选择因素是成本、价格。如果软件是免费的，这意味着你不需要为软件支付预付费。然而，集成和使用它是有成本的。支持要花钱。有人可能会说，这种支持是社区支持，也是免费的。问题是，你花在寻找一个能帮助你克服错误的变通方法上的时间仍然是金钱。这是你的时间，或者如果你是一个经理，这是你所在部门的专业人员的时间，你为他们的时间买单，或者，如果你没有解决问题的内部专业知识，外部承包商会给你一大笔账单。
+在上一段中，我把“免费”放在引号之间。这是因为没有软件是真正免费的。没有什么像他们说的那样是免费的午餐。您已经听过很多次了，但是对于您将要选择的开放源代码库或框架来说，这可能并不明显。任何购买或实现的主要选择因素是成本、价格。如果软件是免费的，这意味着你不需要为软件支付预付费。然而，集成和使用它是有成本的。支持要花钱。有人可能会说，这种支持是社区支持，也是免费的。问题是，你花在寻找一个能帮助你克服错误的变通方法上的时间仍然是金钱。这是你的时间，或者如果你是一个经理，这是你所在部门的专业人员的时间，你为他们的时间买单，或者，如果你没有解决问题的内部专业知识，外部承包商会给你一大笔账单。
 
 因为自由软件没有价格标签，所以我们必须考虑其他在选择过程中很重要的因素。归根结底，它们都会以某种方式影响成本。有时，标准改变成本的方式并不明显，也不容易计算。但是，对于每一个库，我们都可以根据技术决策设置禁止级别，并且我们可以根据每个标准比较库的优劣。
 

new/learn-java12-prog/16.md

@@ -25,7 +25,7 @@
 
 不幸的是，维护和协调一个松散的服务系统是要付出代价的。每个参与者都必须负责维护其 API，不仅在形式上（比如名称和类型），而且在精神上：相同服务的新版本产生的结果在规模上必须相同。在类型上保持相同的值，然后在规模上使其变大或变小，这对于服务的客户来说可能是不可接受的。因此，尽管声明了独立性，但服务作者必须更清楚他们的客户是谁，他们的需求是什么
 
-幸运的是，将应用拆分为可独立部署的单元带来了一些意想不到的好处，这些好处增加了将系统拆分为更小服务的动机。物理隔离允许在选择编程语言和实现平台时具有更大的灵活性。它还可以帮助您选择最适合该工作的技术，并聘请能够实施该技术的专家。这样，您就不必受为系统其他部分所做的技术选择的约束。这也有助于招聘人员在寻找必要人才时更加灵活，这是一个很大的优势，因为对工作的需求继续超过流入就业市场的专家。
+幸运的是，将应用拆分为可独立部署的单元带来了一些意想不到的好处，这些好处增加了将系统拆分为更小服务的动机。物理隔离允许在选择编程语言和实现平台时具有更大的灵活性。它还可以帮助您选择最适合该工作的技术，并聘请能够实现该技术的专家。这样，您就不必受为系统其他部分所做的技术选择的约束。这也有助于招聘人员在寻找必要人才时更加灵活，这是一个很大的优势，因为对工作的需求继续超过流入就业市场的专家。
 
 每一个独立的部分（服务）都能够以自己的速度发展，并且变得更加复杂，只要与系统其他部分的契约没有改变或者以一种协调良好的方式引入。微服务就是这样产生的，后来被 Netflix、Google、Twitter、eBay、Amazon 和 Uber 等数据处理巨头投入使用。现在让我们谈谈这项努力的结果和经验教训。
 

new/learn-java12-prog/18.md

@@ -178,7 +178,7 @@ list.stream().forEach(System.out::println);
 *   我们已将`List.of()`的结果放入`new ArrayList()`对象中。我们这样做是因为，正如我们在第 6 章、“数据结构、泛型和流行实用程序”中已经提到的，工厂方法`of()`创建的集合是不可修改的。不能在其中添加或删除任何元素，也不能更改元素的顺序，同时需要对创建的集合进行排序。我们使用了`of()`方法，只是因为它更方便并且提供了更短的表示法
 *   最后，使用`java.util.Objects`进行属性比较，使得实现比定制编码更简单、更可靠。
 
-在实施`compareTo()`方法时，重要的是确保不违反以下规则：
+在实现`compareTo()`方法时，重要的是确保不违反以下规则：
 
 *   只有当返回值为`0`时，`obj1.compareTo(obj2)`才返回与`obj2.compareTo(obj1)`相同的值。
 *   如果返回值不是`0`，则`obj1.compareTo(obj2)`与`obj2.compareTo(obj1)`符号相反。

new/master-java11/02.md

@@ -747,13 +747,13 @@ GTK+，正式称为 GIMP 工具箱，是一种用于创建图形用户界面的
 
  |
 
-那么，实施这一增强需要进行哪些更改？对于 JavaFX，更改了三个具体内容：
+那么，实现这一增强需要进行哪些更改？对于 JavaFX，更改了三个具体内容：
 
 *   GTK 2 和 GTK 3 都增加了自动测试
 *   添加了动态加载 gtk2 的功能
 *   为 GTK 3 添加了支持
 
-对于 AWT 和 Swing，实施了以下更改：
+对于 AWT 和 Swing，实现了以下更改：
 
 *   GTK 2 和 GTK 3 都增加了自动测试
 *   `AwtRobot`迁移到 gtk3

new/master-java11/03.md

@@ -174,7 +174,7 @@ Coin 项目是 Java7 中引入的一组小改动的特性集。这些变化如
 *   `switch`语句中的字符串
 *   二进制积分文字
 *   在数字文本中使用下划线
-*   实施多重捕获
+*   实现多重捕获
 *   允许更精确地重新触发异常
 *   通用实例创建改进
 *   带资源的`try`语句的添加

new/master-java11/04.md

@@ -148,7 +148,7 @@ JEP-200 的核心目标是使用 **Java 平台模块系统**（**JPMS**）对 JD
 
 正如您在前面的流程图中所看到的，它只适用于导出包的模块。
 
-*   第四个原则处理标准模块中使用的标准和非标准 API 包。以下流程图说明了本原则契约的实施情况：
+*   第四个原则处理标准模块中使用的标准和非标准 API 包。以下流程图说明了本原则契约的实现情况：
 
 ![](img/9921bd3b-db59-488a-b6df-329c42c9f544.jpg)
 
@@ -222,7 +222,7 @@ JDK 是代码文件、工具、库等的汇编。下图概述了 JDK 组件：
 
 # 安全
 
-这组安全工具使开发人员能够创建可在开发人员的计算机系统以及远程系统上实施的安全策略：
+这组安全工具使开发人员能够创建可在开发人员的计算机系统以及远程系统上实现的安全策略：
 
 *   `keytool`：管理安全证书和密钥库
 *   `jarsigner`：该工具生成并验证用于创建/打开 JAR 文件的 JAR 签名

new/master-java11/10.md

@@ -85,7 +85,7 @@ public class DirectCall {
 
 这段代码创建了我们的 API 类的一个实例，然后直接调用`hello()`方法。它应该可以工作，并且应该在屏幕上打印字符`hello`。下一行代码要求`callMe()`方法回调以 Lambda 表达式形式提供的`Runnable`。在这种情况下，调用将失败，因为调用方在库外部，但是从库内部调用的。
 
-现在让我们看看资格检查是如何实施的：
+现在让我们看看资格检查是如何实现的：
 
 ```java
 package packt.java9.deep.stackwalker.myrestrictivelibrary;

new/master-java11/11.md

@@ -33,7 +33,7 @@ IDE 软件包就足够了。来自 JetBrains 的 IntelliJ IDEA 用于与本章
 
 在本节中，我们将回顾 Java 的**超文本传输协议**（**HTTP**）客户端，从旧的 Java9 之前的客户端开始，然后深入到作为当前 Java 平台一部分的新 HTTP 客户端。最后，我们将看看当前 HTTP 客户端的局限性。需要这种方法来支持对变化的理解。
 
-# 前 Java9HTTP 客户端
+# Java9 之前的 HTTP 客户端
 
 JDK1.1 版引入了支持 HTTP 特定特性的`HttpURLConnection`API。这是一个健壮的类，包含以下字段：
 
@@ -123,7 +123,7 @@ JDK1.1 版引入了支持 HTTP 特定特性的`HttpURLConnection`API。这是一
 
 现在我们知道以前的 HTTP 客户端有什么问题了，让我们看看当前的 HTTP 客户端。
 
-# Java11HTTP 客户端
+# Java11 HTTP 客户端
 
 为现代 Java 平台创建新的 HTTP 客户端有几个相关的目标，java9、10 和 11 提供了这些目标。下表列出了主要目标。这些目标分为易用性、核心功能、附加功能和性能等大类：
 
@@ -581,7 +581,7 @@ public static SourceVersion[] values()
 
 此方法返回枚举常量的数组。
 
-# 未知元素异常
+# `UnknownEntityException`
 
 `UnknownEntityException`类扩展了`RuntimeException`，是未知异常的超类。类构造器如下所示：
 
@@ -731,7 +731,7 @@ Javadoc 目录树
 *   成员
 *   使用新的`@index`内联标签索引的术语/短语
 
-# 引入案例搜索
+# 大小写搜索
 
 Javadoc 搜索功能通过使用驼峰大小写搜索提供了一个很好的快捷方式。例如，我们可以搜索`openED`来找到`openExternalDatabase()`方法。
 
@@ -756,7 +756,7 @@ Javadoc 搜索功能通过使用驼峰大小写搜索提供了一个很好的快
 
 Java 平台最近的一个变化是为 Nashorn 的 ECMAScript AST 创建了一个 API。在本节中，我们将分别介绍 Nashorn、ECMAScript，然后介绍解析器 API。
 
-# 犀牛
+# Nashorn
 
 Oracle Nashorn 是 Oracle 用 Java 开发的 JVM 的 JavaScript 引擎。它是与 Java8 一起发布的，旨在为开发人员提供一个高效、轻量级的 JavaScript 运行时引擎。使用这个引擎，开发人员能够在 Java 应用中嵌入 JavaScript 代码。在 Java8 之前，开发人员可以访问 Netscape 创建的 JavaScript 引擎。该引擎于 1997 年推出，由 Mozilla 维护。
 
@@ -895,7 +895,7 @@ Nashorn 接口层次结构
 
 枚举层次结构
 
-# 多个发布 JAR 文件
+# 多版本 JAR 文件
 
 JAR 文件格式已经在 Java 平台中进行了扩展，现在允许在一个 JAR 文件中存在多个版本的类文件。类版本可以特定于 Java 发布版本。这种增强允许开发人员使用一个 JAR 文件来存放多个版本的软件
 
@@ -978,7 +978,7 @@ JVMCI 实际上在某种程度上存在于 Java8 中。JVMCIAPI 只能通过在
 
 Oracle 将 JVMCI 保持在 Java9 中的实验性，以允许进一步的测试，并为开发人员提供最高级别的保护。
 
-# `BeanInfo`注释
+# `BeanInfo`注解
 
 `@beaninfo`Javadoc 标签已经被更合适的注释所取代。此外，这些新注释现在在运行时被处理，这样就可以动态生成`BeanInfo`类。Java 的模块化导致了这种变化。自定义`BeanInfo`类的创建已经简化，客户端库已经模块化。
 
@@ -1044,7 +1044,7 @@ public class MyBean implements java.io.Serializable {
 *   `boolean required`
 *   `boolean visualUpdate`
 
-# 旋转容器
+# `SwingContainer`
 
 `SwingContainer`是注释类型。我们使用这个注释来指定与 Swing 相关的属性，这样我们就可以自动生成`BeanInfo`类。
 
@@ -1184,7 +1184,7 @@ public @interface SwingContainer {
 
 接下来，让我们回顾一下现代 Java 平台中发生了哪些变化。
 
-# 登录现代 Java 平台
+# 现代 Java 平台的日志
 
 在 Java9 之前，有多种日志模式可用，包括`java.util.logging`、`SLF4J`和`Log4J`。后两种是第三方框架，它们有单独的外观和实现组件。这些模式已经在当前的 Java 平台中得到了复制。
 
@@ -1257,7 +1257,7 @@ Java 编程语言不支持集合文本。将此功能添加到 Java 平台是在
 
 Oracle 对集合字面值的定义是[**一种语法表达式形式，其计算结果是聚合类型，例如数组、列表或映射**](http://openjdk.java.net/jeps/186)。
 
-当然，直到 Java9 发布。据报道，在 Java 编程语言中实现集合文字具有以下好处：
+当然，直到 Java9 发布。据报道，在 Java 编程语言中实现集合字面值具有以下好处：
 
 *   性能改进
 *   提高安全性
@@ -1355,7 +1355,7 @@ public class OldSchool {
 
 现在，让我们看看这个问题的解决方案，它是由现代 Java 平台提供的，我们将在下一节中介绍它的新特性。
 
-# 使用新集合文字
+# 使用新集合字面值
 
 为了纠正创建集合时当前所需代码的冗长性，我们需要用于创建集合实例的库 API。请看上一节前面的代码片段，然后考虑以下可能的重构：
 
@@ -1410,7 +1410,7 @@ MacOSX`com.apple.eawt`包是一个内部 API，从 Java9 开始，就不能再
 *   指示任务进度
 *   动作快捷方式
 
-# 增强的方法处理
+# 增强的方法句柄
 
 现代 Java 平台包括增强的方法句柄，作为改进以下列出的类的一种方法，以便通过改进的优化简化常见用法：
 
@@ -1451,7 +1451,7 @@ MacOSX`com.apple.eawt`包是一个内部 API，从 Java9 开始，就不能再
 *   `Class<?> findClass(String targetName)`
 *   `Class<?> accessClass(Class<?> targetClass)`
 
-# 论元处理
+# 参数处理
 
 最近进行了三次更新以改进`MethodHandle`参数处理。这些变化如下：
 
@@ -1487,7 +1487,7 @@ MacOSX`com.apple.eawt`包是一个内部 API，从 Java9 开始，就不能再
 *   参数折叠：
     *   `MethodHandle foldArguments(MethodHandle target, int pos, MethodHandle combiner)`
 
-# 强化废弃
+# 废弃的强化
 
 有两种表达反对意见的工具：
 
@@ -1508,7 +1508,7 @@ MacOSX`com.apple.eawt`包是一个内部 API，从 Java9 开始，就不能再
 *   `since()`：
 *   返回包含版本号或版本号的字符串，此时指定的 API 被标记为已弃用
 
-# `@Deprecated`注释的真正含义
+# `@Deprecated`注解的真正含义
 
 当一个 API 或 API 中的方法已标记有`@Deprecated`注释时，通常存在以下一个或多个条件：
 

new/master-java11/12.md

@@ -87,7 +87,7 @@ Reactive 流计划旨在解决控制线程之间如何交换数据流的问题
 
 在下一节中，我们将研究 Java 平台中的`Flow` API，因为它们对应于反应流规范。
 
-# 流 API
+# `Flow` API
 
 `Flow`类是`java.util.concurrent`包的一部分。它帮助开发人员将反应式编程融入到他们的应用中。这个类有一个方法`defaultBufferSize()`和四个接口。
 
@@ -106,7 +106,7 @@ public static interface Flow.Publisher<T>
 
 此函数式接口可以用作 Lambda 表达式赋值目标。它只接受一个参数，所订阅项目的类型`<T>`。它有一种方法，即`void subscribe(Flow.Subscriber subscriber)`。
 
-# 这个流量订户接口
+# `Flow.Subscriber`接口
 
 `Flow.Subscriber`接口用于接收消息，其实现如下：
 
@@ -121,7 +121,7 @@ public static interface Flow.Subscriber<T>
 *   `void onNext(T item)`
 *   `void onSubscribe(Flow.Subscription subscription)`
 
-# 这个流量订阅接口
+# `Flow.Subscription`接口
 
 `Flow.Subscription`接口确保只有订户接收请求。此外，您将在此处看到，订阅可以随时取消：
 
@@ -134,7 +134,7 @@ public static interface Flow.Subscription
 *   `void cancel()`
 *   `void request(long n)`
 
-# 这个流量处理机接口
+# `Flow.Processor`接口
 
 `Flow.Processor`接口可以同时作为`Subscriber`和`Publisher`。此处提供了实现：
 
@@ -191,7 +191,7 @@ public class packtSubscriber<T> implements Subscriber<T> {
 }
 ```
 
-如您所见，实施`Subscriber`并不困难。繁重的工作由位于`Subscriber`和`Publisher`之间的处理器完成。让我们看一个示例实现，`Publisher`向订阅者发布数据流：
+如您所见，实现`Subscriber`并不困难。繁重的工作由位于`Subscriber`和`Publisher`之间的处理器完成。让我们看一个示例实现，`Publisher`向订阅者发布数据流：
 
 ```java
 import java.util.concurrent.SubsmissionPublisher;
@@ -213,7 +213,7 @@ packtPublisher.close();
 System.out.println("||---- End of Data Stream Reached ----||");
 ```
 
-# 其他并发更新
+# 额外的并发更新
 
 Java 平台最近得到了增强，以改进并发性的使用。在本节中，我们将简要探讨 Java 并发的概念，并查看 Java 平台的相关增强功能，包括：
 
@@ -396,13 +396,13 @@ varT.start();
 
 这两种方法都同样有效，您使用哪种方法被认为是开发人员的选择。当然，如果您希望获得更多的灵活性，那么第二种方法可能是更好的方法。你可以尝试这两种方法来帮助你做出决定。
 
-# 可完成的未来 API 增强
+# `CompletableFuture` API 增强
 
 `CompletableFuture<T>`类是`java.util.concurrent`包的一部分。该类扩展了`Object`类，实现了`Future<T>`和`CompletionStage<T>`接口。此类用于注释可以完成的线程。我们可以使用`CompletableFuture`类来表示未来的结果。当使用`complete`方法时，可以完成将来的结果。
 
 重要的是要认识到，如果多个线程试图同时完成（完成或取消），除一个线程外，其他所有线程都将失败。让我们看看这个类，然后看看增强功能。
 
-# 课程详情
+# 类详情
 
 `CompletableFuture<T>`类有一个嵌套类，用于标记异步任务：
 
@@ -505,7 +505,7 @@ public static interface CompletableFuture.AsynchronousCompletionTask
 *   `public T join()`
 *   `public String toString()`
 
-# 增强功能
+# 增强
 
 作为当前 Java 平台的一部分，`CompletableFuture<T>`类收到了以下增强：
 

new/master-java11/13.md

@@ -236,7 +236,7 @@ DTLS 是一种协议，用于在将数据传递到传输层协议之前保护来
 
 Java 平台为密钥库提供了更高的安全性。在默认情况下创建 PKCS12 密钥库之前，我们将首先回顾密钥库的概念，查看`KeyStore`类，然后查看 Java 平台的最新更新。
 
-# 密钥库底漆
+# 密钥库入门
 
 `KeyStore`的概念相对简单。它本质上是一个存储公钥证书和私钥的数据库文件或数据存储库文件。`KeyStore`将存储在`/jre/lib/security/cacerts`文件夹中。正如您将在下一节中看到的，这个数据库是由 Java 的`java.security.KeyStore`类方法管理的。
 
@@ -259,7 +259,7 @@ public class KeyStore extends Object
 
 由`KeyStore`管理的条目有三种类型，每种类型都实现`KeyStore.Entry`接口，`KeyStore`类提供的三个接口之一。下表定义了条目实现：
 
-| **实施** | **说明** |
+| **实现** | **说明** |
 | `KeyStore.PrivateKeyEntry` | 包含`PrivateKey`，它可以以受保护的格式存储。包含公钥的证书链。 |
 | `KeyStore.SecretKeyEntry` | 包含`SecretKey`，它可以以受保护的格式存储。 |
 | `KeyStore.TrustedCertifcateEntry` | 包含来自外部源的单个公钥`Certificate`。 |
@@ -312,7 +312,7 @@ public static class KeyStore.CallbackHandlerProtection extends Object implements
 public CallbackHandler getCallbackHandler()
 ```
 
-# 密码保护类
+# `PasswordProtection`类
 
 `KeyStore.PasswordProtection`类定义如下：
 
@@ -417,12 +417,12 @@ try {
 
 这项工作导致了以下优化，每个优化将在后面的部分中详细介绍：
 
-*   安全策略实施
+*   安全策略实现
 *   权限评估
 *   散列码
 *   包检查算法
 
-# 安全策略实施
+# 安全策略实现
 
 JDK 使用`ConcurrentHashMap`将`ProtectionDomain`映射到`PermissionCollection`。`ConcurrentHashMap`通常用于应用中的高并发性。它具有以下特点：
 
@@ -624,7 +624,7 @@ struct {
 
 OCSP 装订以前被称为 TLS 证书状态请求扩展。
 
-# OCSP 装订底漆
+# OCSP 装订入门
 
 OCSP 装订过程涉及多个组件和有效性检查。下图说明了 OCSP 装订过程：
 
@@ -688,7 +688,7 @@ X.509 证书是使用 X509 **公钥基础设施**（**PKI**）的数字证书。
 
 **确定性随机位发生器**（**DRBG**）是一种产生随机数的方法。它已经被美国商务部的分支机构 NIST 批准。DRBG 方法包括生成安全随机数的现代和更强的算法。
 
-最近，实施了三种特定的 DRBG 机制。这些机制如下：
+最近，实现了三种特定的 DRBG 机制。这些机制如下：
 
 *   `Hash_DRBG`
 *   `HMAC_DRBG`

new/master-java11/14.md

@@ -148,7 +148,7 @@ parameter=value
 *   使用`debug`水准仪
 *   向名为`rtdebug.txt`的文件提供输出
 
-# 装饰品
+# 装饰
 
 在 Java 日志框架的上下文中，装饰是关于日志消息的元数据。以下是按字母顺序排列的可用装饰品列表：
 
@@ -176,7 +176,7 @@ parameter=value
 9.  `level`
 10.  `tags`
 
-# 水平
+# 级别
 
 记录的消息单独与详细级别相关联。如前所述，级别为**错误**、**警告**、**信息**、**调试**、**跟踪**、**开发**。下表显示了这些级别相对于记录的信息量的详细程度是如何增加的。“开发级别”仅用于开发目的，在产品应用内部版本中不可用：
 
@@ -212,7 +212,7 @@ Java 日志框架支持三种类型的输出，包括直接使用`-Xlog`命令
 
 当多个标记组合在一起时，它们形成一个标记集。当我们通过源代码添加自己的标记时，每个标记都应该与一个标记集相关联。这将有助于确保标签保持有序，并且易于人类阅读。
 
-# 编译器控件
+# 编译器控制
 
 控制 **Java 虚拟机**（**JVM**）编译器似乎是一项不必要的任务，但对于许多开发人员来说，这是测试的一个重要方面。这是通过依赖于方法的编译器标志实现的。
 
@@ -342,7 +342,7 @@ Java 承诺能够有限地控制 JVM 编译器并在运行时进行更改。这
 
 `print_utf8pool`命令打印所有 UTF-8 字符串常量。
 
-# 堆分析代理
+# 堆性能分析代理
 
 JVMTI `hprof`代理最近从 Java 平台上删除了。以下是与此更改相关的关键术语：
 

new/master-java11/15.md

@@ -644,9 +644,9 @@ Java 平台尚未实现以下 Unicode 标准：
 
 让我们快速看一下这些类中的每一个，以帮助巩固我们对 Unicode 10.0.0 在 Java 平台上的广泛影响的理解。
 
-# `java.lang.package`
+# `java.lang`包
 
-`java.lang.package`提供了几乎所有 Java 应用中使用的基本类。在本节中，我们将介绍`Character`和`String`类。
+`java.lang`包提供了几乎所有 Java 应用中使用的基本类。在本节中，我们将介绍`Character`和`String`类。
 
 这是`Character`类：
 
@@ -699,7 +699,7 @@ public final class Normalizer extends Object
 *   `isNormalized`：用于确定给定序列的`char`值是否归一化
 *   `normalize`：规范化`char`值的序列
 
-# 额外意义
+# 额外重要事项
 
 如前所述，JDK8 支持 Unicode 6.2。6.3 版于 2013 年 9 月 30 日发布，主要内容如下：
 

new/master-java11/16.md

@@ -27,7 +27,7 @@ JEP 的核心是增强功能本身。增强的标准包括：
 *   必须表明 JDK 发生了重大变化。
 *   必须有广泛的信息吸引力。
 *   此外，它必须满足以下附加标准之一：
-    *   需要大量的工程工作来实施（至少两周）
+    *   需要大量的工程工作来实现（至少两周）
     *   涉及对 JDK 或其基础结构的重大更改
     *   是 Java 开发人员或用户的高需求项目
 
@@ -126,7 +126,7 @@ JVM 依赖于一个常量池来确定类布局、实例、接口和数组。每
 
 Java 增强建议展示了 Java 平台的设计和实现变化。如前所述，正在起草的 JEP 的标准是，工作必须至少满足以下一项：
 
-*   需要大量的工程工作来实施（至少两周）
+*   需要大量的工程工作来实现（至少两周）
 *   涉及对 JDK 或其基础结构的重大更改
 *   是 Java 开发人员或用户的高需求项目
 
@@ -212,7 +212,7 @@ HarfBuzz 集成项目希望将 HarfBuzz 布局引擎集成到 Java 开发工具
 
 # 科纳
 
-Kona 项目正在定义和实现 Java API，以支持**物联网**（**IoT**）领域。这包括网络技术和协议。尽管没有说明，但安全和安保对于这项工作的成功实施至关重要。
+Kona 项目正在定义和实现 Java API，以支持**物联网**（**IoT**）领域。这包括网络技术和协议。尽管没有说明，但安全和安保对于这项工作的成功实现至关重要。
 
 # 开放 JFX
 

new/master-java11/18.md

@@ -302,7 +302,7 @@
 1.  JDK 的拟议更改列表。
 2.  广泛的信息吸引力。
 3.  提案必须符合以下标准之一：
-    *   需要大量的工程工作来实施（至少两周）
+    *   需要大量的工程工作来实现（至少两周）
     *   涉及对 JDK 或其基础结构的重大更改
     *   是 Java 开发人员或用户的高需求项目
 4.  草案这是最早的状态，在 JEP 已经写好并由作者分发以取得共识时使用。