2020-05-20 22:42:21

docs/java/101.md

@@ -96,7 +96,7 @@ class InformationHiding
 
 ```
 
-#### 2.2 实施隐藏
+#### 2.2 实现隐藏
 
 ```java
 interface ImplemenatationHiding {

docs/java/105.md

@@ -36,7 +36,7 @@ Table of Contents
 
     数据抽象是创建复杂数据类型并仅公开有意义的操作以与数据类型进行交互的方式，而将所有实现细节都隐藏在外部工作中。
 
-    这种方法的好处在于可以随着时间的流逝改善实施的能力，例如解决性能问题无所不包。 想法是这样的更改不应该对客户端代码产生任何影响，因为它们在抽象行为上没有任何区别。
+    这种方法的好处在于可以随着时间的流逝改善实现的能力，例如解决性能问题无所不包。 想法是这样的更改不应该对客户端代码产生任何影响，因为它们在抽象行为上没有任何区别。
 
 2.  #### 控制抽象
 

docs/java/106.md

@@ -33,7 +33,7 @@ Encapsulation vs Abstraction
 简而言之，从 OOAD 的角度来看：
 
 *   *抽象更多地涉及“ **类可以做什么**”。 [**想法**]*
-*   *封装更多地涉及“ **如何**”来实现该功能。 [**实施**]*
+*   *封装更多地涉及“ **如何**”来实现该功能。 [**实现**]*
 
 我在很多博客上都看到了与此理论相矛盾的地方。 因此，如果您也不同意这一点，请多多包涵。 另外，我将要求您对与主题相关的想法发表评论。 我会很乐意尝试联系或否定。
 

docs/java/123.md

@@ -47,7 +47,7 @@ public class DemoThread extends Thread {
 1.  实现`Runnable`是首选的方法。 在这里，您并没有真正专门化或修改线程的行为。 您只是给线程一些要运行的东西。 这意味着合成是更好的选择。
 2.  Java 仅支持单一继承，因此您只能扩展一个类。
 3.  实例化一个接口可以使您的代码与线程实现更加清晰地分离。
-4.  实现`Runnable`使您的课堂更加灵活。 如果您扩展`Thread`，那么您执行的操作将始终处于线程状态。 但是，如果您实施了`Runnable`，则不必这样做。 您可以在线程中运行它，或将其传递给某种执行服务，或仅作为任务在单个线程应用程序中传递。
+4.  实现`Runnable`使您的课堂更加灵活。 如果您扩展`Thread`，那么您执行的操作将始终处于线程状态。 但是，如果您实现了`Runnable`，则不必这样做。 您可以在线程中运行它，或将其传递给某种执行服务，或仅作为任务在单个线程应用程序中传递。
 5.  If you are working on JDK 4 or lesser, then there is bug :
 
     [http://bugs.java.com/bugdatabase/view_bug.do;jsessionid=5869e03fee226ffffffffc40d4fa881a86e3:WuuT?bug_id=4533087](http://bugs.java.com/bugdatabase/view_bug.do;jsessionid=5869e03fee226ffffffffc40d4fa881a86e3:WuuT?bug_id=4533087 terget=)

docs/java/231.md

@@ -22,7 +22,7 @@
 ## 2\. 阅读有关可外部化和可序列化的更多信息
 
 *   [使用 Java 中的可外部化功能更高效的序列化](//howtodoinjava.com/java/serialization/java-externalizable-example/)
-*   [Java 可序列化接口实施指南](//howtodoinjava.com/java/serialization/a-mini-guide-for-implementing-serializable-interface-in-java/)
+*   [Java 可序列化接口实现指南](//howtodoinjava.com/java/serialization/a-mini-guide-for-implementing-serializable-interface-in-java/)
 *   [Java 中反序列化过程如何发生？](//howtodoinjava.com/java/serialization/how-deserialization-process-happen-in-java/)
 
 请在与 **Java** 中的可外部化和可序列化的接口有关的评论部分中提出您的问题。

docs/java/241.md

@@ -18,7 +18,7 @@
 2.  **负整数** –表示按字典顺序在自变量字符串之前的字符串对象。
 3.  **零** –表示两个字符串相等。
 
-## 1.2 方法实施
+## 1.2 方法实现
 
 此方法使用`CaseInsensitiveComparator`类，它是**字符串**类的静态内部类。 字符串比较是通过`compare()`方法完成的。
 

docs/java/3.md

@@ -14,7 +14,7 @@ JDK vs JRE vs JVM
 
 Java 最初由 **James Gosling** 在 *Sun Microsystems* （已由 Oracle Corporation 收购）开发，并于 1995 年作为 Sun Microsystems Java 平台的核心组件发布。 该语言的大部分语法均来自 C 和 C++，但与任何一种相比，它的低级功能都更少。
 
-*Oracle 公司*是 Java SE 平台的正式实现的当前所有者，此后于 2010 年 1 月 27 日收购了 Sun Microsystems。该实现基于 Sun 最初的 Java 实现。 Oracle 实施可用于 Microsoft Windows，Mac OS X，Linux 和 Solaris。
+*Oracle 公司*是 Java SE 平台的正式实现的当前所有者，此后于 2010 年 1 月 27 日收购了 Sun Microsystems。该实现基于 Sun 最初的 Java 实现。 Oracle 实现可用于 Microsoft Windows，Mac OS X，Linux 和 Solaris。
 
 Oracle 实现打包为两个不同的发行版：
 

docs/java/34.md

@@ -50,7 +50,7 @@ Commons lang 库有一个有用的类，可以用于偶对，即[`org.apache.com
 *   `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
@@ -83,18 +83,18 @@ pair.equals(ImmutablePair.of(100, "example.com"));		//false	- different value
 
 ## 4\. `io.vavr.Tuple2` - Vavr
 
-用于存储键值对的另一个有用的类是 [Tuple2](https://static.javadoc.io/io.vavr/vavr/0.9.0/io/vavr/Tuple2.html) 。
+用于存储键值对的另一个有用的类是[`Tuple2`](https://static.javadoc.io/io.vavr/vavr/0.9.0/io/vavr/Tuple2.html)。
 
-`Tuple2`提供了许多有用的方法来处理其中存储的数据。 例如
+`Tuple2`提供了许多有用的方法来处理其中存储的数据。 例如：
 
-*   `T1 _1()` –此元组的第一个元素的获取器。
-*   `T2 _2()` –此元组的第二个元素的获取器。
-*   `Tuple2 update1(T1 value)` –将此元组的第一个元素设置为给定值。
-*   `Tuple2 update2(T2 value)` –将此元组的第二个元素设置为给定值。
-*   `Map.Entry toEntry()` –将元组转换为`java.util.Map.Entry`元组。
-*   `Tuple2 swap()` –交换此元组的元素。
-*   `Tuple2 map(BiFunction mapper)` –使用映射器功能映射该元组的组件。
-*   `int compareTo(Tuple2 that)` –比较两个 Tuple2 实例。
+*   `T1 _1()` – 此元组的第一个元素的获取器。
+*   `T2 _2()` – 此元组的第二个元素的获取器。
+*   `Tuple2 update1(T1 value)` – 将此元组的第一个元素设置为给定值。
+*   `Tuple2 update2(T2 value)` – 将此元组的第二个元素设置为给定值。
+*   `Map.Entry toEntry()` – 将元组转换为`java.util.Map.Entry`元组。
+*   `Tuple2 swap()` – 交换此元组的元素。
+*   `Tuple2 map(BiFunction mapper)` – 使用映射器功能映射该元组的组件。
+*   `int compareTo(Tuple2 that)` – 比较两个`Tuple2`实例。
 
 ```java
 Tuple2<Integer, String> pair = new Tuple2<>(100, "howtodoinjava.com");
@@ -110,7 +110,7 @@ pair.equals(new Tuple2<>(100, "example.com"));		//false	- different value
 
 ```
 
-Do not forget to import the library into application classpath.
+不要忘记将库导入应用程序类路径。
 
 ```java
 <dependency>
@@ -121,6 +121,6 @@ Do not forget to import the library into application classpath.
 
 ```
 
-请问您有关**与 Java** 中的名称/值对一起使用的问题。
+请问您有关 Java 中的名称/值对的问题。
 
 学习愉快！
\ No newline at end of file

docs/java/35.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://howtodoinjava.com/java/basics/java-tuples/](https://howtodoinjava.com/java/basics/java-tuples/)
 
-在本 Java 教程中，我们将学习 **Java 元组** –通用数据结构，以及如何在 Java 程序中使用元组。 默认情况下，元组在 Java 编程语言中不作为数据结构出现，因此我们将使用一个不错的第三方库 **javatuples** 。
+在本 Java 教程中，我们将学习 **Java 元组** – 通用数据结构，以及如何在 Java 程序中使用元组。 默认情况下，元组在 Java 编程语言中不作为数据结构出现，因此我们将使用一个不错的第三方库`javatuples`。
 
 ```java
 Table of Contents
@@ -18,7 +18,7 @@ Table of Contents
 
 元组可以看作是*有序的不同类型的对象*的集合。 这些对象不一定以任何方式相互关联，但是它们总的来说将具有一定的意义。
 
-例如，`["Sajal Chakraborty", "IT Professional", 32]`可以是一个元组，其中该元组中的每个值都没有任何关系，但是整个值集在应用程序中可能具有某些意义。 例如，give 元组可以代表具有姓名，部门和年龄的员工数据。
+例如，`["Sajal Chakraborty", "IT Professional", 32]`可以是一个元组，其中该元组中的每个值都没有任何关系，但是整个值集在应用程序中可能具有某些意义。 例如，给定元组可以代表具有姓名，部门和年龄的员工数据。
 
 让我们来看更多 *java 元组示例*。
 
@@ -33,11 +33,11 @@ Table of Contents
 
 Java 没有任何这样的内置数据结构来支持元组。 无论何时需要，我们显然都可以创建一个类似于元组的类。
 
-同样，在 Java 中，可以使用`List`或`Array`来编写元组功能的一部分，但这些不允许我们通过设计保存不同类型的数据类型。 因此，可以说在 Java 中使用标准数据结构的异构元组是不可能的。
+同样，在 Java 中，可以使用列表或数组来编写元组功能的一部分，但这些不允许我们通过设计保存不同类型的数据类型。 因此，可以说在 Java 中使用标准数据结构的异构元组是不可能的。
 
 #### 2.1 元组与列表/数组的比较
 
-通常将 Tuple 与 List 进行比较，因为它看起来非常像一个列表。 但是它们在某些方面有所不同。
+通常将元组与列表进行比较，因为它看起来非常像一个列表。 但是它们在某些方面有所不同。
 
 1.  元组是可以包含异构数据的对象。 列表旨在存储单一类型的元素。
 2.  在所有数据结构中，元组被认为是最快的，并且它们消耗的内存量最少。
@@ -47,9 +47,9 @@ Java 没有任何这样的内置数据结构来支持元组。 无论何时需
 
 ## 3\. `javatuples`库
 
-#### 3.1 `javatuples` maven 依赖性
+#### 3.1 `javatuples` maven 依赖
 
-**javatuples** 库存在于 Maven 中央存储库中，我们可以添加此依赖项以使用该库。
+`javatuples`库存在于 Maven 中央存储库中，我们可以添加此依赖项以使用该库。
 
 ```java
 <dependency>
@@ -62,7 +62,7 @@ Java 没有任何这样的内置数据结构来支持元组。 无论何时需
 
 #### 3.2 `javatuples` - 类
 
-Java 元组支持最大为`'10'`的元组，并且对于每种大小，它都提供了如下的元组实现。
+Java 元组支持最大为`10`的元组，并且对于每种大小，它都提供了如下的元组实现。
 
 *   `Unit`（一个元素）
 *   `Pair`（两个元素）
@@ -77,20 +77,20 @@ Java 元组支持最大为`'10'`的元组，并且对于每种大小，它都提
 
 除了上述类之外，它还提供了另外两个类来方便表示对。 大部分与`Pair`相同，但语法更详细。
 
-1.  **键值**
-2.  **LabelValue**
+1.  `KeyValue`
+2.  `LabelValue`
 
 #### 3.3 `javatuples` – 特性
 
 *不同类型的 Java 元组*是：
 
 1.  输入安全
-2.  一成不变
+2.  不可变
 3.  可迭代的
 4.  可序列化
-5.  可比（实现可比）
-6.  实施`equals()`和`hashCode()`
-7.  实施`toString()`
+5.  可比（实现`Comparable`）
+6.  实现`equals()`和`hashCode()`
+7.  实现`toString()`
 
 ## 4\. `javatuples`的常见操作
 
@@ -165,11 +165,11 @@ Exp : 12
 
 ```
 
-请注意，这些 get 方法是类型安全的。 这意味着编译器已经基于用于初始化元组的元素值知道方法的返回类型。
+请注意，这些获取方法是类型安全的。 这意味着编译器已经基于用于初始化元组的元素值知道方法的返回类型。
 
 ###### 4.2.2 `getValue(int index)`方法
 
-元组还有另一种类型不安全的方法 **getValue（int index）**。 因此，在分配变量时，需要将值转换为期望的类型。
+元组还有另一种类型不安全的方法`getValue(int index)`。 因此，在分配变量时，需要将值转换为期望的类型。
 
 ```java
 Pair<String, Integer> pair = Pair.with("Sajal", 12);
@@ -187,7 +187,7 @@ Exp : 12
 
 ```
 
-Classes `KeyValue` and `LabelValue` have methods as getKey()/getValue() and getLabel()/getValue(), respectively.
+类`KeyValue`和`LabelValue`的方法分别为`getKey()`/`getValue()`和`getLabel()`/`getValue()`。
 
 #### 4.3 设定值
 
@@ -218,7 +218,7 @@ System.out.println(modifiedPair);
 
 ###### 4.4.1 `add()`方法
 
-我们还可以在 Tuple 中添加元素，这将返回与元素数量匹配的新元组类型。 例如，如果我们将元素值添加到`Pair`，那么我们将获得一个`Triplet`对象作为回报。
+我们还可以在元组中添加元素，这将返回与元素数量匹配的新元组类型。 例如，如果我们将元素值添加到`Pair`，那么我们将获得一个`Triplet`对象作为回报。
 
 元组的末尾添加了新元素。
 
@@ -315,7 +315,7 @@ System.out.println(Arrays.toString(quartletArr));
 
 #### 4.6 迭代
 
-javatuples 中的所有 tuple 类都实现`Iterable`接口，因此可以与集合或数组相同的方式对其进行迭代。
+`javatuples`中的所有元组类都实现`Iterable`接口，因此可以与集合或数组相同的方式对其进行迭代。
 
 ```java
 Quartet<String, Integer, String, Double> quartet1 = Quartet.with("A1",1,"A3",2.3);
@@ -338,18 +338,18 @@ A3
 
 #### 4.7 Java 元组中的更多操作
 
-所有元组类都有以下实用方法，例如 collection，我们可以根据需要使用它们。
+所有元组类都有以下实用方法，例如集合，我们可以根据需要使用它们。
 
-*   **contains（）** –如果该元组包含指定的元素，则返回`true`。
-*   **containsAll（）** –如果该元组包含所有指定的元素，则返回`true`。
-*   **indexOf（）** –返回指定元素首次出现的索引。
-*   **lastIndexOf（）** –返回指定元素最后一次出现的索引。
+*   **`contains()`** – 如果该元组包含指定的元素，则返回`true`。
+*   **`containsAll()`** – 如果该元组包含所有指定的元素，则返回`true`。
+*   **`indexOf()`** – 返回指定元素首次出现的索引。
+*   **`lastIndexOf()`** – 返回指定元素最后一次出现的索引。
 
-元组还提供 **hashCode（）**， **equals（）**和 **compareTo（）**方法的通用实现，这些方法可以很好地处理包装程序和字符串类。
+元组还提供`hashCode()`，`equals()`和`compareTo()`方法的通用实现，这些方法可以很好地处理包装程序和字符串类。
 
 ## 5\. Java 元组 - 总结
 
-在此 **Java 元组教程**中，我们了解了如何通过 *javatuple* 库在 Java 中使用元组。 因此，如果您对存储*固定数量的异构元素*的数据结构有任何要求，则可以使用此库。 它非常简单，易于使用并提供良好的性能。
+在此 **Java 元组教程**中，我们了解了如何通过`javatuple`库在 Java 中使用元组。 因此，如果您对存储*固定数量的异构元素*的数据结构有任何要求，则可以使用此库。 它非常简单，易于使用并提供良好的性能。
 
 [下载源码](https://howtodoinjava.com/wp-content/uploads/2018/10/javaTuples.zip)
 
@@ -357,4 +357,4 @@ A3
 
 参考文献：
 
-[Javatuples 的官方页面](https://www.javatuples.org/index.html)
\ No newline at end of file
+[`Javatuples`的官方页面](https://www.javatuples.org/index.html)
\ No newline at end of file

docs/java/69.md

@@ -103,7 +103,7 @@ c -> { //some complex statements }  	// takes a collection and do some procesing
 
 ## 2\. Java 8 功能接口
 
-**单一抽象方法接口**（SAM 接口）不是一个新概念。 这意味着**仅使用一种方法**进行接口。 在 Java 中，我们已经有许多此类 SAM 接口的示例。 从 Java 8 开始，它们也将**也称为功能接口**。 Java 8 通过使用新的注释（即 **@FunctionalInterface** ）标记这些接口来实施单一职责规则。
+**单一抽象方法接口**（SAM 接口）不是一个新概念。 这意味着**仅使用一种方法**进行接口。 在 Java 中，我们已经有许多此类 SAM 接口的示例。 从 Java 8 开始，它们也将**也称为功能接口**。 Java 8 通过使用新的注释（即 **@FunctionalInterface** ）标记这些接口来实现单一职责规则。
 
 例如，Runnable 接口的新定义是这样的：