2020-06-30 09:30:02

docs/kotlin/100.md

@@ -36,9 +36,9 @@ fun main(args: Array<String>) {
 
 现在，为了将两者结合起来，我们使用 arraycopy（）函数将两个数组中的每个元素都复制为结果。
 
-简单来说，`arraycopy(array1, 0, result, 0, aLen)`函数告诉程序将 `array1` 从索引`0`开始复制到`结果`从索引`0`复制到 `aLen` 。
+简单来说，`arraycopy(array1, 0, result, 0, aLen)`函数告诉程序将`array1`从索引`0`开始复制到`结果`从索引`0`复制到`aLen`。
 
-同样，对于`arraycopy(array2, 0, result, aLen, bLen)`告诉程序从索引`0`开始将 `array2` 从索引 `aLen` 复制到 `bLen` 。
+同样，对于`arraycopy(array2, 0, result, aLen, bLen)`告诉程序从索引`0`开始将`array2`从索引`aLen`复制到`bLen`。
 
 * * *
 
@@ -75,12 +75,12 @@ When you run the program, the output will be:
 [1, 2, 3, 4, 5, 6]
 ```
 
-在上述程序中，我们不使用`arraycopy`，而是将两个数组 `array1` 和 `array2` 的每个元素手动复制到`结果`。
+在上述程序中，我们不使用`arraycopy`，而是将两个数组`array1`和`array2`的每个元素手动复制到`结果`。
 
 我们存储`结果`所需的`总长度`，即`array1.length + array2\. length`。 然后，我们创建一个新的长度数组结果。
 
-现在，我们使用 for-each 循环遍历 `array1` 的每个元素，并将其存储在`结果`中。 分配后，我们将位置 `pos` 增加 1 `pos++`。
+现在，我们使用 for-each 循环遍历`array1`的每个元素，并将其存储在`结果`中。 分配后，我们将位置`pos`增加 1 `pos++`。
 
-同样，我们对 `array2` 执行相同的操作，并将每个元素从 `array1` 之后的位置存储在`结果`中。
+同样，我们对`array2`执行相同的操作，并将每个元素从`array1`之后的位置存储在`结果`中。
 
 以下是等效的 Java 代码：[用于连接两个数组](/java-programming/examples/concatenate-two-arrays "Java program to concatenate two arrays")的 Java 程序。
\ No newline at end of file

docs/kotlin/101.md

@@ -23,7 +23,7 @@ fun main(args: Array<String>) {
 The string is: c
 ```
 
-在上面的程序中，我们有一个字符存储在变量 `ch` 中。 我们使用`Character`类的`toString()`方法将字符转换为字符串 `st` 。
+在上面的程序中，我们有一个字符存储在变量`ch`中。 我们使用`Character`类的`toString()`方法将字符转换为字符串`st`。
 
 另外，我们也可以使用`String`的`valueOf()`方法进行转换。 但是，两者在内部是相同的。
 
@@ -53,9 +53,9 @@ aeiou
 aeiou
 ```
 
-在上面的程序中，我们有一个包含元音的 char 数组 `ch` 。 我们再次使用`String`的`valueOf()`方法将字符数组转换为`String`。
+在上面的程序中，我们有一个包含元音的 char 数组`ch`。 我们再次使用`String`的`valueOf()`方法将字符数组转换为`String`。
 
-我们还可以使用`String`构造函数，该构造函数将字符数组 `ch` 作为转换参数。
+我们还可以使用`String`构造函数，该构造函数将字符数组`ch`作为转换参数。
 
 * * *
 
@@ -81,7 +81,7 @@ When you run the program, the output will be:
 [T, h, i, s,  , i, s,  , g, r, e, a, t]
 ```
 
-在以上程序中，我们在变量 `st` 中存储了一个字符串。 我们使用`String`的`toCharArray()`方法将字符串转换为存储在 `chars` 中的字符数组。
+在以上程序中，我们在变量`st`中存储了一个字符串。 我们使用`String`的`toCharArray()`方法将字符串转换为存储在`chars`中的字符数组。
 
 然后，我们使用`Arrays`的`toString()`方法以类似数组的形式打印`字符`的元素。
 

docs/kotlin/102.md

@@ -33,9 +33,9 @@ fun main(args: Array<String>) {
 3 is found.
 ```
 
-在上面的程序中，我们有一个整数数组，存储在变量 `num` 中。 同样，要找到的编号存储在`中以查找`。
+在上面的程序中，我们有一个整数数组，存储在变量`num`中。 同样，要找到的编号存储在`中以查找`。
 
-现在，我们使用`for-in`循环遍历 `num` 的所有元素，并分别检查 `toFind` 是否等于 `n` 。
+现在，我们使用`for-in`循环遍历`num`的所有元素，并分别检查`toFind`是否等于`n`。
 
 如果是，我们将`找到的`设置为`true`，然后退出循环。 如果不是，我们转到下一个迭代。
 
@@ -68,9 +68,9 @@ When you run the program, the output will be:
 
 在上面的程序中，我们没有使用 foreach 循环，而是将数组转换为`IntStream`并使用其`anyMatch()`方法。
 
-`anyMatch()`方法采用返回布尔值的谓词，表达式或函数。 在我们的情况下，谓词将流中的每个元素 `n` 与`进行比较以查找`，然后返回`true`或`false`。
+`anyMatch()`方法采用返回布尔值的谓词，表达式或函数。 在我们的情况下，谓词将流中的每个元素`n`与`进行比较以查找`，然后返回`true`或`false`。
 
-如果元素 `n` 中的任何一个返回`true`，则将找到的设置为`true`的`。`
+如果元素`n`中的任何一个返回`true`，则将找到的设置为`true`的`。`
 
 * * *
 
@@ -99,6 +99,6 @@ When you run the program, the output will be:
 Four is found.
 ```
 
-在上面的程序中，我们使用了非原始数据类型`String`，并使用`Arrays`的`stream()`方法首先将其转换为流，然后使用`anyMatch()`检查数组是否包含给定值 `]查找`。
+在上面的程序中，我们使用了非原始数据类型`String`，并使用`Arrays`的`stream()`方法首先将其转换为流，然后使用`anyMatch()`检查数组是否包含给定值`]查找`。
 
 以下是等效的 Java 代码：[检查数组是否包含给定值](/java-programming/examples/array-contains-value "Java program to check if array contains a given value")的 Java 程序。
\ No newline at end of file

docs/kotlin/103.md

@@ -37,7 +37,7 @@ str1 is null or empty.
 str2 is null or empty.
 ```
 
-在上面的程序中，我们有两个字符串 `str1` 和 `str2` 。 `str1` 包含空值， `str2` 是空字符串。
+在上面的程序中，我们有两个字符串`str1`和`str2`。`str1`包含空值，`str2`是空字符串。
 
 我们还创建了一个函数`isNullOrEmpty()`，顾名思义，该函数检查字符串是空还是空。 它使用字符串的`!= null`和`isEmpty()`方法使用空检查来对其进行检查。
 

docs/kotlin/106.md

@@ -36,7 +36,7 @@ fun main(args: Array<String>) {
 Tue Aug 08 10:20:56 NPT 2017 + Tue Aug 08 10:20:56 NPT 2017 = Mon Apr 16 20:41:53 NPT 4035
 ```
 
-在上述程序中， `c1` 和 `c2` 存储当前日期。 然后，我们只需克隆 `c1` ，然后依次添加 `c2` 的每个 DateTime 属性。
+在上述程序中，`c1`和`c2`存储当前日期。 然后，我们只需克隆`c1`，然后依次添加`c2`的每个 DateTime 属性。
 
 如您所见，我们在月份中增加了 1。 这是因为，科特林的月份从 0 开始。
 

docs/kotlin/107.md

@@ -37,7 +37,7 @@ list2: [b]
 joined: [a, b]
 ```
 
-在以上程序中，我们使用`List`的`addAll()`方法将列表 `list1` 和 `list2` 联接到联接列表。
+在以上程序中，我们使用`List`的`addAll()`方法将列表`list1`和`list2`联接到联接列表。
 
 * * *
 

docs/kotlin/108.md

@@ -28,7 +28,7 @@ aeiou
 
 在上面的程序中，我们定义了一个数组列表`vowels_list`。 要将数组列表转换为数组，我们使用了`toTypedArray()`方法。
 
-最后，使用 `forEach()`循环打印数组的元素。
+最后，使用`forEach()`循环打印数组的元素。
 
 * * *
 

docs/kotlin/11.md

@@ -17,7 +17,7 @@ else {
 }
 ```
 
-如果将 `testExpression` 评估为`true`，则`if`执行代码的特定部分。 它可以具有可选的 `else` 子句。 如果`testExpression`为假，则执行`else`子句中的代码。
+如果将`testExpression`评估为`true`，则`if`执行代码的特定部分。 它可以具有可选的`else`子句。 如果`testExpression`为假，则执行`else`子句中的代码。
 
 * * *
 
@@ -162,7 +162,7 @@ fun main(args: Array<String>) {
 
 ## Kotlin 如果表达式嵌套
 
-一个 `if` 表达式可以位于另一个 `if` 表达式的嵌套块内。
+一个`if`表达式可以位于另一个`if`表达式的嵌套块内。
 
 * * *
 

docs/kotlin/110.md

@@ -35,8 +35,8 @@ Key List: [1, 2, 3, 4, 5]
 Value List: [a, b, c, d, e]
 ```
 
-在上面的程序中，我们有一个名为`的整数和字符串映射`。 由于`映射`包含**键，值**对，因此我们需要两个列表来存储它们，分别是 `keyList` （用于键）和 `valueList` （用于）。 价值观。
+在上面的程序中，我们有一个名为`的整数和字符串映射`。 由于`映射`包含**键，值**对，因此我们需要两个列表来存储它们，分别是`keyList`（用于键）和`valueList`（用于）。 价值观。
 
-我们使用 map 的`keySet()`方法获取所有键，并从中创建了一个`ArrayList` `keyList` 。 同样，我们使用 map 的`values()`方法来获取所有值，并从中创建一个`ArrayList` `valueList` 。
+我们使用 map 的`keySet()`方法获取所有键，并从中创建了一个`ArrayList` `keyList`。 同样，我们使用 map 的`values()`方法来获取所有值，并从中创建一个`ArrayList` `valueList`。
 
 以下是等效的 Java 代码： [Java 程序，用于将映射转换为列表](/java-programming/examples/convert-map-list "Java Program to convert map to a list")。
\ No newline at end of file

docs/kotlin/111.md

@@ -25,7 +25,7 @@ fun main(args: Array<String>) {
 Set: [a, b, c]
 ```
 
-在上面的程序中，我们有一个名为 `array` 的数组。 要将`数组`转换​​为`设置`，我们首先使用`asList()`将其转换为列表，因为`HashSet`接受 list 作为构造函数。
+在上面的程序中，我们有一个名为`array`的数组。 要将`数组`转换​​为`设置`，我们首先使用`asList()`将其转换为列表，因为`HashSet`接受 list 作为构造函数。
 
 然后，使用转换后的列表的元素初始化`集`。
 

docs/kotlin/112.md

@@ -25,9 +25,9 @@ fun main(args: Array<String>) {
 0A020F0B
 ```
 
-在上面的程序中，我们有一个名为 `bytes` 的字节数组。 要将字节数组转换为十六进制值，我们遍历数组中的每个字节，并使用`String`的`format()`。
+在上面的程序中，我们有一个名为`bytes`的字节数组。 要将字节数组转换为十六进制值，我们遍历数组中的每个字节，并使用`String`的`format()`。
 
-我们使用`%02X`打印十六进制（`X`）值的两个位置（`02`）并将其存储在字符串 `st` 中。
+我们使用`%02X`打印十六进制（`X`）值的两个位置（`02`）并将其存储在字符串`st`中。
 
 对于大字节数组转换，这是相对较慢的过程。 我们可以使用下面显示的字节操作大大提高执行速度。
 

docs/kotlin/114.md

@@ -75,7 +75,7 @@ fun main(args: Array<String>) {
 
 在上述程序中，不是使用`write()`方法，而是使用`FileWriter`的实例（对象）将文本附加到现有文件中。
 
-创建`FileWriter`对象时，我们传递文件的路径，并以`true`作为第二个参数。 `true`表示我们允许添加文件。
+创建`FileWriter`对象时，我们传递文件的路径，并以`true`作为第二个参数。`true`表示我们允许添加文件。
 
 然后，我们使用`write()`方法附加给定的`文本`并关闭文件编写器。
 

docs/kotlin/116.md

@@ -40,7 +40,7 @@ fun main(args: Array<String>) {
 [84, 104, 105, 115, 32, 105, 115, 32, 97, 13, 10, 84, 101, 115, 116, 32, 102, 105, 108, 101, 46]
 ```
 
-在上面的程序中，我们将文件的路径存储在变量 `path` 中。
+在上面的程序中，我们将文件的路径存储在变量`path`中。
 
 然后，在 try 块内部，我们使用`readAllBytes()`方法从给定的 pth 读取所有字节。
 
@@ -76,8 +76,8 @@ fun main(args: Array<String>) {
 
 在上面的程序中，我们使用了与示例 1 相同的方法从存储在`路径`中的 File 中读取所有字节。 这些字节存储在编码为的数组`中。`
 
-我们还有一个 `finalPath` ，其中要写入字节。
+我们还有一个`finalPath`，其中要写入字节。
 
-然后，我们仅使用`Files`'`write()`方法将编码的字节数组写入给定 `finalPath` 中的文件中。
+然后，我们仅使用`Files`'`write()`方法将编码的字节数组写入给定`finalPath`中的文件中。
 
 以下是等效的 Java 代码： [Java 程序，用于将 File 转换为 byte []，反之亦然](/java-programming/examples/convert-file-byte-array "Java program to convert File to byte[] and vice-versa")。
\ No newline at end of file

docs/kotlin/117.md

@@ -35,7 +35,7 @@ fun main(args: Array<String>) {
 Hello there!
 ```
 
-在上述程序中，输入流是从字符串创建的，并存储在变量`流`中。 我们还需要字符串构建器 `sb` 从流中创建字符串。
+在上述程序中，输入流是从字符串创建的，并存储在变量`流`中。 我们还需要字符串构建器`sb`从流中创建字符串。
 
 然后，我们从`InputStreamReader`创建了一个缓冲读取器 br，以从`流`中读取行。 使用 while 循环，我们读取每一行并将其附加到字符串生成器。 最后，我们关闭了 bufferedReader。
 

docs/kotlin/118.md

@@ -30,6 +30,6 @@ Hello there!
 
 在上面的程序中，我们基于给定的字符串`行`创建了`OutputStream`。 这是使用流的`write()`方法完成的。
 
-然后，我们使用`String`的构造函数（将字节数组）简单地将`OutputStream`转换为 `finalString` 。 为此，我们使用流的`toByteArray()`方法。
+然后，我们使用`String`的构造函数（将字节数组）简单地将`OutputStream`转换为`finalString`。 为此，我们使用流的`toByteArray()`方法。
 
 以下是等效的 Java 代码：[将 OutputStream 转换为 String](/java-programming/examples/convert-outputstream-string "Java program to convert OutputStream to String") 的 Java 程序。
\ No newline at end of file

docs/kotlin/12.md

@@ -44,7 +44,7 @@ result = 60
 
 上面的程序从用户那里获取输入字符串（建议阅读：[从 Kotlin 的](/kotlin-programming/input-output#input-string)中获取用户的字符串输入）。 假设用户输入了`*`。 在这种情况下，对表达式`a * b`求值，并将该值分配给变量`结果`。
 
-如果不满足任何分支条件（用户输入`+`，`-`， `*` 或`/`除外），则评估`else`分支。
+如果不满足任何分支条件（用户输入`+`，`-`，`*`或`/`除外），则评估`else`分支。
 
 * * *
 

docs/kotlin/120.md

@@ -25,7 +25,7 @@ fun main(args: Array<String>) {
 Equal
 ```
 
-在上面的程序中，我们有两个字符串 `style` 和 `style2` 。 我们仅使用相等运算符（`==`）比较两个字符串，这会将值 **Bold** 与 **Bold** 进行比较，并输出 **Equal** 。
+在上面的程序中，我们有两个字符串`style`和`style2`。 我们仅使用相等运算符（`==`）比较两个字符串，这会将值 **Bold** 与 **Bold** 进行比较，并输出 **Equal** 。
 
 * * *
 
@@ -50,7 +50,7 @@ When you run the program, the output will be:
 Equal
 ```
 
-在上面的程序中，我们有两个字符串 `style` 和 `style2` 都包含相同的世界 **Bold** 。
+在上面的程序中，我们有两个字符串`style`和`style2`都包含相同的世界 **Bold** 。
 
 如您所见，我们已经使用`equals()`方法比较字符串。 与示例 1 相似，它将值**粗体**与**粗体**进行比较。
 
@@ -79,7 +79,7 @@ Not Equal
 
 在上面的程序中，我们使用辅助方法`buildString`创建了`String`对象，而不是仅使用引号创建了字符串。
 
-我们没有使用`==`运算符，而是使用了`===`（引用相等运算符）来比较字符串。 该运算符比较`样式`和`样式 2` 本质上是否是同一对象。
+我们没有使用`==`运算符，而是使用了`===`（引用相等运算符）来比较字符串。 该运算符比较`样式`和`样式 2`本质上是否是同一对象。
 
 由于它们不是，因此**不等于**被打印在屏幕上。
 

docs/kotlin/122.md

@@ -39,12 +39,12 @@ X
 Z
 ```
 
-在上面的程序中，我们定义了一个`CustomObject`类，它带有`String`属性，即 `customProperty` 。
+在上面的程序中，我们定义了一个`CustomObject`类，它带有`String`属性，即`customProperty`。
 
 在`main()`方法中，我们创建了以 5 个对象初始化的自定义对象`列表`的数组列表。
 
-为了使用属性对列表进行排序，我们使用 `list` 的`sortedWith()`方法。 `sortedWith()`方法采用比较器`compareBy`，该比较器比较每个对象的 `customProperty` 并将其排序。
+为了使用属性对列表进行排序，我们使用`list`的`sortedWith()`方法。`sortedWith()`方法采用比较器`compareBy`，该比较器比较每个对象的`customProperty`并将其排序。
 
-然后将已排序的列表存储在变量 `sortedList` 中。
+然后将已排序的列表存储在变量`sortedList`中。
 
 这里是等效的 Java 代码： [Java 程序，用于通过属性](/java-programming/examples/sort-custom-objects-property "Java program to sort an ArrayList of custom objects by property")对自定义对象的 ArrayList 进行排序。
\ No newline at end of file

docs/kotlin/13.md

@@ -75,7 +75,7 @@ Line 4
 Line 5
 ```
 
-注意，`while`循环内的`++i`语句。 在 5 次迭代之后，变量 `i` 将增加到 6。然后，将测试表达式`i <= 5`评估为`false`，然后循环终止。
+注意，`while`循环内的`++i`语句。 在 5 次迭代之后，变量`i`将增加到 6。然后，将测试表达式`i <= 5`评估为`false`，然后循环终止。
 
 * * *
 
@@ -106,7 +106,7 @@ When you run the program, the output will be:
 sum = 5050
 ```
 
-在此，变量`和`初始化为 0，并且 `i` 初始化为 100。在 while 循环的每次迭代中，变量`和`被分配为`sum + i`，并且 `i` 的值减小 1，直到 `i` 等于 0。
+在此，变量`和`初始化为 0，并且`i`初始化为 100。在 while 循环的每次迭代中，变量`和`被分配为`sum + i`，并且`i`的值减小 1，直到`i`等于 0。
 
 ```kt
 1st iteration: sum = 0+100 = 100, i = 99
@@ -138,7 +138,7 @@ do {
 
 ### ... while 循环如何工作？
 
-`do`构造体内的代码只执行一次（无需检查 `testExpression` ）。 然后，检查测试表达式。
+`do`构造体内的代码只执行一次（无需检查`testExpression`）。 然后，检查测试表达式。
 
 如果将测试表达式评估为`true`，则执行循环体内的代码，然后再次评估测试表达式。 该过程一直进行到测试表达式被评估为`false`为止。
 

docs/kotlin/15.md

@@ -22,7 +22,7 @@ for (...) {
 }
 ```
 
-如果将 `testExpression` 评估为`true`，则将执行`break`，从而终止`for`循环。
+如果将`testExpression`评估为`true`，则将执行`break`，从而终止`for`循环。
 
 ![Kotlin break](img/883ed53898fb6ecf0fdad2042b5ff270.png)
 
@@ -52,7 +52,7 @@ fun main(args: Array<String>) {
 
 ```
 
-当 `i` 的值等于 5 时，将`if`内部的表达式`i == 5`评估为`true`，并执行`break`。 这终止了循环的[。](/kotlin-programming/for-loop "Java for Loop")
+当`i`的值等于 5 时，将`if`内部的表达式`i == 5`评估为`true`，并执行`break`。 这终止了循环的[。](/kotlin-programming/for-loop "Java for Loop")
 
 * * *
 
@@ -111,7 +111,7 @@ sum = 13
 
 Kotlin 中的标签以[标识符](/kotlin-programming/keywords-identifiers#identifiers "Kotlin identifier")开头，后跟`@`。
 
-此处， `test @` 是在循环时在外部[处标记的标签。 现在，通过在标签上使用`break`（在这种情况下为`break@test`），可以中断特定的循环。](/kotlin-programming/while-loop "Kotlin while Loop")
+此处，`test @`是在循环时在外部[处标记的标签。 现在，通过在标签上使用`break`（在这种情况下为`break@test`），可以中断特定的循环。](/kotlin-programming/while-loop "Kotlin while Loop")
 
 这是一个示例：
 

docs/kotlin/16.md

@@ -6,7 +6,7 @@
 
 假设您正在使用循环。 有时希望跳过循环的当前迭代。
 
-在这种情况下，将使用`continue`。 `continue`构造跳过了当前的循环循环，并且程序控制跳到了循环主体的末尾。
+在这种情况下，将使用`continue`。`continue`构造跳过了当前的循环循环，并且程序控制跳到了循环主体的末尾。
 
 * * *
 
@@ -25,7 +25,7 @@ while (testExpression1) {
 }
 ```
 
-如果将 `testExpression2` 评估为`true`，则将执行`continue`，在该迭代之后，它会跳过`while`循环内的所有代码。
+如果将`testExpression2`评估为`true`，则将执行`continue`，在该迭代之后，它会跳过`while`循环内的所有代码。
 
 ![How continue expression works in Kotlin?](img/fe78962e055b69a869b8de76b8ff3a34.png)
 
@@ -58,7 +58,7 @@ fun main(args: Array<String>) {
 5 Not always printed.
 ```
 
-当 `i` 的值大于 1 且小于 5 时，将执行`continue`，从而跳过执行
+当`i`的值大于 1 且小于 5 时，将执行`continue`，从而跳过执行
 
 ```kt
 println("$i Not always printed.")
@@ -127,7 +127,7 @@ sum = 31
 
 Kotlin 中的标签以[标识符](https://www.programiz.com/kotlin-programming/keywords-identifiers#identifiers "Kotlin identifier")开头，后跟`@`。
 
-在此， `outsideloop @` 是在循环时在外部[处标记的标签。 现在，通过在标签上使用`continue`（在这种情况下为`continue@outerloop`），可以跳过该迭代的特定循环代码的执行。](https://www.programiz.com/kotlin-programming/while-loop "Kotlin while Loop")
+在此，`outsideloop @`是在循环时在外部[处标记的标签。 现在，通过在标签上使用`continue`（在这种情况下为`continue@outerloop`），可以跳过该迭代的特定循环代码的执行。](https://www.programiz.com/kotlin-programming/while-loop "Kotlin while Loop")
 
 * * *
 

docs/kotlin/18.md

@@ -70,7 +70,7 @@ fun callMe() {
 
 ```
 
-要在 Kotlin 中定义功能，请使用`fun`关键字。 然后是函数的名称（[标识符](/kotlin-programming/keywords-identifiers#identifiers "Kotlin identifiers")）。 在此，函数的名称为 `callMe` 。
+要在 Kotlin 中定义功能，请使用`fun`关键字。 然后是函数的名称（[标识符](/kotlin-programming/keywords-identifiers#identifiers "Kotlin identifiers")）。 在此，函数的名称为`callMe`。
 
 在上述程序中，括号`( )`为空。 这意味着此函数不接受任何参数。 您将在本文的后面部分了解参数。
 
@@ -151,13 +151,13 @@ result = 15
 
 ### 带参数和返回值的函数如何工作？
 
-在此，在函数调用期间将类型为`Double`的两个参数 `number1` 和 `number2` 传递给`addNumbers()`函数。 这些参数称为实际参数。
+在此，在函数调用期间将类型为`Double`的两个参数`number1`和`number2`传递给`addNumbers()`函数。 这些参数称为实际参数。
 
 ```kt
 result = addNumbers(number1, number2)
 ```
 
-参数 `n1` 和 `n2` 接受传递的参数（在函数定义中）。 这些参数称为形式参数（或参数）。
+参数`n1`和`n2`接受传递的参数（在函数定义中）。 这些参数称为形式参数（或参数）。
 
 ![Passing arguments to a function in Kotlin](img/eb191255c1be3b065f0b5aac7bb9880a.png)
 
@@ -175,13 +175,13 @@ return sumInteger
 
 是 return 语句。 该代码终止`addNumbers()`功能，程序控制跳至`main()`功能。
 
-在程序中，从`addNumbers()`函数返回 `sumInteger` 。 该值分配给变量`结果`。
+在程序中，从`addNumbers()`函数返回`sumInteger`。 该值分配给变量`结果`。
 
 ![Return value from a function in Kotlin](img/276d39e8ee56ea92aff7db217a1685b4.png)
 
 注意，
 
-*   `sumInteger` 和`结果`均为`Int`类型。
+*   `sumInteger`和`结果`均为`Int`类型。
 *   函数的返回类型在函数定义中指定。
 
     ```kt

docs/kotlin/20.md

@@ -22,7 +22,7 @@
 
 函数`foo()`具有两个参数。 参数提供有默认值。 但是，通过在上述程序中传递两个参数来调用`foo()`。 因此，不使用默认参数。
 
-在`foo()`功能内，`字母`和`数字`的值分别为`'x'`和 `2` 。
+在`foo()`功能内，`字母`和`数字`的值分别为`'x'`和`2`。
 
 **情况 II：未传递所有参数**
 
@@ -32,7 +32,7 @@
 
 在此，仅一个（第一个）参数传递给`foo()`函数。 因此，第一个参数使用传递给函数的值。 但是，第二个参数`编号`将采用默认值，因为在函数调用期间未传递第二个参数。
 
-在`foo()`功能内，`字母`和`数字`的值分别为`'y'`和 `15` 。
+在`foo()`功能内，`字母`和`数字`的值分别为`'y'`和`15`。
 
 **情况 III：不传递任何参数**
 
@@ -42,7 +42,7 @@
 
 在此，不传递任何参数就调用`foo()`函数。 因此，两个参数都使用其默认值。
 
-在`foo()`功能内，`字母`和`数字`的值分别为`'a'`和 `15` 。
+在`foo()`功能内，`字母`和`数字`的值分别为`'a'`和`15`。
 
 * * *
 

docs/kotlin/23.md

@@ -79,17 +79,17 @@ class Lamp {
 }
 ```
 
-在这里，我们定义了一个名为 `Lamp` 的类。
+在这里，我们定义了一个名为`Lamp`的类。
 
-该类具有一个属性 `isOn` （以与变量相同的方式定义），并且具有两个成员函数`turnOn()`和`turnOff()`。
+该类具有一个属性`isOn`（以与变量相同的方式定义），并且具有两个成员函数`turnOn()`和`turnOff()`。
 
 **推荐读物：** [Kotlin 函数](https://kotlinlang.org/docs/reference/functions.html "Kotlin functions")
 
-在 Kotlin 中，必须初始化属性或将其声明为`abstract`（**访问：** *Kotlin 抽象类*，以了解更多信息）。 在上面的示例中， `isOn` 属性被初始化为`false`。
+在 Kotlin 中，必须初始化属性或将其声明为`abstract`（**访问：** *Kotlin 抽象类*，以了解更多信息）。 在上面的示例中，`isOn`属性被初始化为`false`。
 
 * * *
 
-类，对象，属性，成员函数等可以具有可见性修饰符。 例如， `isOn` 属性是私有的。 这意味着，只能从 `Lamp` 类内部更改 `isOn` 属性。
+类，对象，属性，成员函数等可以具有可见性修饰符。 例如，`isOn`属性是私有的。 这意味着，只能从`Lamp`类内部更改`isOn`属性。
 
 其他可见性修饰符是：
 
@@ -102,7 +102,7 @@ class Lamp {
 
 如果未指定可见性修改器，则默认为`public`。
 
-在上述程序中，`turnOn()`和`turnOff()`成员函数是`public`，而 `isOn` 属性是私有的。
+在上述程序中，`turnOn()`和`turnOff()`成员函数是`public`，而`isOn`属性是私有的。
 
 * * *
 
@@ -110,7 +110,7 @@ class Lamp {
 
 定义类时，仅定义对象的规范； 没有分配内存或存储空间。
 
-要访问在类中定义的成员，您需要创建对象。 让我们创建 `Lamp` 类的对象。
+要访问在类中定义的成员，您需要创建对象。 让我们创建`Lamp`类的对象。
 
 ```kt
 class Lamp {
@@ -136,7 +136,7 @@ fun main(args: Array<String>) {
 }
 ```
 
-该程序创建了 `Lamp` 类的两个对象 `l1` 和 `l2` 。 两个灯 `l1` 和 `l2` 的`处于`属性为`false`。
+该程序创建了`Lamp`类的两个对象`l1`和`l2`。 两个灯`l1`和`l2`的`处于`属性为`false`。
 
 * * *
 
@@ -148,7 +148,7 @@ fun main(args: Array<String>) {
 l1.turnOn()
 ```
 
-该语句为 `l1` 对象调用 `turnOn（）`函数。
+该语句为`l1`对象调用`turnOn（）`函数。
 
 让我们再举一个例子：
 
@@ -156,7 +156,7 @@ l1.turnOn()
 l2.isOn = true
 ```
 
-在这里，我们试图将`true`分配给 `l2` 对象的 `isOn` 属性。 请注意， `isOn` 属性为`private`，如果您尝试从类外部访问 `isOn` ，则会引发异常。
+在这里，我们试图将`true`分配给`l2`对象的`isOn`属性。 请注意，`isOn`属性为`private`，如果您尝试从类外部访问`isOn`，则会引发异常。
 
 * * *
 
@@ -209,13 +209,13 @@ l2 Lamp is off.
 在上面的程序中
 
 *   `Lamp`类已创建。
-*   该类具有 `isOn` 属性和三个成员函数`turnOn()`，`turnOff()`和`displayLightStatus()`。
-*   在`main()`功能中创建了`灯`类的两个对象 `l1` 和 `l2` 。
-*   在此，使用 `l1` 对象：`l1.turnOn()`调用`turnOn()`函数。 此方法将 `l1` 对象的 `isOn` 实例变量设置为`true`。
-*   并且，使用 `l2` 对象：`l1.turnOff()`调用`turnOff()`函数。 此方法将 `l2` 对象的 `isOff` 实例变量设置为`false`。
-*   然后，针对 `l1` 和 `l2` 对象调用`displayLightStatus()`函数，这些对象根据`的 On` 属性是 `true` 还是[ `false`。
+*   该类具有`isOn`属性和三个成员函数`turnOn()`，`turnOff()`和`displayLightStatus()`。
+*   在`main()`功能中创建了`灯`类的两个对象`l1`和`l2`。
+*   在此，使用`l1`对象：`l1.turnOn()`调用`turnOn()`函数。 此方法将`l1`对象的`isOn`实例变量设置为`true`。
+*   并且，使用`l2`对象：`l1.turnOff()`调用`turnOff()`函数。 此方法将`l2`对象的`isOff`实例变量设置为`false`。
+*   然后，针对`l1`和`l2`对象调用`displayLightStatus()`函数，这些对象根据`的 On`属性是`true`还是[ `false`。
 
-请注意， `isOn` 属性已初始化为该类内部的`false`。 创建该类的对象时，该对象的 `isOn` 属性将自动初始化为`false`。 因此，不需要 `l2` 对象调用`turnOff()`将 `isOn` 属性设置为`false`。
+请注意，`isOn`属性已初始化为该类内部的`false`。 创建该类的对象时，该对象的`isOn`属性将自动初始化为`false`。 因此，不需要`l2`对象调用`turnOff()`将`isOn`属性设置为`false`。
 
 例如：
 

docs/kotlin/24.md

@@ -56,7 +56,7 @@ Age = 25
 
 创建`Person`类的对象时，就像`Person`是一个函数一样，传递`"Joe"`和`25`值。
 
-这会将 `person1` 对象的`firstName`和`age`属性分别初始化为`"Joe"`和`25`。
+这会将`person1`对象的`firstName`和`age`属性分别初始化为`"Joe"`和`25`。
 
 * * *
 
@@ -97,9 +97,9 @@ First Name = Joe
 Age = 25
 ```
 
-在此，当创建 `person1` 对象时，括号内的参数 `fName` 和 `personAge` 分别接受值`"Joe"`和`25`。 但是，不使用`var`或`val`而使用 `fName` 和 `personAge` ，它们不是`Person`类的属性。
+在此，当创建`person1`对象时，括号内的参数`fName`和`personAge`分别接受值`"Joe"`和`25`。 但是，不使用`var`或`val`而使用`fName`和`personAge`，它们不是`Person`类的属性。
 
-`Person`类具有两个属性 `firstName` ，并且声明了 `age` 。
+`Person`类具有两个属性`firstName`，并且声明了`age`。
 
 创建`person1`对象时，将执行初始化程序块内的代码。 初始化程序块不仅初始化其属性，还打印它们。
 
@@ -126,7 +126,7 @@ class Person(fName: String, personAge: Int) {
 
 * * *
 
-为了区分构造函数参数和属性，使用了不同的名称（ `fName` 和 `firstName` ，以及 `personAge` 和 `age` ）。 对于构造函数参数，使用 `_firstName` 和 `_age` 更为常见。 例如：
+为了区分构造函数参数和属性，使用了不同的名称（`fName`和`firstName`，以及`personAge`和`age`）。 对于构造函数参数，使用`_firstName`和`_age`更为常见。 例如：
 
 ```kt
 class Person(_firstName: String, _age: Int) {

docs/kotlin/25.md

@@ -38,7 +38,7 @@ class Person {
 }
 ```
 
-实例化`Person`类的对象并初始化`名称`属性时，它将传递给设置器参数`值`并将`字段`设置为`值` 。
+实例化`Person`类的对象并初始化`名称`属性时，它将传递给设置器参数`值`并将`字段`设置为`值`。
 
 ```kt
 val p = Person()
@@ -126,6 +126,6 @@ Angela: actual age = 35
 Angela: pretended age = 32
 ```
 
-在这里， `actualAge` 属性按预期方式工作。
+在这里，`actualAge`属性按预期方式工作。
 
-但是，还有其他逻辑设置器可以修改 `age` 属性的值。
\ No newline at end of file
+但是，还有其他逻辑设置器可以修改`age`属性的值。
\ No newline at end of file

docs/kotlin/26.md

@@ -121,13 +121,13 @@ I play for LA Galaxy.
 
 这里，从`Person`类派生两个类`MathTeacher`和`Footballer`。
 
-`Person`类的主要构造函数声明了两个属性： `age` 和`名称`，并且它具有一个初始化程序块。 基类`Person`的初始化器块（和成员函数）可以由派生类（`MathTeacher`和`Footballer`）的对象访问。
+`Person`类的主要构造函数声明了两个属性：`age`和`名称`，并且它具有一个初始化程序块。 基类`Person`的初始化器块（和成员函数）可以由派生类（`MathTeacher`和`Footballer`）的对象访问。
 
 派生类`MathTeacher`和`Footballer`分别具有自己的成员函数`teachMaths()`和`playFootball()`。 这些功能只能从其各自类别的对象中访问。
 
 * * *
 
-创建`MathTeacher`类的对象 `t1` 时，
+创建`MathTeacher`类的对象`t1`时，
 
 ```kt
 val t1 = MathTeacher(25, "Jack")

docs/kotlin/28.md

@@ -75,7 +75,7 @@ My SSN is 23123.
 
 然后，使用`插孔`对象调用`displayJob()`方法。 请注意，`displayJob()`方法在基类中被声明为抽象，而在派生类中被重写。
 
-最后，使用`插孔`对象调用`displaySSN()`方法。 该方法是非抽象的，并且在 `Person` 类中声明（并且不在`Teacher`类中声明）。
+最后，使用`插孔`对象调用`displaySSN()`方法。 该方法是非抽象的，并且在`Person`类中声明（并且不在`Teacher`类中声明）。
 
 * * *
 

docs/kotlin/29.md

@@ -32,7 +32,7 @@ interface MyInterface {
 
 这里，
 
-*   接口 `MyInterface` 已创建。
+*   接口`MyInterface`已创建。
 *   接口具有抽象属性`测试`和抽象方法`foo()`。
 *   该接口还具有非抽象方法`hello()`。
 
@@ -63,7 +63,7 @@ class InterfaceImp : MyInterface {
 
 ```
 
-在这里，类 `InterfaceImp` 实现了 `MyInterface` 接口。
+在这里，类`InterfaceImp`实现了`MyInterface`接口。
 
 该类重写接口的抽象成员（`测试`属性和`foo()`方法）。
 
@@ -187,7 +187,7 @@ From interface B
 
 ## 解决覆盖冲突（多个接口）
 
-假设两个接口（ `A` 和 `B` ）具有同名的非抽象方法（假设`callMe()`方法）。 您在一个类中实现了这两个接口（假设 `C` ）。 现在，如果使用类 `C` 的对象调用`callMe()`方法，则编译器将引发错误。 例如，
+假设两个接口（`A`和`B`）具有同名的非抽象方法（假设`callMe()`方法）。 您在一个类中实现了这两个接口（假设`C`）。 现在，如果使用类`C`的对象调用`callMe()`方法，则编译器将引发错误。 例如，
 
 ```kt
 interface A {
@@ -257,7 +257,7 @@ From interface A
 From interface B
 ```
 
-在此，在类 `C` 中提供了`callMe()`方法的显式实现。
+在此，在类`C`中提供了`callMe()`方法的显式实现。
 
 ```kt
 class C: A, B {
@@ -268,4 +268,4 @@ class C: A, B {
 }
 ```
 
-语句`super<A>.callMe()`调用类 `A` 的`callMe()`方法。 类似地，`super<B>.callMe()`调用类`B`的`callMe()`方法。
\ No newline at end of file
+语句`super<A>.callMe()`调用类`A`的`callMe()`方法。 类似地，`super<B>.callMe()`调用类`B`的`callMe()`方法。
\ No newline at end of file

docs/kotlin/3.md

-# Kotlin Hello World-您的 Kotlin 计划
+# Kotlin HelloWorld - 您的 Kotlin 程序
 
 > 原文： [https://www.programiz.com/kotlin-programming/hello-world](https://www.programiz.com/kotlin-programming/hello-world)
 
-#### 在本文中，您将学习用 Kotlin 编写 Hello World 程序。
+#### 在本文中，您将学习用 Kotlin 编写 HelloWorld 程序。
 
 一个“你好，世界！” 是一个在屏幕上输出`Hello, World!`的简单程序。 由于它是一个非常简单的程序，因此通常用于引入一种新的编程语言。
 
@@ -12,7 +12,7 @@
 
 * * *
 
-## Kotlin：“你好，世界！” 程序
+## Kotlin：HelloWorld 程序
 
 ```kt
  // Hello World Program
@@ -35,14 +35,14 @@ Hello, World!
 
 1.  `// Hello World Program`
 
-    以`//`开头的任何行都是 Kotlin 中的注释（类似于 Java）。 注释将被编译器忽略。 它们旨在供阅读代码的人员更好地了解该程序的意图和功能。 要了解更多信息，请访问 *Kotlin 评论*。
+    以`//`开头的任何行都是 Kotlin 中的注释（类似于 Java）。 注释将被编译器忽略。 它们旨在供阅读代码的人员更好地了解该程序的意图和功能。 要了解更多信息，请访问 *Kotlin 注释*。
 2.  `fun main(args : Array<String>) { ... }`
 
     这是`main`功能，在每个 Kotlin 应用程序中都是必需的。 Kotlin 编译器开始从`main`函数执行代码。
 
-    该函数将字符串数组作为参数并返回 Unit。 您将在后面的章节中了解函数和参数。
+    该函数将字符串数组作为参数并返回`Unit`。 您将在后面的章节中了解函数和参数。
 
-    现在，请记住`main`函数是强制性函数，它是每个 Kotlin 程序的入口。 `main`功能的签名为：
+    现在，请记住`main`函数是强制性函数，它是每个 Kotlin 程序的入口。`main`功能的签名为：
 
     ```kt
     fun main(args : Array<String>) {
@@ -56,9 +56,9 @@ Hello, World!
 
 * * *
 
-## 与 Java“ Hello，World！”的比较 程序
+## 与 Java HelloWorld 程序的比较
 
-如您所知，Kotlin 可与 Java 100％互操作。 这是等效的 [Java“ Hello，World！” 程序](/java-programming/hello-world "Java Hello World")。
+如您所知，Kotlin 可与 Java 100% 互操作。 这是等效的 [Java HelloWorld 程序](/java-programming/hello-world "Java Hello World")。
 
 ```kt
 // Hello World Program
@@ -76,11 +76,11 @@ class HelloWorldKt {
 
 1.  与 Java 不同，不是必须在每个 Kotlin 程序中创建`class`。 这是因为 Kotlin 编译器为我们创建了该类。
 
-    如果使用的是 IntelliJ IDEA，请转到`Run` > `Edit Configurations`查看此类。 如果您将 Kotlin 文件命名为 **HelloWorld.kt** ，则编译器将创建 `HelloWorldKt` 类。
+    如果使用的是 IntelliJ IDEA，请转到`Run > Edit Configurations`查看此类。 如果您将 Kotlin 文件命名为`HelloWorld.kt`，则编译器将创建`HelloWorldKt`类。
 
     ![Kotlin compiler creates class automatically](img/000b1127dc181ed9170e7e7c01d30c3c.png)
 2.  `println()`函数在内部调用`System.out.println()`。
 
-    如果使用的是 IntelliJ IDEA，请将鼠标光标放在`println`旁边，然后转到`Navigate` > `Declaration`（快捷方式： **Ctrl + B** 。对于 Mac： **Cmd + B** ），这将打开`Console.kt`（声明文件）。 您可以看到`println()`函数正在内部调用`System.out.println()`。
+    如果使用的是 IntelliJ IDEA，请将鼠标光标放在`println`旁边，然后转到`Navigate` > `Declaration`（快捷方式：`Ctrl + B`。对于 Mac：`Cmd + B`），这将打开`Console.kt`（声明文件）。 您可以看到`println()`函数正在内部调用`System.out.println()`。
 
     ![console.kt declaration file in Kotlin](img/1b625c92f5ac093c8f5598f52c44067a.png)
\ No newline at end of file

docs/kotlin/30.md

@@ -82,7 +82,7 @@ fun main(args: Array<String>) {
 }
 ```
 
-上面的代码无法编译，因为我们尝试从`嵌套`类内部访问`外部`类的 `foo` 属性。
+上面的代码无法编译，因为我们尝试从`嵌套`类内部访问`外部`类的`foo`属性。
 
 为了解决此问题，您需要使用`内部`标记嵌套的类以创建内部类。 内部类带有对外部类的引用，并且可以访问外部类成员。
 

docs/kotlin/32.md

@@ -24,7 +24,7 @@ fun eval(e: Expr): Int =
         }
 ```
 
-在上述程序中，基类 `Expr` 具有两个派生类 `Const` （代表一个数字）和`和`（代表两个表达式的总和）。 在这里，当表达式时，必须为[中的默认条件使用`else`分支作为默认条件。](/kotlin-programming/when-expression "Kotlin when expression")
+在上述程序中，基类`Expr`具有两个派生类`Const`（代表一个数字）和`和`（代表两个表达式的总和）。 在这里，当表达式时，必须为[中的默认条件使用`else`分支作为默认条件。](/kotlin-programming/when-expression "Kotlin when expression")
 
 现在，如果您从`Expr`类派生新的子类，则编译器将不会检测到任何东西，因为`else`分支对其进行处理会导致错误。 如果在添加新的子类时编译器发出错误，那就更好了。
 

docs/kotlin/33.md

@@ -22,7 +22,7 @@ object SingletonExample {
 }
 ```
 
-上面的代码结合了一个类声明和该类的单个实例 `SingletonExample` 的声明。
+上面的代码结合了一个类声明和该类的单个实例`SingletonExample`的声明。
 
 对象声明可以包含属性，方法等。 但是，不允许它们具有构造函数（这很有意义）。 **为什么？**
 
@@ -92,7 +92,7 @@ window.addMouseListener(object : MouseAdapter() {
 
 （该示例摘自 [Kotlin 官方文档页面](https://kotlinlang.org/docs/reference/object-declarations.html)。）
 
-在此，声明了扩展 `MouseAdapter` 类的匿名对象。该程序重写了`mouseClicked()`和`mouseEntered()`这两个`MouseAdapter`方法。
+在此，声明了扩展`MouseAdapter`类的匿名对象。该程序重写了`mouseClicked()`和`mouseEntered()`这两个`MouseAdapter`方法。
 
 如有必要，可以为匿名对象分配名称，并将其存储在变量中。 例如，
 
@@ -141,7 +141,7 @@ Talking with people.
 I don't pray. I am an atheist.
 ```
 
-在这里，匿名对象存储在变量`无神论者`中，该变量通过`pray()`方法实现了 `Person` 类。
+在这里，匿名对象存储在变量`无神论者`中，该变量通过`pray()`方法实现了`Person`类。
 
 * * *
 

docs/kotlin/34.md

@@ -20,9 +20,9 @@ fun main(args: Array<String>) {
 
 ```
 
-在这里，我们创建了 `Person` 类的对象 `p1` 来调用`callMe()`方法。 这就是正常情况下的工作方式。
+在这里，我们创建了`Person`类的对象`p1`来调用`callMe()`方法。 这就是正常情况下的工作方式。
 
-但是，在 Kotlin 中，您还可以通过使用类名来调用`callMe()`方法，即在这种情况下使用 `Person` 。 为此，您需要通过使用`companion`关键字标记[对象声明](https://www.programiz.com/kotlin-programming/object-singleton#object-declarations "Kotlin object declaration")来创建伴随对象。
+但是，在 Kotlin 中，您还可以通过使用类名来调用`callMe()`方法，即在这种情况下使用`Person`。 为此，您需要通过使用`companion`关键字标记[对象声明](https://www.programiz.com/kotlin-programming/object-singleton#object-declarations "Kotlin object declaration")来创建伴随对象。
 
 * * *
 

docs/kotlin/35.md

@@ -8,7 +8,7 @@
 
 但是，在 Koltin 中，您还可以使用扩展功能来扩展具有新功能的类。 基本上，扩展函数是在类外部定义的类的成员函数。
 
-例如，您需要对[字符串类](/kotlin-programming/string "Kotlin String Class")使用一个方法，该方法返回删除了第一个和最后一个字符的新字符串。 `String`类中尚未提供此方法。 您可以使用扩展功能来完成此任务。
+例如，您需要对[字符串类](/kotlin-programming/string "Kotlin String Class")使用一个方法，该方法返回删除了第一个和最后一个字符的新字符串。`String`类中尚未提供此方法。 您可以使用扩展功能来完成此任务。
 
 * * *
 

docs/kotlin/36.md

@@ -21,7 +21,7 @@ fun main(args: Array<String>) {
 15
 ```
 
-实际上，`plus()`函数已重载以与各种 Kotlin 基本类型和`String`一起使用。
+实际上，`plus()`函数已重载以与各种 Kotlin 原始类型和`String`一起使用。
 
 ```kt
 // + operator for basic types

docs/kotlin/39.md

@@ -28,7 +28,7 @@ aeiou
 
 在上面的程序中，我们定义了一个数组列表`vowels_list`。 要将数组列表转换为数组，我们使用了`toTypedArray()`方法。
 
-最后，使用 `forEach()`循环打印数组的元素。
+最后，使用`forEach()`循环打印数组的元素。
 
 * * *
 

docs/kotlin/4.md

-# Kotlin 变量和基本类型
+# Kotlin 变量和原始类型
 
 > 原文： [https://www.programiz.com/kotlin-programming/variable-types](https://www.programiz.com/kotlin-programming/variable-types)
 
@@ -19,9 +19,9 @@ var language = "French"
 val score = 95
 ```
 
-本文稍后将讨论使用 `var` 和 `val` 的区别。 现在，让我们集中讨论变量声明。
+本文稍后将讨论使用`var`和`val`的区别。 现在，让我们集中讨论变量声明。
 
-在此，`语言`是类型`String`的变量，`score`是类型`Int`的变量。 您不必指定变量的类型。 Kotlin 暗中为您执行此操作。 编译器通过初始化表达式来知道这一点（在上述程序中，`“法语”` 是`String`， `95` 是整数）。 这在编程中称为类型推断。
+在此，`language`是类型`String`的变量，`score`是类型`Int`的变量。 您不必指定变量的类型。 Kotlin 暗中为您执行此操作。 编译器通过初始化表达式来知道这一点（在上述程序中，`"French"`是`String`，`95`是整数）。 这在编程中称为类型推断。
 
 但是，如果要执行以下操作，则可以显式指定类型：
 
@@ -51,7 +51,7 @@ var language           // Error
 language = "French"
 ```
 
-在此，未明确指定`语言`变量的类型，也未在声明期间初始化该变量。
+在此，未明确指定`language`变量的类型，也未在声明期间初始化该变量。
 
 ```kt
 var language: String
@@ -62,10 +62,10 @@ language = 14         // Error
 
 * * *
 
-### var 和 val 之间的区别
+### `var`和`val`之间的区别
 
-*   **val** （不可变参考）-一旦分配了值，就无法更改使用`val`关键字声明的变量。 它类似于 Java 中的*最终变量。*
-*   **var** （可变参考）-使用`var`关键字声明的变量可以稍后在程序中更改。 它对应于常规 Java 变量。
+*   `val`（不可变参考） - 一旦分配了值，就无法更改使用`val`关键字声明的变量。 它类似于 Java 中的*最终变量*。
+*   `var`（可变参考） - 使用`var`关键字声明的变量可以稍后在程序中更改。 它对应于常规 Java 变量。
 
 以下是一些示例：
 
@@ -81,7 +81,7 @@ val language = "French"
 language = "German"      // Error
 ```
 
-在上面的示例中，您无法将`语言`变量重新分配给`German`，因为该变量是使用`val`声明的。
+在上面的示例中，您无法将`language`变量重新分配给`German`，因为该变量是使用`val`声明的。
 
 * * *
 
@@ -89,7 +89,7 @@ language = "German"      // Error
 
 * * *
 
-## Kotlin 基本类型
+## Kotlin 原始类型
 
 Kotlin 是一种类似于 Java 的静态类型语言。 也就是说，在编译期间，变量的类型是已知的。 例如，
 
@@ -98,7 +98,7 @@ val language: Int
 val marks = 12.3
 ```
 
-在此，编译器在编译时间之前就知道`语言`是`Int`类型的，而`标志`是`Double`类型的。
+在此，编译器在编译时间之前就知道`language`是`Int`类型的，而`标志`是`Double`类型的。
 
 Kotlin 中的内置类型可以分类为：
 
@@ -124,8 +124,8 @@ Kotlin 中的数字类似于 Java。 有 6 种内置类型代表数字。
 
 * * *
 
-*   `Byte`数据类型的值可以从-128 到 127（8 位带符号二进制补码整数）。
-*   如果可以确定某个变量的值在[-128，127]之内，则可以使用它代替`Int`或其他整数数据类型来节省内存
+*   `Byte`数据类型的值可以从 -128 到 127（8 位带符号二进制补码整数）。
+*   如果可以确定某个变量的值在`[-128, 127]`之内，则可以使用它代替`Int`或其他整数数据类型来节省内存
 *   范例：
 
     ```kt
@@ -148,8 +148,8 @@ Kotlin 中的数字类似于 Java。 有 6 种内置类型代表数字。
 
 * * *
 
-*   `Short`数据类型的值可以从-32768 到 32767（16 位带符号二进制补码整数）。
-*   如果可以确定该变量的值在[-32768，32767]之内，则可以使用它代替其他整数数据类型来节省内存。
+*   `Short`数据类型的值可以从 -32768 到 32767（16 位带符号二进制补码整数）。
+*   如果可以确定该变量的值在`[-32768, 32767]`之内，则可以使用它代替其他整数数据类型来节省内存。
 *   例：
 
 ```kt
@@ -170,7 +170,7 @@ When you run the program, the output will be:
 
 * * *
 
-*   `Int`数据类型的值可以从`-2<sup>31</sup>`到`2<sup>31</sup>-1`（32 位带符号的二进制补码整数）。
+*   `Int`数据类型的值可以从`-2 ^ 31`到`2 ^ 31 -1`（32 位带符号的二进制补码整数）。
 *   例：
 
 ```kt
@@ -206,7 +206,7 @@ fun main(args : Array<String>) {
 
 * * *
 
-*   `Long`数据类型的值可以从`-2<sup>63</sup>`到`2<sup>63</sup>-1`（64 位带符号二进制补码整数）。
+*   `Long`数据类型的值可以从`-2 ^ 63`到`2 ^ 63 -1`（64 位带符号二进制补码整数）。
 *   例：
 
 ```kt
@@ -230,7 +230,7 @@ val distance = 10000000000  // distance variable of type Long
 
 ```
 
-同样，您可以使用大写字母 `L` 来指定变量为`Long`类型。 例如，
+同样，您可以使用大写字母`L`来指定变量为`Long`类型。 例如，
 
 ```kt
 val distance = 100L    // distance value of type Long
@@ -284,7 +284,7 @@ When you run the program, the output will be:
 
 请注意，我们在上述程序中使用了`<font face="monospace">19.5F</font>`而不是`19.5`。 这是因为`19.5`是`Double`文字，并且您无法将`Double`值分配给`Float`类型的变量。
 
-要告诉编译器将`19.5`视为`Float`，您需要最后使用 `F` 。
+要告诉编译器将`19.5`视为`Float`，您需要最后使用`F`。
 
 * * *
 
@@ -321,9 +321,9 @@ When you run the program, the output will be:
 
 #### 字符
 
-为了表示 Kotlin 中的字符，使用了 `Char` 类型。
+为了表示 Kotlin 中的字符，使用了`Char`类型。
 
-与 Java 不同，`字符`类型不能视为数字。 访问此页面以了解有关 [Java char 类型](/java-programming/variables-primitive-data-types#char)的更多信息。
+与 Java 不同，`char`类型不能视为数字。 访问此页面以了解有关 [Java `char`类型](/java-programming/variables-primitive-data-types#char)的更多信息。
 
 ```kt
 fun main(args : Array<String>) {
@@ -385,7 +385,7 @@ fun main(args : Array<String>) {
 
 ## 科特林弦
 
-在 Kotlin 中，字符串由`String`类表示。 诸如`“这是一个字符串”` 之类的字符串文字被实现为此类的实例。
+在 Kotlin 中，字符串由`String`类表示。 诸如`“这是一个字符串”`之类的字符串文字被实现为此类的实例。
 
 要详细了解字符串，请访问： *Kotlin 字符串*
 

docs/kotlin/41.md

@@ -39,12 +39,12 @@ X
 Z
 ```
 
-在上面的程序中，我们定义了一个`CustomObject`类，它带有`String`属性，即 `customProperty` 。
+在上面的程序中，我们定义了一个`CustomObject`类，它带有`String`属性，即`customProperty`。
 
 在`main()`方法中，我们创建了以 5 个对象初始化的自定义对象`列表`的数组列表。
 
-为了使用属性对列表进行排序，我们使用 `list` 的`sortedWith()`方法。 `sortedWith()`方法采用比较器`compareBy`，该比较器比较每个对象的 `customProperty` 并将其排序。
+为了使用属性对列表进行排序，我们使用`list`的`sortedWith()`方法。`sortedWith()`方法采用比较器`compareBy`，该比较器比较每个对象的`customProperty`并将其排序。
 
-然后将已排序的列表存储在变量 `sortedList` 中。
+然后将已排序的列表存储在变量`sortedList`中。
 
 这里是等效的 Java 代码： [Java 程序，用于通过属性](/java-programming/examples/sort-custom-objects-property "Java program to sort an ArrayList of custom objects by property")对自定义对象的 ArrayList 进行排序。
\ No newline at end of file

docs/kotlin/42.md

@@ -33,7 +33,7 @@ You entered: 10
 
 * * *
 
-在此示例中，创建了一个`Scanner`类的对象，即`阅读器`，它从`keyboard` （标准输入）获取用户的输入。
+在此示例中，创建了一个`Scanner`类的对象，即`阅读器`，它从`keyboard`（标准输入）获取用户的输入。
 
 然后，`nextInt()`函数读取输入的整数，直到遇到换行符`\n (Enter)`为止。 然后将整数保存在类型为`Int`的变量`整数`中。
 
@@ -73,8 +73,8 @@ You entered: 10
 
 * * *
 
-在上面的程序中，我们使用功能`readLine()`从键盘读取一行字符串。 由于`readLine()`也可以接受空值，因此 *!! 运算符*确保变量 `stringInput` 的值不为空。
+在上面的程序中，我们使用功能`readLine()`从键盘读取一行字符串。 由于`readLine()`也可以接受空值，因此 *!! 运算符*确保变量`stringInput`的值不为空。
 
-然后，使用函数`toInt()`将存储在 `stringInput` 中的字符串转换为整数值，并存储在另一个变量`整数`中。
+然后，使用函数`toInt()`将存储在`stringInput`中的字符串转换为整数值，并存储在另一个变量`整数`中。
 
 最后，使用`println()`将整数打印到输出屏幕上。
\ No newline at end of file

docs/kotlin/43.md

@@ -28,7 +28,7 @@ The sum is: 30
 
 在该程序中，类似于 Java，两个整数`10`和`20`分别存储在整数变量`首先`和`第二`中。 不必在变量声明中添加`:Int`，Kotlin 会自动分配类型（在这种情况下为`Int`）。
 
-然后，使用`+`运算符将`首先`和`第二`相加，并将其结果存储在另一个变量 `sum` 中。
+然后，使用`+`运算符将`首先`和`第二`相加，并将其结果存储在另一个变量`sum`中。
 
 最后，使用`println()`功能将`和`打印在屏幕上。
 

docs/kotlin/45.md

@@ -24,13 +24,13 @@ The ASCII value of a is: 97
 
 * * *
 
-在上述程序中，字符`a`存储在`char`变量 `ch` 中。 与 Java 相似，双引号`(" ")`用于声明字符串，而单引号`(' ')`用于声明字符。
+在上述程序中，字符`a`存储在`char`变量`ch`中。 与 Java 相似，双引号`(" ")`用于声明字符串，而单引号`(' ')`用于声明字符。
 
-现在，要查找 `ch` 的 ASCII 值，我们使用 Kotlin 的内置函数`toInt()`。 这将`Char`值转换为`Int`值。
+现在，要查找`ch`的 ASCII 值，我们使用 Kotlin 的内置函数`toInt()`。 这将`Char`值转换为`Int`值。
 
-然后将该转换后的值存储在变量 `ascii` 中。
+然后将该转换后的值存储在变量`ascii`中。
 
-最后，我们使用`println()`功能打印 `ascii` 值。
+最后，我们使用`println()`功能打印`ascii`值。
 
 * * *
 

docs/kotlin/47.md

@@ -91,14 +91,14 @@ Second number = 12.0
 
 在上面的程序中，我们使用简单的数学来交换数字，而不是使用临时变量。
 
-对于该操作，`(first - second)`的存储很重要。 首先将其存储在变量 `` 中。
+对于该操作，`(first - second)`的存储很重要。 首先将其存储在变量``中。
 
 ```kt
 first = first - second;
 first = 12.0f - 24.5f
 ```
 
-然后，我们只需在**后面加上** `第二个`（`24.5f`）-首先计算 `` （`12.0f - 24.5f`）即可交换该数字。
+然后，我们只需在**后面加上** `第二个`（`24.5f`）-首先计算``（`12.0f - 24.5f`）即可交换该数字。
 
 ```kt
 second = first + second;

docs/kotlin/48.md

@@ -30,13 +30,13 @@ Enter a number: 12
 12 is even
 ```
 
-在上面的程序中，创建了`Scanner`对象`reader`以从用户的键盘读取数字。 输入的数字然后存储在变量 `num` 中。
+在上面的程序中，创建了`Scanner`对象`reader`以从用户的键盘读取数字。 输入的数字然后存储在变量`num`中。
 
-现在，要检查 `num` 是偶数还是奇数，我们使用`%`运算符计算其余数，并检查其是否可被`2`整除。
+现在，要检查`num`是偶数还是奇数，我们使用`%`运算符计算其余数，并检查其是否可被`2`整除。
 
-为此，我们在 Java 中使用`if...else`语句。 如果`编号`可被`2`整除，则我们打印`编号`是偶数。 否则，我们打印 `num` 是奇怪的。
+为此，我们在 Java 中使用`if...else`语句。 如果`编号`可被`2`整除，则我们打印`编号`是偶数。 否则，我们打印`num`是奇怪的。
 
-我们也可以通过使用 if ... else 作为表达式来检查 `num` 是偶数还是奇数。
+我们也可以通过使用 if ... else 作为表达式来检查`num`是偶数还是奇数。
 
 * * *
 
@@ -69,6 +69,6 @@ Enter a number: 13
 
 这是 Java 中的等效代码：[检查 Java 中数字是偶数还是奇数](/java-programming/examples/even-odd "Java Program to Check Whether a Number is Even or Odd")
 
-在上述程序中，如果 `num` 被 2 整除，则返回 `"even"`。 否则，返回`"odd"`。 返回的值存储在字符串变量 `evenOdd` 中。
+在上述程序中，如果`num`被 2 整除，则返回`"even"`。 否则，返回`"odd"`。 返回的值存储在字符串变量`evenOdd`中。
 
 然后，使用`println()`将结果打印在屏幕上。
\ No newline at end of file

docs/kotlin/49.md

@@ -23,9 +23,9 @@ fun main(args: Array<String>) {
 i is vowel
 ```
 
-在上述程序中，`'i'`存储在 char 变量 `ch` 中。 在 Java 中，对字符串使用双引号`(" ")`，对于字符使用单引号`(' ')`。
+在上述程序中，`'i'`存储在 char 变量`ch`中。 在 Java 中，对字符串使用双引号`(" ")`，对于字符使用单引号`(' ')`。
 
-现在，要检查 `ch` 是否是元音，我们检查 `ch` 是否为以下任何一项：`('a', 'e', 'i', 'o', 'u')`。 与 Java 不同，这是使用`if..else`表达式而不是 if..else 语句来完成的。
+现在，要检查`ch`是否是元音，我们检查`ch`是否为以下任何一项：`('a', 'e', 'i', 'o', 'u')`。 与 Java 不同，这是使用`if..else`表达式而不是 if..else 语句来完成的。
 
 如果字母是任何元音，则返回`"vowel"`字符串。 否则，返回`"consonant"`字符串。
 
@@ -53,11 +53,11 @@ When you run the program, the output will be:
 z is consonant
 ```
 
-在上面的程序中，我们没有使用长`if`条件，而是将其替换为`when`语句。 `when`与 Java 中的`switch case`相似。
+在上面的程序中，我们没有使用长`if`条件，而是将其替换为`when`语句。`when`与 Java 中的`switch case`相似。
 
 但是，`when`不仅是一个语句，而且还是一个表达式，即我们可以从`when`语句返回并存储值。
 
-因此，在程序中，当 `ch` 是以下两种情况之一时：`('a', 'e', 'i', 'o', 'u')`，将打印元音。 否则，执行`else`部分并将辅音打印在屏幕上。
+因此，在程序中，当`ch`是以下两种情况之一时：`('a', 'e', 'i', 'o', 'u')`，将打印元音。 否则，执行`else`部分并将辅音打印在屏幕上。
 
 * * *
 

docs/kotlin/5.md

@@ -90,9 +90,9 @@ Talk is cheap. Show me the code. - Linus Torvalds
 
 ### 算术运算符实际上如何工作？
 
-假设您正在使用`+`算术运算符将两个数字 `a` 和 `b` 相加。
+假设您正在使用`+`算术运算符将两个数字`a`和`b`相加。
 
-在后台，表达式`a + b`调用`a.plus(b)`成员函数。 `plus`运算符被重载以使用`String`值和其他基本数据类型（ [Char](/kotlin-programming/variable-types#char "Kotlin Char Type") 和[布尔](/kotlin-programming/variable-types#boolean "Kotlin Boolean Type")除外）。
+在后台，表达式`a + b`调用`a.plus(b)`成员函数。`plus`运算符被重载以使用`String`值和其他基本数据类型（ [Char](/kotlin-programming/variable-types#char "Kotlin Char Type") 和[布尔](/kotlin-programming/variable-types#boolean "Kotlin Boolean Type")除外）。
 
 ```kt
 // + operator for basic types
@@ -120,7 +120,7 @@ operator fun String?.plus(other: Any?): String
 | a-b | 减去 | a。减（b） |
 | a * b | 次 | a。倍（b） |
 | a / b | div | a.div（b） |
-| a％b | 反对 | a.mod（b） |
+| a% b | 反对 | a.mod（b） |
 
 * * *
 
@@ -142,7 +142,7 @@ val age = 5
 | a-= b | a = a-b | 负分配（b） |
 | a * = b | a = a * b | a.timesAssign（b） |
 | a / = b | a = a / b | a.divAssign（b） |
-| a％= b | a = a％b | a.modAssign（b） |
+| a% = b | a = a% b | a.modAssign（b） |
 
 * * *
 

docs/kotlin/50.md

@@ -28,13 +28,13 @@ fun main(args: Array<String>) {
 3.9 is the largest number.
 ```
 
-在上述程序中，三个数字`-4.5`，`3.9`和`2.5`分别存储在变量 `n1` ， `n2` 和 `n3` 中。
+在上述程序中，三个数字`-4.5`，`3.9`和`2.5`分别存储在变量`n1`，`n2`和`n3`中。
 
 然后，为了找到最大的条件，使用 if else 语句检查以下条件
 
-*   如果 `n1` 大于或等于 `n2` 和 `n3` ，则 `n1` 最大。
-*   如果 `n2` 大于或等于 `n1` 和 `n3` ，则 `n2` 最大。
-*   否则， `n3` 最大。
+*   如果`n1`大于或等于`n2`和`n3`，则`n1`最大。
+*   如果`n2`大于或等于`n1`和`n3`，则`n2`最大。
+*   否则，`n3`最大。
 
 也可以使用`when`语句找到最大的数字。
 

docs/kotlin/51.md

@@ -69,7 +69,7 @@ root1 = -0.87+1.30i and root2 = -0.87-1.30i
 
 * * *
 
-在上述程序中，系数 `a` ， `b` 和 `c` 分别设置为 2.3、4 和 5.6。 然后，将`determinant`计算为`b<sup>2</sup> - 4ac`。
+在上述程序中，系数`a`，`b`和`c`分别设置为 2.3、4 和 5.6。 然后，将`determinant`计算为`b<sup>2</sup> - 4ac`。
 
 根据行列式的值，根的计算公式如上式所示。 注意，我们已经使用库函数 *Math.sqrt（）*计算数字的平方根。
 

docs/kotlin/52.md

@@ -33,7 +33,7 @@ fun main(args: Array<String>) {
 1900 is not a leap year.
 ```
 
-在上述程序中，给定年份 1900 存储在变量 `year` 中。
+在上述程序中，给定年份 1900 存储在变量`year`中。
 
 *   由于 1900 除以 4 也是一个世纪年（以 00 结尾），因此，年已除以 400。 由于不能被 400 整除，因此 1900 年不是 a 年。
 *   但是，如果我们将年份更改为 2000，则它可以被 4 整除，是世纪年份，也可以被 400 整除。因此，2000 是 is 年。

docs/kotlin/55.md

@@ -35,9 +35,9 @@ fun main(args: Array<String>) {
 Sum = 5050
 ```
 
-上面的程序从 1 循环到给定的 `num` （100），并将所有数字加到变量 `sum` 上。
+上面的程序从 1 循环到给定的`num`（100），并将所有数字加到变量`sum`上。
 
-与 Java 不同，在 Kotlin 中，您可以在运算符中使用*范围*（`1..num`）和*范围从 1 到 `num` 之间的数字。*
+与 Java 不同，在 Kotlin 中，您可以在运算符中使用*范围*（`1..num`）和*范围从 1 到`num`之间的数字。*
 
 以下是等效的 Java 代码：[计算自然数总和的 Java 程序](/java-programming/examples/sum-natural-numbers)
 
@@ -69,8 +69,8 @@ When you run the program, the output will be:
 Sum = 1275
 ```
 
-在上面的程序中，与 for 循环不同，我们必须在循环体内增加 `i` 的值。
+在上面的程序中，与 for 循环不同，我们必须在循环体内增加`i`的值。
 
-尽管两个程序在技术上都是正确的，但在这种情况下最好使用 for 循环。 这是因为迭代次数（最多 `num` ）是已知的。
+尽管两个程序在技术上都是正确的，但在这种情况下最好使用 for 循环。 这是因为迭代次数（最多`num`）是已知的。
 
 访问此页面以了解*如何使用递归*来查找自然数之和。
\ No newline at end of file

docs/kotlin/56.md

@@ -4,7 +4,7 @@
 
 #### 在此程序中，您将学习在 Kotlin 中使用 for 和 while 循环查找数字的阶乘。 您还将学习使用范围来解决此问题。
 
-正数 `n` 的阶乘由下式给出：
+正数`n`的阶乘由下式给出：
 
 ```kt
 factorial of n (n!) = 1 * 2 * 3 * 4 * ... * n
@@ -32,11 +32,11 @@ fun main(args: Array<String>) {
 Factorial of 10 = 3628800
 ```
 
-在此程序中，我们使用循环来循环遍历 1 至给定数字 `num` （10）之间的所有数字，并将每个数字的乘积直到 `num` 存储在 变量`阶乘`。
+在此程序中，我们使用循环来循环遍历 1 至给定数字`num`（10）之间的所有数字，并将每个数字的乘积直到`num`存储在 变量`阶乘`。
 
-与 Java 不同，在 Kotlin 中，您可以在运算符中使用*范围*（`1..num`）和*范围从 1 到 `num` 之间的数字。*
+与 Java 不同，在 Kotlin 中，您可以在运算符中使用*范围*（`1..num`）和*范围从 1 到`num`之间的数字。*
 
-另外，我们使用`长的`代替了 `int` 来存储较大的阶乘结果。
+另外，我们使用`长的`代替了`int`来存储较大的阶乘结果。
 
 但是，它仍然不足以存储较大数字（例如 100）的值。 对于不能存储在长变量中的结果，我们使用在`java.math`库中声明的`BigInteger`变量。
 
@@ -97,8 +97,8 @@ When you run the program, the output will be:
 Factorial of 5 = 120
 ```
 
-在上面的程序中，与 for 循环不同，我们必须在循环体内增加 `i` 的值。
+在上面的程序中，与 for 循环不同，我们必须在循环体内增加`i`的值。
 
-尽管两个程序在技术上都是正确的，但在这种情况下最好使用 for 循环。 这是因为迭代次数（最多 `num` ）是已知的。
+尽管两个程序在技术上都是正确的，但在这种情况下最好使用 for 循环。 这是因为迭代次数（最多`num`）是已知的。
 
 访问此页面以学习*使用递归*查找数字的阶乘。
\ No newline at end of file

docs/kotlin/57.md

@@ -70,6 +70,6 @@ When you run the program, the output will be:
 9 * 10 = 90
 ```
 
-在上面的程序中，与 for 循环不同，我们必须在循环体内增加 `i` 的值。
+在上面的程序中，与 for 循环不同，我们必须在循环体内增加`i`的值。
 
 尽管两个程序在技术上都是正确的，但在这种情况下最好使用 for 循环。 这是因为已知迭代次数（从 1 到 10）。
\ No newline at end of file

docs/kotlin/58.md

@@ -37,9 +37,9 @@ fun main(args: Array<String>) {
 First 10 terms: 0 + 1 + 1 + 2 + 3 + 5 + 8 + 13 + 21 + 34 + 
 ```
 
-在上面的程序中，第一项（ `t1` ）和第二项[ `t2` ）分别被初始化为斐波那契数列 0 和 1 的前两个项。
+在上面的程序中，第一项（`t1`）和第二项[ `t2`）分别被初始化为斐波那契数列 0 和 1 的前两个项。
 
-与 Java 不同，我们在运算符中使用*范围*和*进行迭代，直到 `n` （项数）显示存储在变量`中的前两项的和 ] t1` 。*
+与 Java 不同，我们在运算符中使用*范围*和*进行迭代，直到`n`（项数）显示存储在变量`中的前两项的和 ] t1`。*
 
 以下是等效的 Java 代码：[显示斐波那契系列的 Java 程序。](/java-programming/examples/fibonacci-series)
 
@@ -72,9 +72,9 @@ fun main(args: Array<String>) {
 
 输出与上述程序相同。
 
-在上面的程序中，与 for 循环不同，我们必须在循环体内增加 `i` 的值。
+在上面的程序中，与 for 循环不同，我们必须在循环体内增加`i`的值。
 
-尽管两个程序在技术上都是正确的，但在这种情况下最好使用 for 循环。 这是因为迭代次数（从 1 到 `n` ）是已知的。
+尽管两个程序在技术上都是正确的，但在这种情况下最好使用 for 循环。 这是因为迭代次数（从 1 到`n`）是已知的。
 
 * * *
 
@@ -105,6 +105,6 @@ Upto 100: 0 + 1 + 1 + 2 + 3 + 5 + 8 + 13 + 21 + 34 + 55 + 89 +
 
 该程序将序列显示到给定数字（100），而不是显示序列直至特定数字。
 
-为此，我们只需要比较最后两个数字（ `t1` ）与 `n` 的和即可。
+为此，我们只需要比较最后两个数字（`t1`）与`n`的和即可。
 
-如果 `t1` 小于或等于 `n` ，则打印 `t1` 。 否则，我们完成了所有条款的显示。
\ No newline at end of file
+如果`t1`小于或等于`n`，则打印`t1`。 否则，我们完成了所有条款的显示。
\ No newline at end of file

docs/kotlin/59.md

@@ -32,11 +32,11 @@ fun main(args: Array<String>) {
 G.C.D of 81 and 153 is 9
 ```
 
-这里，将要找到其 GCD 的两个数字分别存储在 `n1` 和 `n2` 中。
+这里，将要找到其 GCD 的两个数字分别存储在`n1`和`n2`中。
 
-然后，执行 while 循环，直到 `i` 小于 `n1` 和 `n2` 为止。 这样，迭代 1 到两个数字中最小的所有数字以找到 GCD。
+然后，执行 while 循环，直到`i`小于`n1`和`n2`为止。 这样，迭代 1 到两个数字中最小的所有数字以找到 GCD。
 
-如果将 `n1` 和 `n2` 都除以 `i` ，则将 `gcd` 设置为该数字。 一直进行到找到最大数（GCD）为止，该数将 `n1` 和 `n2` 均除而无余数。
+如果将`n1`和`n2`都除以`i`，则将`gcd`设置为该数字。 一直进行到找到最大数（GCD）为止，该数将`n1`和`n2`均除而无余数。
 
 与 Java 不同，您不能在条件循环中使用 for 循环来解决此问题。 以下是等效的 Java 代码：[查找两个数字的 GCD 的 Java 程序。](/java-programming/examples/hcf-gcd)
 
@@ -68,7 +68,7 @@ When you run the program, the output will be:
 G.C.D = 9
 ```
 
-这是查找 GCD 的更好方法。 在此方法中，从较大的整数中减去较小的整数，然后将结果分配给保存较大整数的变量。 继续该过程，直到 `n1` 和 `n2` 相等为止。
+这是查找 GCD 的更好方法。 在此方法中，从较大的整数中减去较小的整数，然后将结果分配给保存较大整数的变量。 继续该过程，直到`n1`和`n2`相等为止。
 
 仅当用户输入正整数时，以上两个程序才能按预期工作。 这是第二个示例的一些修改，可以找到正整数和负整数的 GCD。
 

docs/kotlin/6.md

@@ -13,7 +13,7 @@ int number1 = 55;
 long number2 = number1;    // Valid code 
 ```
 
-在这里，类型为`int`的`number1`的值会自动转换为类型`long`，并分配给变量 `number2` 。
+在这里，类型为`int`的`number1`的值会自动转换为类型`long`，并分配给变量`number2`。
 
 在科特林，
 
@@ -22,9 +22,9 @@ val number1: Int = 55
 val number2: Long = number1   // Error: type mismatch.
 ```
 
-尽管 `Long` 的大小大于`Int`，但 Kotlin 不会自动将 `Int` 转换为 `Long` 。
+尽管`Long`的大小大于`Int`，但 Kotlin 不会自动将`Int`转换为`Long`。
 
-相反，您需要明确使用` toLong()`（以转换为 `Long` 类型）。 Kotlin 这样做是为了确保类型安全以避免意外。
+相反，您需要明确使用` toLong()`（以转换为`Long`类型）。 Kotlin 这样做是为了确保类型安全以避免意外。
 
 ```kt
 val number1: Int = 55

docs/kotlin/60.md

@@ -34,15 +34,15 @@ fun main(args: Array<String>) {
 The LCM of 72 and 120 is 360.
 ```
 
-在此程序中，将找到其 LCM 的两个数字分别存储在变量 `n1` 和 `n2` 中。
+在此程序中，将找到其 LCM 的两个数字分别存储在变量`n1`和`n2`中。
 
-然后，我们最初将 `lcm` 设置为两个数字中的最大值。 这是因为 LCM 不能小于最大数量。
+然后，我们最初将`lcm`设置为两个数字中的最大值。 这是因为 LCM 不能小于最大数量。
 
-与 Java 类似，在无限 while 循环（`while(true)`）中，我们检查 `lcm` 是否完美地划分了 `n1` 和 `n2` 。
+与 Java 类似，在无限 while 循环（`while(true)`）中，我们检查`lcm`是否完美地划分了`n1`和`n2`。
 
 如果是这样，我们已经找到 LCM。 我们打印 LCM 并使用`break`语句退出 while 循环。
 
-否则，我们将 `lcm` 加 1，然后重新测试除数条件。
+否则，我们将`lcm`加 1，然后重新测试除数条件。
 
 这是等效的 Java 代码：[查找两个数字](/java-programming/examples/lcm "How to find LCM of two numbers in Java?")的 LCM 的 Java 程序。
 
@@ -79,4 +79,4 @@ fun main(args: Array<String>) {
 
 该程序的输出与示例 1 相同。
 
-在这里，在 while 循环内，我们计算了两个数字的 GCD- `n1` 和 `n2` 。 计算后，我们使用上面的公式来计算 LCM。
\ No newline at end of file
+在这里，在 while 循环内，我们计算了两个数字的 GCD- `n1`和`n2`。 计算后，我们使用上面的公式来计算 LCM。
\ No newline at end of file

docs/kotlin/62.md

@@ -28,10 +28,10 @@ Number of digits: 7
 
 在此程序中，将循环 while 循环，直到测试表达式`num != 0`的值为 0（假）。
 
-*   第一次迭代后， `num` 将除以 10，其值将为 345。然后，`计数`增至 1。
-*   在第二次迭代后， `n` um 的值将为 34，并且`计数`递增为 2。
-*   在第三次迭代后， `num` 的值将为 3，并且`计数`增至 3。
-*   第四次迭代后， `num` 的值将为 0，并且`计数`增至 4。
+*   第一次迭代后，`num`将除以 10，其值将为 345。然后，`计数`增至 1。
+*   在第二次迭代后，`n` um 的值将为 34，并且`计数`递增为 2。
+*   在第三次迭代后，`num`的值将为 3，并且`计数`增至 3。
+*   第四次迭代后，`num`的值将为 0，并且`计数`增至 4。
 *   然后将测试表达式评估为 false 并终止循环。
 
 以下是等效的 Java 代码： [Java 程序，用于对整数](/java-programming/examples/digits-count "Java Program to Count Number of Digits in an Integer")中的位数进行计数
\ No newline at end of file

docs/kotlin/63.md

@@ -29,12 +29,12 @@ Reversed Number: 4321
 
 在此程序中，while 循环用于按以下步骤反转数字：
 
-*   首先，将 `num` 除以 10 的余数存储在变量`数字`中。 现在，`数字`包含`数字`的最后一位，即 4。
+*   首先，将`num`除以 10 的余数存储在变量`数字`中。 现在，`数字`包含`数字`的最后一位，即 4。
     `数字`然后将其乘以 10 后乘以反向。 10 在倒序数字中添加一个新位置。 十分之一乘以 10 可得到第十位，十分之一则可得到百分数，依此类推。 在这种情况下，将`反转为`包含 0 * 10 + 4 =4。然后
-    `num` 除以 10，因此现在它仅包含前三个数字：123。
+    `num`除以 10，因此现在它仅包含前三个数字：123。
 *   在第二次迭代后，`数字`等于 3，`反转了`等于 4 * 10 + 3 = 43，并且`编号` = 12
 *   在第三次迭代后，`数字`等于 2，`反转了`等于 43 * 10 + 2 = 432，并且`编号` = 1
 *   在第四次迭代后，`数字`等于 1，`反转了`等于 432 * 10 +1 = 4321，并且`编号` = 0
-*   现在 `num` = 0，因此测试表达式`num != 0`失败并且 while 循环退出。 颠倒的 `` 已经包含颠倒的数字 4321。
+*   现在`num` = 0，因此测试表达式`num != 0`失败并且 while 循环退出。 颠倒的``已经包含颠倒的数字 4321。
 
 以下是等效的 Java 代码：[反转数字的 Java 程序](/java-programming/examples/reverse-number "Java Program to reverse a number")
\ No newline at end of file

docs/kotlin/64.md

@@ -31,7 +31,7 @@ Answer = 81
 
 使用 while 循环，我们继续将`结果`与`基数`相乘，直到`指数`变为零。
 
-在这种情况下，我们将`结果`乘以基数总共四次，因此`结果` = 1 * 3 * 3 * 3 * 3 =81。我们还需要强制转换`基数` 到`Long`，因为`结果`仅接受`Long`，而 Kotlin 专注于类型安全。
+在这种情况下，我们将`结果`乘以基数总共四次，因此`结果` = 1 * 3 * 3 * 3 * 3 =81。我们还需要强制转换`基数`到`Long`，因为`结果`仅接受`Long`，而 Kotlin 专注于类型安全。
 
 但是，与 Java 中一样，如果指数为负，则以上代码将不起作用。 为此，您需要在 Kotlin 中使用 pow（）函数
 

docs/kotlin/65.md

@@ -46,12 +46,12 @@ fun main(args: Array<String>) {
 
 在这个程序中
 
-*   首先，给定数字（ `num` ）的值存储在另一个整数变量 <samp>originalInteger</samp> 中。 这是因为，我们需要在最后比较反向编号和原始编号的值。
+*   首先，给定数字（`num`）的值存储在另一个整数变量 <samp>originalInteger</samp> 中。 这是因为，我们需要在最后比较反向编号和原始编号的值。
 *   然后，使用 while 循环循环遍历 num，直到等于 0。
     *   在每次迭代中，`编号`的最后一位存储在`余数`中。
-    *   然后，将`余数`添加到 `reversedInteger` ，以便将其添加到下一个位置值（乘以 10）。
-    *   然后，除以 10 后，从 `num` 中删除最后一位数字。
-*   最后，比较 `reversedInteger` 和 `originalInteger` 。 如果相等，则为回文数。 如果不是，则不是。
+    *   然后，将`余数`添加到`reversedInteger`，以便将其添加到下一个位置值（乘以 10）。
+    *   然后，除以 10 后，从`num`中删除最后一位数字。
+*   最后，比较`reversedInteger`和`originalInteger`。 如果相等，则为回文数。 如果不是，则不是。
 
 以下是执行的步骤：
 

docs/kotlin/66.md

@@ -31,11 +31,11 @@ fun main(args: Array<String>) {
 29 is a prime number.
 ```
 
-与 Java 一样，在上述程序中，for 循环用于确定给定数字 `num` 是否为素数。 我们只需要遍历 `num` 的 2 到一半，因为没有数字可被其一半以上的整数整除。
+与 Java 一样，在上述程序中，for 循环用于确定给定数字`num`是否为素数。 我们只需要遍历`num`的 2 到一半，因为没有数字可被其一半以上的整数整除。
 
 在 for 循环内，我们检查该数字是否可被给定范围`(2..num/2)`中的任何数字整除。 如果是，则将`标志`设置为`true`，我们就跳出了循环。 这确定`编号`不是素数。
 
-如果 `num` 不能被任何数整除，则`标志`为 false，而 `num` 为质数。
+如果`num`不能被任何数整除，则`标志`为 false，而`num`为质数。
 
 以下是等效的 Java 代码：[用于检查素数](/java-programming/examples/prime-number "Java Program to Check Whether a Number is Prime or Not")的 Java 程序
 
@@ -70,6 +70,6 @@ When you run the program, the output will be:
 33 is not a prime number.
 ```
 
-在上面的程序中，使用 while 循环代替 for 循环。 循环一直运行到`i <= num/2`为止。 在每次迭代中，检查 `num` 是否除以 `i` ，并将 `i` 的值增加 1。
+在上面的程序中，使用 while 循环代替 for 循环。 循环一直运行到`i <= num/2`为止。 在每次迭代中，检查`num`是否除以`i`，并将`i`的值增加 1。
 
 访问此页面以了解如何[显示两个时间间隔](/kotlin-programming/examples/prime-number-interval "Display all prime numbers between two intervals ")之间的所有素数。
\ No newline at end of file

docs/kotlin/68.md

@@ -4,7 +4,7 @@
 
 #### 在此程序中，您将学习检查给定的数字是否为阿姆斯壮数字。 您将通过在 Kotlin 中使用 while 循环学习如何做到这一点。
 
-一个正整数称为阿姆斯特朗数 `n` ，如果
+一个正整数称为阿姆斯特朗数`n`，如果
 
 ```kt
 abcd... = an + bn + cn + dn + ...
@@ -47,12 +47,12 @@ fun main(args: Array<String>) {
 371 is an Armstrong number.
 ```
 
-*   首先，给定数字（`数字`）的值存储在另一个整数变量 `originalNumber` 中。 这是因为，我们需要在最后比较最终编号和原始编号的值。
-*   然后，使用 while 循环循环遍历 `originalNumber` ，直到等于 0。
+*   首先，给定数字（`数字`）的值存储在另一个整数变量`originalNumber`中。 这是因为，我们需要在最后比较最终编号和原始编号的值。
+*   然后，使用 while 循环循环遍历`originalNumber`，直到等于 0。
     *   在每次迭代中，`编号`的最后一位存储在`余数`中。
     *   然后，使用`Math.pow()`功能将`余数`乘以 3（数字位数），并将其添加到`结果`中。
         此处，`余下的`被转换为`Double`，因为`pow`仅接受`Double`参数，并且其值再次转换回`Int`
-    *   然后，除以 10 后，从 `originalNumber` 中删除最后一位数字。
+    *   然后，除以 10 后，从`originalNumber`中删除最后一位数字。
 *   最后，比较`结果`和`编号`。 如果相等，则为阿姆斯壮数。 如果不是，则不是。
 
 以下是等效的 Java 代码：[用于检查 Armstrong 编号](/java-programming/examples/armstrong-number "Java Program to Check Armstrong Number")的 Java 程序
@@ -93,7 +93,7 @@ fun main(args: Array<string>) {
 
 在此程序中，我们使用了两个 while 循环。 第一个 while 循环用于计算`数字`中的位数。
 
-然后，将 `originalNumber` 恢复为给定的`数字`。
+然后，将`originalNumber`恢复为给定的`数字`。
 
 然后，第二个 while 循环检查数字是否为 armstrong。
 

docs/kotlin/69.md

@@ -4,7 +4,7 @@
 
 #### 在此程序中，您将学习在 Kotlin 中显示两个给定间隔（低和高）之间的所有阿姆斯壮数字。
 
-一个正整数称为阿姆斯特朗数 `n` ，如果
+一个正整数称为阿姆斯特朗数`n`，如果
 
 ```kt
 abcd... = an + bn + cn + dn + ...

docs/kotlin/70.md

@@ -42,7 +42,7 @@ fun checkPrimeNumber(num: Int): Boolean {
 23 29 31 37 41 43 47 
 ```
 
-在上面的程序中，我们创建了一个名为`checkPrimeNumber()`的函数，该函数采用参数 `num` 并返回布尔值。
+在上面的程序中，我们创建了一个名为`checkPrimeNumber()`的函数，该函数采用参数`num`并返回布尔值。
 
 如果数字是素数，则返回`true`。 如果不是，则返回`false`。
 

docs/kotlin/71.md

@@ -52,7 +52,7 @@ fun checkArmstrong(num: Int): Boolean {
 1634 8208 9474 54748 92727 93084 
 ```
 
-在上面的程序中，我们创建了一个名为`checkArmstrong()`的函数，该函数采用参数 `num` 并返回布尔值。
+在上面的程序中，我们创建了一个名为`checkArmstrong()`的函数，该函数采用参数`num`并返回布尔值。
 
 如果数字是 armstrong，则返回`true`。 如果不是，则返回`false`。
 

docs/kotlin/72.md

@@ -27,6 +27,6 @@ Factors of 60 are: 1 2 3 4 5 6 10 12 15 20 30 60
 
 在上述程序中，要查找其因素的编号存储在变量`编号`中（60）。
 
-`for`循环从 1 迭代到`数字`。 在每次迭代中，检查`编号`是否可被 `i` 完全整除（ `i` 是`数字`的因数）和 `i` 的值增加 1。
+`for`循环从 1 迭代到`数字`。 在每次迭代中，检查`编号`是否可被`i`完全整除（`i`是`数字`的因数）和`i`的值增加 1。
 
 以下是等效的 Java 代码：[显示数字因子的 Java 程序](/java-programming/examples/factors-number "Java Program to Display Factors of a Number")
\ No newline at end of file

docs/kotlin/75.md

@@ -37,8 +37,8 @@ Sum = 210
 
 `编号`（20）被添加到`addNumbers(19)`的结果中。
 
-在从`addNumbers()`到`addNumbers()`的下一个函数调用中，传递了 19，该值被添加到`addNumbers(18)`的结果中。 该过程一直持续到 `num` 等于 0。
+在从`addNumbers()`到`addNumbers()`的下一个函数调用中，传递了 19，该值被添加到`addNumbers(18)`的结果中。 该过程一直持续到`num`等于 0。
 
-当 `num` 等于 0 时，没有递归调用，这将整数和返回给`main()`函数。
+当`num`等于 0 时，没有递归调用，这将整数和返回给`main()`函数。
 
 以下是等效的 Java 代码：[使用递归](/java-programming/examples/sum-natural-numbers-recursion "Java Program to Find Sum of Natural Numbers using Recursion")查找自然数之和的 Java 程序
\ No newline at end of file

docs/kotlin/76.md

@@ -41,9 +41,9 @@ Factorial of 6 = 720
 
 由于 6 大于或等于 1，因此将 6 与`multiplyNumbers()`的结果相乘，其中传递了 5（数字-1）。 由于是从同一函数调用的，因此它是递归调用。
 
-在每个递归调用中，参数 `n` um 的值减小 1，直到 `num` 小于 1。
+在每个递归调用中，参数`n` um 的值减小 1，直到`num`小于 1。
 
-当 `num` 的值小于 1 时，将没有递归调用。
+当`num`的值小于 1 时，将没有递归调用。
 
 每个递归调用都会返回给我们：
 

docs/kotlin/77.md

@@ -36,7 +36,7 @@ G.C.D of 366 and 60 is 6.
 在上面的程序中，递归函数被调用直到 n2 为 0。最后，n1 的值是给定两个数字的 GCD 或 HCF。
 
 <caption>Execution Steps</caption>
-| 没有。 | 递归调用 | n1 | n2 | n1％n2 |
+| 没有。 | 递归调用 | n1 | n2 | n1% n2 |
 | --- | --- | --- | --- | --- |
 | 1 | hcf（366，60） | 366 | 60 | 6 |
 | 2 | hcf（60，6） | 60 | 6 | 0 |

docs/kotlin/83.md

@@ -26,7 +26,7 @@ fun main(args: Array<String>) {
 The average is: 27.69
 ```
 
-在上面的程序中， `numArray` 存储要求平均值的浮点值。
+在上面的程序中，`numArray`存储要求平均值的浮点值。
 
 然后，要计算`平均值`，我们首先需要计算数组中所有元素的`和`。 这是使用 Java 中的 for-each 循环完成的。
 

docs/kotlin/86.md

@@ -40,9 +40,9 @@ Sum of two matrices is:
 10    8    6 
 ```
 
-在上面的程序中，两个矩阵存储在 2d 数组中，即 `firstMatrix` 和 `secondMatrix` 。 我们还定义了行数和列数，并将它们分别存储在变量`行`和`列`中。
+在上面的程序中，两个矩阵存储在 2d 数组中，即`firstMatrix`和`secondMatrix`。 我们还定义了行数和列数，并将它们分别存储在变量`行`和`列`中。
 
-然后，我们初始化给定行和列的新数组，称为 `sum` 。 该矩阵数组存储给定矩阵的加法。
+然后，我们初始化给定行和列的新数组，称为`sum`。 该矩阵数组存储给定矩阵的加法。
 
 我们遍历两个数组的每个索引以添加和存储结果。
 

docs/kotlin/9.md

@@ -126,7 +126,7 @@ You entered: Hmm, interesting!
 import java.util.Scanner 
 ```
 
-然后，您需要从此类创建`Scanner` 对象。
+然后，您需要从此类创建`Scanner`对象。
 
 ```kt
 val reader = Scanner(System.`in`) 

docs/kotlin/90.md

@@ -28,11 +28,11 @@ fun main(args: Array<String>) {
 Frequency of e = 4
 ```
 
-在上述程序中，使用字符串方法`length()`查找给定字符串 `str` 的长度。
+在上述程序中，使用字符串方法`length()`查找给定字符串`str`的长度。
 
-我们使用`charAt()`函数遍历字符串中的每个字符，该函数获取索引（ `i` ）并返回给定索引中的字符。
+我们使用`charAt()`函数遍历字符串中的每个字符，该函数获取索引（`i`）并返回给定索引中的字符。
 
-我们将每个字符与给定字符 `ch` 进行比较。 如果匹配，我们将`频率`的值增加 1。
+我们将每个字符与给定字符`ch`进行比较。 如果匹配，我们将`频率`的值增加 1。
 
 最后，我们获得了一个以`频率`存储的字符的总出现次数，并将其打印出来。
 

docs/kotlin/93.md

@@ -35,13 +35,13 @@ fun add(n1: Complex, n2: Complex): Complex {
 Sum = 5.7 + 9.5i
 ```
 
-在上面的程序中，我们创建了一个具有两个成员变量的类`Complex`： `real` 和 `imag` 。 顾名思义，`实数`存储复数的实数部分， `imag` 存储虚数部分。
+在上面的程序中，我们创建了一个具有两个成员变量的类`Complex`：`real`和`imag`。 顾名思义，`实数`存储复数的实数部分，`imag`存储虚数部分。
 
-`Complex`类具有一个构造函数，用于初始化 `real` 和 `imag` 的值。
+`Complex`类具有一个构造函数，用于初始化`real`和`imag`的值。
 
 我们还创建了一个新的静态函数`add()`，该函数将两个复数作为参数并将结果作为复数返回。
 
-在`add()`方法内部，我们只添加复数 `n1` 和 `n2` 的实部和虚部，将其存储在新变量 `temp` 中，然后返回[ `temp` 。
+在`add()`方法内部，我们只添加复数`n1`和`n2`的实部和虚部，将其存储在新变量`temp`中，然后返回[ `temp`。
 
 然后，在调用函数`main()`中，我们使用`printf()`函数进行打印。
 

docs/kotlin/99.md

@@ -20,9 +20,9 @@ fun main(args: Array<String>) {
 1.3457
 ```
 
-在上面的程序中，我们使用 format（）方法将给定的浮点数 `num` 打印到小数点后 4 位。 小数点后 4 位格式为`.4f.`
+在上面的程序中，我们使用 format（）方法将给定的浮点数`num`打印到小数点后 4 位。 小数点后 4 位格式为`.4f.`
 
-这意味着，仅在**点**之后打印最多 4 个位置（小数位），并且 `f` 表示打印浮点数。
+这意味着，仅在**点**之后打印最多 4 个位置（小数位），并且`f`表示打印浮点数。
 
 * * *
 
@@ -47,7 +47,7 @@ When you run the program, the output will be:
 1.346
 ```
 
-在上述程序中，我们使用`DecimalFormat`类将给定数字 `num` 舍入。
+在上述程序中，我们使用`DecimalFormat`类将给定数字`num`舍入。
 
 我们使用＃模式`#.###`声明格式。 这意味着，我们希望 num 最多 3 个小数位。 我们还将舍入模式设置为`Ceiling`，这将导致最后一个给定的位置被舍入到下一个数字。