2020-07-11 12:16:12

docs/c/26.md

@@ -10,7 +10,7 @@
 float x[3][4];
 ```
 
-在此，`x`是二维（2d）阵列。 该数组可以容纳 12 个元​​素。 您可以将数组视为具有 3 行的表，每行有 4 列。
+在此，`x`是二维（2d）数组。 该数组可以容纳 12 个元​​素。 您可以将数组视为具有 3 行的表，每行有 4 列。
 
 ![Two dimensional array in C programming](img/a6d7a6659d07991f8409ba3cd8b7af51.png)
 

docs/c/46.md

@@ -87,7 +87,7 @@ int main()
 } 
 ```
 
-**3\. C 程序：使用`fwrite()`将结构数组的所有成员写入文件。 从文件中读取阵列并显示在屏幕上。**
+**3\. C 程序：使用`fwrite()`将结构数组的所有成员写入文件。 从文件中读取数组并显示在屏幕上。**
 
 ```c
 #include <stdio.h>

docs/cpp/3.md

@@ -139,4 +139,4 @@ LIGHT_SPEED = 2500 // Error! LIGHT_SPEED is a constant.
 
 在这里，我们使用了关键字`const`来声明名为`LIGHT_SPEED`的常量。 如果尝试更改`LIGHT_SPEED`的值，则会出现错误。
 
-也可以使用`#define`预处理程序指令创建一个常量。 我们将在 C++ 宏教程中详细了解它。
\ No newline at end of file
+也可以使用`#define`预处理器指令创建一个常量。 我们将在 C++ 宏教程中详细了解它。
\ No newline at end of file

docs/cpp/43.md

@@ -158,7 +158,7 @@ int main() {
 
 创建对象`Test`时，将调用构造器，该构造器为`num`浮点数据分配内存。
 
-当对象被销毁时，即，对象超出范围时，将自动调用析构函数。
+当对象被销毁时，即，对象超出范围时，将自动调用析构器。
 
 ```cpp
     ~Test() {
@@ -167,4 +167,4 @@ int main() {
 
 ```
 
-该析构函数执行`delete[] ptr;`，并将内存返回给操作系统。
\ No newline at end of file
+该析构器执行`delete[] ptr;`，并将内存返回给操作系统。
\ No newline at end of file

docs/cpp/45.md

@@ -16,7 +16,7 @@
 
 由于所有角色都是人，因此他们可以走路和说话。 但是，他们也有一些特殊技能。 数学老师可以**教数学**，足球运动员可以**踢足球**，商人可以**经营企业**。
 
-您可以单独创建三个可以走路，说话和执行其特殊技能的班级，如下图所示。
+您可以单独创建三个可以走路，说话和执行其特殊技能的类，如下图所示。
 
 ![Solving a problem without inheritance in C++](img/f8a8ee6ec7e2d237bc937d6925ca1938.png "Without inheritance")
 

docs/cpp/48.md

@@ -184,7 +184,7 @@ int main()
 
 如果从基类继承多个类，则称为[分层继承](http://www.programtopia.net/cplusplus/docs/hierarchical-inheritance-c-programming?utm_source=programiz&utm_campaign=display)。 在分层继承中，子类中共有的所有函数都包括在基类中。
 
-例如：物理，化学，生物学均来自科学课。
+例如：物理，化学，生物学均来自科学类。
 
 * * *
 

docs/cpp/53.md

@@ -40,7 +40,7 @@ Hello World!
     在 C++ 中，以`//`开头的任何行都是注释。 注释供阅读代码的人员使用，以更好地理解程序的功能。 C++ 编译器完全忽略了它。
 2.  `#include <iostream>`
 
-    `#include`是预处理程序指令，用于在程序中包含文件。 上面的代码包括`iostream`文件的内容。
+    `#include`是预处理器指令，用于在程序中包含文件。 上面的代码包括`iostream`文件的内容。
 
     这使我们可以在程序中使用`cout`在屏幕上打印输出。
 

docs/csharp/19.md

-# C# 预处理程序指令
+# C# 预处理器指令
 
 > 原文： [https://www.programiz.com/csharp-programming/preprocessor-directives](https://www.programiz.com/csharp-programming/preprocessor-directives)
 
 #### 在本教程中，我们将学习预处理器指令，C# 中的可用指令以及何时，为什么以及为什么使用它们。
 
-顾名思义，预处理器指令是在实际编译开始之前进行处理的语句块。 C# 预处理程序指令是影响编译过程的编译器命令。
+顾名思义，预处理器指令是在实际编译开始之前进行处理的语句块。 C# 预处理器指令是影响编译过程的编译器命令。
 
 这些命令指定要编译的代码部分或如何处理特定的错误和警告。
 
-C# 预处理程序指令以`# (hash)`符号开头，所有预处理程序指令都持续一行。 预处理器指令由`new line`而不是`semicolon`终止。
+C# 预处理器指令以`# (hash)`符号开头，所有预处理器指令都持续一行。 预处理器指令由`new line`而不是`semicolon`终止。
 
 C# 中可用的预处理器指令为：
 

docs/csharp/21.md

@@ -16,7 +16,7 @@
 
 我们有一个名为`HeightWeightInfo`的项目，它显示了身高和体重。
 
-我们有一个名为`File1.cs`的文件，其子类名为`Record`。 它具有两个整数变量`h`和`w`和一个名为`Record`的方法/构造函数，该方法/构造函数分配`h`和`w`的值。
+我们有一个名为`File1.cs`的文件，其子类名为`Record`。 它具有两个整数变量`h`和`w`和一个名为`Record`的方法/构造器，该方法/构造函数分配`h`和`w`的值。
 
 ```cs
 namespace HeightWeightInfo
@@ -81,7 +81,7 @@ namespace HeightWeightInfo
 
 可以使用`partial`类的地方：
 
-1.  在与多个开发人员一起进行较大项目的同时，它可以帮助开发人员同时在同一个班上工作。
+1.  在与多个开发人员一起进行较大项目的同时，它可以帮助开发人员同时在同一个类上工作。
 2.  可以在不重新创建由 IDE（即 Visual Studio）自动生成的源文件的情况下，将代码添加或修改到该类。
 
 * * *

docs/csharp/SUMMARY.md

@@ -15,6 +15,6 @@
     +   [C# 三元（`?:`）运算符](16.md)
 +   [其他话题](17.md)
     +   [C# 按位和移位运算符](18.md)
-    +   [C# 预处理程序指令](19.md)
+    +   [C# 预处理器指令](19.md)
     +   [C# 编程中的命名空间](20.md)
     +   [C# 部分类和部分方法](21.md)

docs/dsal/21.md

@@ -22,7 +22,7 @@
 
 斐波那契堆的重要属性是：
 
-1.  它是**最小堆** -- [**有序**](https://cs.lmu.edu/~ray/notes/orderedtrees/)树的集合。 （即，父母总是比子女小。）
+1.  它是**最小堆** -- [**有序**](https://cs.lmu.edu/~ray/notes/orderedtrees/)树的集合。 （即，父级总是比子级小。）
 2.  指针保持在最小元素节点上。
 3.  它由一组标记的节点组成。 （减少按键操作）
 4.  斐波那契堆中的树是无序的，但[植根于](https://mathworld.wolfram.com/RootedTree.html)。

docs/dsal/22.md

@@ -71,7 +71,7 @@
 
     ![Cut 26 and add it to root list](img/50808a768ed07c56060a1f95a6078138.png "Decrease-key operation")
 
-    剪裁 26 并将其添加到根列表中。 呼叫`Cut(24)`和`Cascading-Cut(7)`。 这些操作将导致下面的树。
+    剪裁 26 并将其添加到根列表中。 调用`Cut(24)`和`Cascading-Cut(7)`。 这些操作将导致下面的树。
 
     ![Cut 24 and add it to root list](img/d0bd12ec9f2f79c499e8eb94a0713b1d.png "Decrease-key operation")
 

docs/dsal/39.md

@@ -52,7 +52,7 @@
     从 B 树中删除 35
 3.  这种情况与情况 II（1）相似，但是在此处，直接父节点上方会生成空白空间。
     删除键后，将空白空间与其同级合并。
-    用顺序后继填充祖父母节点中的空白区域。
+    用顺序后继填充祖父节点中的空白区域。
 
     ![Delete a key from a B+tree](img/b735d929d2b05a58783584fe7b7f5bcf.png "Deletion from a B+ tree")
 

docs/dsal/40.md

@@ -1860,5 +1860,5 @@ int main() {
 
 1.  实现有限图
 2.  要实现 Java 包：`java.util.TreeMap`和`java.util.TreeSet`
-3.  要在 C++ 中实现标准模板库（STL）：多集，地图，多图
+3.  要在 C++ 中实现标准模板库（STL）：多集，映射，多映射
 4.  在 Linux 内核中
\ No newline at end of file

docs/java/126.md

@@ -29,7 +29,7 @@ public interface MyInterface{
 
 在上面的示例中，接口`MyInterface`只有一个抽象方法`getValue()`。 因此，它是一个函数式接口。
 
-在这里，我们使用了注释`@FunctionalInterface`。 该注释会强制 Java 编译器指示该接口是函数式接口。 因此，不允许有多个抽象方法。 但是，它不是强制性的。
+在这里，我们使用了注解`@FunctionalInterface`。 该注解会强制 Java 编译器指示该接口是函数式接口。 因此，不允许有多个抽象方法。 但是，它不是强制性的。
 
 在 Java 7 中，函数式接口被视为[单一抽象方法](https://stackoverflow.com/a/23342625/4494547)或 **SAM** 类型。 SAM 通常用 Java 7 中的匿名类实现。
 
@@ -306,7 +306,7 @@ factorial of 5 = 120
 
 在上面的示例中，我们创建了一个名为`GenericInterface`的通用函数式接口。 它包含一个名为`func()`的通用方法。
 
-在主班里面
+在`Main`类里面
 
 *   `GenericInterface<String> reverse` - 创建对接口的引用。 现在，该接口可处理`String`类型的数据。
 *   `GenericInterface<Integer> factorial` - 创建对接口的引用。 在这种情况下，该接口对`Integer`类型的数据进行操作。

docs/java/212.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://www.programiz.com/java-programming/examples/convert-outputstream-string](https://www.programiz.com/java-programming/examples/convert-outputstream-string)
 
-#### 在此程序中，您将学习如何使用 Java 中的`String`初始化程序将输出流转换为字符串。
+#### 在此程序中，您将学习如何使用 Java 中的`String`初始化器将输出流转换为字符串。
 
 ## 示例：将`OutputStream`转换为`String`
 

docs/java/34.md

@@ -46,7 +46,7 @@ I am a dog.
 
 ![Working of method overriding in Java.](img/f82fa138b161013f631b9a4d17810531.png "Method Overriding in Java")
 
-注意在我们的示例中使用了`@Override`注解。 在 Java 中，注释是我们用来向编译器提供信息的元数据。 在此，`@Override`注解指定编译器，该注释之后的方法将覆盖超类的方法。
+注意在我们的示例中使用了`@Override`注解。 在 Java 中，注解是我们用来向编译器提供信息的元数据。 在此，`@Override`注解指定编译器，该注解之后的方法将覆盖超类的方法。
 
 使用`@Override`不是强制性的。 但是，当我们使用此方法时，该方法应遵循所有覆盖规则。 否则，编译器将生成错误。
 

docs/java/39.md

@@ -83,7 +83,7 @@ My age is 24
 p1.age = 24;     // error: age has private access in Person 
 ```
 
-通过将`age`设为私有，我们可以限制来自课堂之外的未经授权的访问。 这是数据隐藏。
+通过将`age`设为私有，我们可以限制来自类外的未经授权的访问。 这是数据隐藏。
 
 * * *
 
@@ -153,4 +153,4 @@ setName()   // provides write-only access
 
 人们通常将封装视为数据隐藏，但这并非完全正确。
 
-封装是指将相关领域和方法捆绑在一起。 这使我们可以实现数据隐藏。 封装本身并不是隐藏数据。
\ No newline at end of file
+封装是指将相关字段和方法捆绑在一起。 这使我们可以实现数据隐藏。 封装本身并不是隐藏数据。
\ No newline at end of file

docs/java/41.md

@@ -93,7 +93,7 @@ Ram Clock speed = 5.5
 
 在上面的程序中，有两个嵌套类：`CPU`和`RAM`位于外部类内部：`CPU`。 我们可以将内部类声明为受保护的。 因此，我们已将 RAM 类声明为受保护的。
 
-在主班里面
+在`Main`类里面
 
 *   我们首先创建了一个名为`cpu`的外部类`CPU`的实例。
 *   然后使用外部类的实例创建内部类的对象：

docs/java/58.md

@@ -125,7 +125,7 @@ java -ea
 java -ea Main
 ```
 
-要仅启用一个课程，
+要仅启用一个类，
 
 ```java
 java -ea:AnimalClass Main

docs/java/60.md

@@ -6,7 +6,7 @@
 
 Java **集合**框架提供了一组接口和类，以实现各种数据结构和算法。
 
-例如，集合框架的`LinkedList`类提供了双向链接列表数据结构的实现。
+例如，集合框架的`LinkedList`类提供了双向链表数据结构的实现。
 
 * * *
 

docs/java/64.md

@@ -30,7 +30,7 @@
 Vector<Type> vector = new Vector<>(); 
 ```
 
-在此，`Type`表示链接列表的类型。 例如，
+在此，`Type`表示链表的类型。 例如，
 
 ```java
 // create Integer type linked list

docs/java/70.md

@@ -30,7 +30,7 @@ Java `LinkedList`类提供了一个双向链表实现。
 *   **下一个** - 在列表中存储下一个元素的地址。 最后一个元素为`null`。
 *   **数据** - 存储实际数据。
 
-链接列表中的元素未按顺序存储。 相反，它们分散并通过链接（上一个和下一个）连接。
+链表中的元素未按顺序存储。 相反，它们分散并通过链接（上一个和下一个）连接。
 
 ![Working of LinkedList in Java](img/4735f5cddc382d37abf0ada0c963d5ef.png)
 
@@ -44,13 +44,13 @@ Java `LinkedList`类提供了一个双向链表实现。
 
 ## 创建一个`LinkedList`
 
-这是我们如何用 Java 创建链接列表的方法：
+这是我们如何用 Java 创建链表的方法：
 
 ```java
 LinkedList<Type> linkedList = new LinkedList<>(); 
 ```
 
-在此，`Type`表示链接列表的类型。 例如，
+在此，`Type`表示链表的类型。 例如，
 
 ```java
 // create Integer type linked list
@@ -152,7 +152,7 @@ LinkedList: [Dog, Cat, Horse]
 
 **3.添加元素：一个链表到另一个链表**
 
-要将链接列表的所有元素添加到另一个链接列表，我们使用`addAll()`方法。 例如，
+要将链表的所有元素添加到另一个链表，我们使用`addAll()`方法。 例如，
 
 ```java
 import java.util.LinkedList;
@@ -187,7 +187,7 @@ Animals: [Crocodile, Dog, Cat, Horse]
 
 **4.添加元素：使用`listIterator()`方法**
 
-我们还可以使用`listsIterator()`方法将元素添加到链接列表中。 要使用它，我们必须导入`java.util.ListIterator`包。 例如，
+我们还可以使用`listsIterator()`方法将元素添加到链表中。 要使用它，我们必须导入`java.util.ListIterator`包。 例如，
 
 ```java
 import java.util.ArrayList;
@@ -252,7 +252,7 @@ Element at index 1: Horse
 
 **2.访问元素：使用`iterator()`方法**
 
-要遍历链接列表的元素，我们可以使用`iterator()`方法。 我们必须导入`java.util.Iterator`包才能使用此方法。 例如，
+要遍历链表的元素，我们可以使用`iterator()`方法。 我们必须导入`java.util.Iterator`包才能使用此方法。 例如，
 
 ```java
 import java.util.LinkedList;
@@ -296,9 +296,9 @@ LinkedList: Dog, Cat, Horse,
 
 **3.访问元素：使用`listIterator()`方法**
 
-我们还可以使用`listIterator()`方法来迭代链接列表的元素。 要使用此方法，我们必须导入`java.util.ListIterator`包。
+我们还可以使用`listIterator()`方法来迭代链表的元素。 要使用此方法，我们必须导入`java.util.ListIterator`包。
 
-在链接列表中，`listsIterator()`方法更为可取。 这是因为`listIterator()`的对象也可以向后迭代。 例如，
+在链表中，`listsIterator()`方法更为可取。 这是因为`listIterator()`的对象也可以向后迭代。 例如，
 
 ```java
 import java.util.LinkedList;
@@ -355,7 +355,7 @@ Here,
 
 **1.搜索元素：使用`contains()`方法**
 
-要检查链接列表是否包含特定元素，我们使用`contains()`方法。 例如，
+要检查链表是否包含特定元素，我们使用`contains()`方法。 例如，
 
 ```java
 import java.util.LinkedList;
@@ -435,7 +435,7 @@ Last Occurrence of Dog: 3
 
 **1.更改元素：使用`set()`方法**
 
-要更改链接列表的元素，可以使用`set()`方法。 例如，
+要更改链表的元素，可以使用`set()`方法。 例如，
 
 ```java
 import java.util.LinkedList;
@@ -469,7 +469,7 @@ New LinkedList: [Dog, Horse, Cat, Zebra]
 
 **2.更改元素：使用`listIterator()`方法**
 
-我们还可以使用`listIterator()`方法更改链接列表中的元素。 例如，
+我们还可以使用`listIterator()`方法更改链表中的元素。 例如，
 
 ```java
 import java.util.ArrayList;
@@ -546,7 +546,7 @@ New LinkedList: [Dog, Cat, Zebra]
 
 **2.删除元素：使用`listIterator()`方法**
 
-我们还可以使用`listsIterator()`方法从链接列表中删除元素。 例如，
+我们还可以使用`listsIterator()`方法从链表中删除元素。 例如，
 
 ```java
 import java.util.ArrayList;
@@ -584,7 +584,7 @@ New LinkedList: [Cat, Horse]
 
 **3.删除元素：使用`clear()`方法**
 
-要从链接列表中删除所有元素，我们使用`clear()`方法。 例如，
+要从链表中删除所有元素，我们使用`clear()`方法。 例如，
 
 ```java
 import java.util.LinkedList;
@@ -666,8 +666,8 @@ New LinkedList: [4, 5]
 
 ### `addFirst()`和`addLast()`方法
 
-*   `addFirst()` - 在链接列表的开头添加指定的元素
-*   `addLast()` - 将指定的元素添加到链接列表的末尾
+*   `addFirst()` - 在链表的开头添加指定的元素
+*   `addLast()` - 将指定的元素添加到链表的末尾
 
 例如：
 
@@ -860,7 +860,7 @@ New LinkedList: [Horse, Cat]
 
 ### `offer()`方法
 
-`offer()`方法将指定的元素添加到链接列表的末尾。 例如，
+`offer()`方法将指定的元素添加到链表的末尾。 例如，
 
 ```java
 import java.util.LinkedList;

docs/java/74.md

@@ -4,7 +4,7 @@
 
 #### 在本教程中，我们将借助示例学习`LinkedBLockingQueue`类及其方法。
 
-Java `Collections`框架的`LinkedBlockingQueue`类使用链接列表提供阻塞队列实现。
+Java `Collections`框架的`LinkedBlockingQueue`类使用链表提供阻塞队列实现。
 
 它实现了 [Java `BlockingQueue`接口](/java-programming/blockingqueue "Java BlockingQueue Interface")。
 
@@ -47,7 +47,7 @@ LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
 LinkedBlockingQueue<Integer> age = new LinkedBlockingQueue<>(5); 
 ```
 
-**注意**：不必提供链接列表的大小。
+**注意**：不必提供链表的大小。
 
 * * *
 
@@ -293,7 +293,7 @@ New LinkedBlockingQueue: [Cat]
 
 ## 为什么要使用`LinkedBlockingQueue`？
 
-`LinkedBlockingQueue`使用链接列表作为其内部存储。
+`LinkedBlockingQueue`使用链表作为其内部存储。
 
 它被视为**线程安全的**集合。 因此，它通常用于多线程应用中。
 

docs/java/76.md

@@ -20,7 +20,7 @@ Java 集合框架的`Map`接口提供了映射数据结构的功能。
 
 我们可以使用与它们关联的键来访问和修改值。
 
-在上图中，我们具有以下值：`Amarica`，`Brazil`和`Spain`。 并且我们有相应的密钥：`us`，`br`和`es`。
+在上图中，我们具有以下值：`Amarica`，`Brazil`和`Spain`。 并且我们有相应的键：`us`，`br`和`es`。
 
 现在，我们可以使用它们的对应键访问这些值。
 
@@ -91,8 +91,8 @@ Map<Key, Value> numbers = new HashMap<>();
 *   **`put(K, V)`** - 将键`K`和值`V`的关联插入到映射中。 如果键已经存在，则新值将替换旧值。
 *   **`putAll()`** - 将指定映射中的所有条目插入此映射。
 *   **`putIfAbsent(K, V)`** - 如果键`K`尚未与值`V`关联，则插入关联。
-*   **`get(K)`** - 返回与指定键`K`关联的值。 如果找不到密钥，则返回`null`。
-*   **`getOrDefault(K, defaultValue)`** - 返回与指定键`K`关联的值。 如果未找到密钥，则返回`defaultValue`。
+*   **`get(K)`** - 返回与指定键`K`关联的值。 如果找不到键，则返回`null`。
+*   **`getOrDefault(K, defaultValue)`** - 返回与指定键`K`关联的值。 如果未找到键，则返回`defaultValue`。
 *   **`containsKey(K)`** - 检查映射中是否存在指定的键`K`。
 *   **`containsValue(V)`** - 检查指定值`V`是否存在于映射中。
 *   **`replace(K, V)`** - 用新的指定值`V`替换键`K`的值。

docs/java/77.md

@@ -172,8 +172,8 @@ Values: [1, 2, 3]
 
 **2.使用`get()`和`getOrDefault()`**
 
-*   `get()` - 返回与指定键关联的值。 如果找不到密钥，则返回`null`。
-*   `getOrDefault()` - 返回与指定键关联的值。 如果找不到密钥，则返回指定的默认值。
+*   `get()` - 返回与指定键关联的值。 如果找不到键，则返回`null`。
+*   `getOrDefault()` - 返回与指定键关联的值。 如果找不到键，则返回指定的默认值。
 
 例如：
 

docs/java/78.md

@@ -6,7 +6,7 @@
 
 Java 集合框架的`LinkedHashMap`类提供[`Map`接口](/java-programming/map "Java Map interface")的哈希表和链表实现。
 
-`LinkedHashMap`接口扩展了[`HashMap`](/java-programming/hashmap)类，以将其条目存储在哈希表中。 它在内部维护所有条目之间的双向链接列表，以对条目进行排序。
+`LinkedHashMap`接口扩展了[`HashMap`](/java-programming/hashmap)类，以将其条目存储在哈希表中。 它在内部维护所有条目之间的双向链表，以对条目进行排序。
 
 ![Java LinkedHashMap class extends the HashMap class.](img/70bc7a6ac01cb14fb13ba84a8661d576.png)
 
@@ -189,8 +189,8 @@ Values: [1, 2, 3]
 
 **2.使用`get()`和`getOrDefault()`**
 
-*   `get()` - 返回与指定键关联的值。 如果找不到密钥，则返回`null`。
-*   `getOrDefault()` - 返回与指定键关联的值。 如果找不到该密钥，它将返回指定的默认值。
+*   `get()` - 返回与指定键关联的值。 如果找不到键，则返回`null`。
+*   `getOrDefault()` - 返回与指定键关联的值。 如果找不到该键，它将返回指定的默认值。
 
 例如：
 
@@ -286,6 +286,6 @@ Updated LinkedHashMap: {One=1}
 
 `LinkedHashMap`和`HashMap`都实现`Map`接口。 但是，它们之间存在一些差异。
 
-*   `LinkedHashMap`在内部维护一个双向链接列表。 因此，它保持其元素的插入顺序。
-*   `LinkedHashMap`类比`HashMap`需要更多的存储空间。 这是因为`LinkedHashMap`内部维护链接列表。
+*   `LinkedHashMap`在内部维护一个双向链表。 因此，它保持其元素的插入顺序。
+*   `LinkedHashMap`类比`HashMap`需要更多的存储空间。 这是因为`LinkedHashMap`内部维护链表。
 *   `LinkedHashMap`的性能比`HashMap`慢。
\ No newline at end of file

docs/java/79.md

@@ -289,8 +289,8 @@ Values: [1, 2]
 
 **2.使用`get()`和`getOrDefault()`**
 
-*   `get()` - 返回与指定键关联的值。 如果找不到密钥，则返回`null`。
-*   `getOrDefault()` - 返回与指定键关联的值。 如果找不到密钥，则返回指定的默认值。
+*   `get()` - 返回与指定键关联的值。 如果找不到键，则返回`null`。
+*   `getOrDefault()` - 返回与指定键关联的值。 如果找不到键，则返回指定的默认值。
 
 例如：
 

docs/java/80.md

@@ -140,7 +140,7 @@ Values: [28, 32, 36, 40]
 
 **2.使用`get()`方法**
 
-`get()`方法返回与指定键关联的值。 如果找不到指定的密钥，则返回`null`。
+`get()`方法返回与指定键关联的值。 如果找不到指定的键，则返回`null`。
 
 例如：
 

docs/java/82.md

@@ -56,7 +56,7 @@ NavigableMap<Key, Value> numbers = new TreeMap<>();
 
 `booleanValue`是可选参数。 其默认值为`false`。
 
-如果将`true`作为`booleanValue`传递，则该方法返回与所有在指定的`key`之前的所有密钥相关联的条目，包括与指定的`key`。
+如果将`true`作为`booleanValue`传递，则该方法返回与所有在指定的`key`之前的所有键相关联的条目，包括与指定的`key`。
 
 * * *
 
@@ -66,7 +66,7 @@ NavigableMap<Key, Value> numbers = new TreeMap<>();
 
 `booleanValue`是可选参数。 其默认值为`true`。
 
-如果`false`作为`booleanValue`传递，则该方法将返回指定的`key`之后与这些密钥相关的所有条目，而不包括与指定的`key`。
+如果`false`作为`booleanValue`传递，则该方法将返回指定的`key`之后与这些键相关的所有条目，而不包括与指定的`key`。
 
 * * *
 

docs/java/83.md

@@ -126,8 +126,8 @@ Values: [1, 3, 2]
 
 **2.使用`get()`和`getOrDefault()`**
 
-*   `get()` - 返回与指定键关联的值。 如果找不到密钥，则返回`null`。
-*   `getOrDefault()` - 返回与指定键关联的值。 如果找不到密钥，则返回指定的默认值。
+*   `get()` - 返回与指定键关联的值。 如果找不到键，则返回`null`。
+*   `getOrDefault()` - 返回与指定键关联的值。 如果找不到键，则返回指定的默认值。
 
 例如：
 

docs/java/85.md

@@ -178,8 +178,8 @@ Values: [1, 2, 3]
 
 **2.使用`get()`和`getOrDefault()`**
 
-*   `get()` - 返回与指定键关联的值。 如果找不到密钥，则返回`null`。
-*   `getOrDefault()` - 返回与指定键关联的值。 如果找不到密钥，则返回指定的默认值。
+*   `get()` - 返回与指定键关联的值。 如果找不到键，则返回`null`。
+*   `getOrDefault()` - 返回与指定键关联的值。 如果找不到键，则返回指定的默认值。
 
 例如：
 

docs/java/90.md

@@ -4,7 +4,7 @@
 
 #### 在本教程中，我们将借助示例学习 Java `LinkedHashSet`类及其方法。
 
-Java 集合框架的`LinkedHashSet`类提供哈希表和链接列表数据结构的功能。
+Java 集合框架的`LinkedHashSet`类提供哈希表和链表数据结构的功能。
 
 它实现了[`Set`接口](/java-programming/set "Java Set Interface")。
 
@@ -381,9 +381,9 @@ Is LinkedHashSet2 is a subset of LinkedHashSet1? true
 
 `LinkedHashSet`和`HashSet`都实现`Set`接口。 但是，它们之间存在一些差异。
 
-*   `LinkedHashSet`在内部维护一个链接列表。 因此，它保持其元素的插入顺序。
-*   `LinkedHashSet`类比`HashSet`需要更多的存储空间。 这是因为`LinkedHashSet`内部维护链接列表。
-*   `LinkedHashSet`的性能比`HashSet`慢。 这是因为`LinkedHashSet`中存在链接列表。
+*   `LinkedHashSet`在内部维护一个链表。 因此，它保持其元素的插入顺序。
+*   `LinkedHashSet`类比`HashSet`需要更多的存储空间。 这是因为`LinkedHashSet`内部维护链表。
+*   `LinkedHashSet`的性能比`HashSet`慢。 这是因为`LinkedHashSet`中存在链表。
 
 * * *
 

docs/kotlin/121.md

@@ -44,7 +44,7 @@ val result = capitals.toList().sortedBy { (_, value) -> value}.toMap()
 ```
 
 *   首先，使用`toList()`将`capitals`转换为列表。
-*   然后，`sortedBy()`用于按值`{ (_, value) -> value}`对列表进行排序。 我们将`_`用于密钥，因为我们不使用它进行排序。
+*   然后，`sortedBy()`用于按值`{ (_, value) -> value}`对列表进行排序。 我们将`_`用于键，因为我们不使用它进行排序。
 *   最后，我们使用`toMap()`将其转换回映射，并将其存储在`result`中。
 
 以下是等效的 Java 代码： [Java 程序：通过值对映射进行排序](/java-programming/examples/sort-map-values "Java program to sort a map by values")。
\ No newline at end of file

docs/kotlin/26.md

@@ -21,7 +21,7 @@
 
 由于所有角色都是人，因此他们可以走路和说话。 但是，他们也有一些特殊技能。 数学老师可以**教数学**，足球运动员可以**踢足球**，商人可以**经营业务**。
 
-您可以单独创建三个可以走路，说话和执行其特殊技能的课程。
+您可以单独创建三个可以走路，说话和执行其特殊技能的类。
 
 ![Example of classes sharing same features without the use of inheritance.](img/6350dc50b918abd693e84e2451f5c145.png)
 
@@ -69,7 +69,7 @@ class Businessman(age: Int): Person(age) {
 
 注意，在基类`Person`之前的关键字`open`。 这一点很重要。
 
-默认情况下，Kotlin 中的类是最终的。 如果您熟悉 Java，那么您将知道最终类不能被子类化。 通过在类上使用开放注释，编译器允许您从其派生新类。
+默认情况下，Kotlin 中的类是最终的。 如果您熟悉 Java，那么您将知道最终类不能被子类化。 通过在类上使用开放修饰符，编译器允许您从其派生新类。
 
 * * *
 

docs/kotlin/29.md

@@ -142,7 +142,7 @@ fun main(args: Array<String>) {
 
 在这里，`prop`不是抽象的。 但是，它在接口内部有效，因为它为访问器提供了实现。
 
-但是，您无法在界面内执行类似`val prop: Int = 23`的操作。
+但是，您无法在接口内执行类似`val prop: Int = 23`的操作。
 
 * * *
 

docs/py/33.md

@@ -43,7 +43,7 @@ my_dict = dict([(1,'apple'), (2,'ball')])
 
 虽然索引与其他数据类型一起使用来访问值，但是字典使用`keys`。 可以在方括号`[]`内或`get()`方法中使用键。
 
-如果我们使用方括号`[]`，则在字典中找不到键的情况下会抛出`KeyError`。 另一方面，如果找不到密钥，则`get()`方法返回`None`。
+如果我们使用方括号`[]`，则在字典中找不到键的情况下会抛出`KeyError`。 另一方面，如果找不到键，则`get()`方法返回`None`。
 
 ```py
 # get vs [] for retrieving elements
@@ -81,7 +81,7 @@ KeyError: 'address'
 
 字典是可变的。 我们可以使用赋值运算符添加新项或更改现有项的值。
 
-如果密钥已经存在，那么现有值将被更新。 如果键不存在，则将新的**键值**对添加到字典中。
+如果键已经存在，那么现有值将被更新。 如果键不存在，则将新的**键值**对添加到字典中。
 
 ```py
 # Changing and adding Dictionary Elements

docs/py/41.md

@@ -146,7 +146,7 @@ Blu is now dancing
 
 * * *
 
-## 遗产
+## 继承
 
 继承是一种创建新类以使用现有类的详细信息而不进行修改的方法。 新形成的类是派生类（或子类）。 同样，现有类是基类（或父类）。
 

docs/py/44.md

@@ -85,7 +85,7 @@ print(isinstance("Hello",object))
 
 因此，在上述`MultiDerived`类的示例中，搜索顺序为`MultiDerived`，`Base1`，`Base2`，`object`。 该顺序也称为`MultiDerived`类的线性化，用于查找该顺序的规则集称为**方法解析顺序（MRO）**。
 
-MRO 必须防止本地优先级排序，并且还必须提供单调性。 它确保班级始终出现在其班级之前。 如果有多个父母，顺序与基类的元组相同。
+MRO 必须防止本地优先级排序，并且还必须提供单调性。 它确保类始终出现在其类之前。 如果有多个父级，顺序与基类的元组相同。
 
 类别的 MRO 可以视为`__mro__`属性或`mro()`方法。 前者返回一个元组，而后者返回一个列表。
 

docs/py/7.md

@@ -248,7 +248,7 @@ TypeError: 'set' object does not support indexing
 
 [字典](https://www.programiz.com/python-programming/dictionary)是键值对的无序集合。
 
-当我们拥有大量数据时，通常使用它。 字典针对检索数据进行了优化。 我们必须知道检索值的密钥。
+当我们拥有大量数据时，通常使用它。 字典针对检索数据进行了优化。 我们必须知道检索值的键。
 
 在 Python 中，字典在花括号`{}`中定义，每一项都是一对，形式为`key:value`。 键和值可以是任何类型。
 

docs/swift/28.md

@@ -90,7 +90,7 @@ print(newDictionary)
 
 在上述程序中，`zip(customKeys,customValues)`创建一个新的*元组*序列，每个元素表示来自`customKeys`和`customValues`的值。 要了解有关`zip`的工作原理的更多信息，请访问 Swift `zip`。
 
-现在，我们可以将此序列传递给`Dictionary(uniqueKeysWithValues:)`初始化程序，并创建一个新的`Dictionary`。 因此，`print(newDictionary)`输出具有两个数组元素的新字典。
+现在，我们可以将此序列传递给`Dictionary(uniqueKeysWithValues:)`初始化器，并创建一个新的`Dictionary`。 因此，`print(newDictionary)`输出具有两个数组元素的新字典。
 
 * * *