Skip to content

Z
zetcode-zh

OpenDocCN / zetcode-zh
9 个月 前同步成功

通知 2
Star 157
Fork 40
Z
zetcode-zh

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 722256e4 编写于 作者: W wizardforcel
浏览文件
操作

2019-11-10 00:14:54

上级 61fa4696
隐藏空白更改
内联 并排
Showing with 577 addition and 577 deletion
docs/kotlin/35.md
浏览文件 @ 722256e4
......@@ -12,21 +12,21 @@ Kotlin 由 JetBrains 创建。 Kotlin 是面向对象的函数式编程语言。
从官方的 Github [存储库](https://github.com/JetBrains/kotlin)中，我们从发行链接下载 Kotlin。 它包含在 ZIP 存档中。 （Kotlin 内置在 IntelliJ IDEA IDE 中。）
```
```kt
$ unzip kotlin-compiler-1.2.21.zip
```
我们解压缩档案。
```
```kt
$ mv kotlinc ~/bin/
```
我们将目录移动到我们选择的目的地。
```
```kt
$ export PATH=$PATH:~/bin/kotlinc/bin/
```
......@@ -39,7 +39,7 @@ $ export PATH=$PATH:~/bin/kotlinc/bin/
`hello.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -51,14 +51,14 @@ fun main(args: Array<String>) {
Kotlin 源文件的扩展名为`.kt`。 请注意，在 Kotlin 中，我们不必使用分号。
```
```kt
package com.zetcode
```
源文件可以以`package`声明开头。 包用于组织类型。 与 Java 不同，Kotlin 不需要软件包来匹配目录结构。 但是，这样做是一个好习惯。
```
```kt
fun main(args: Array<String>) {
println("Hello, World!")
......@@ -72,14 +72,14 @@ fun main(args: Array<String>) {
我们将从命令行编译并运行程序。
```
```kt
$ kotlinc hello.kt
```
使用`kotlinc`编译器，我们可以编译源代码。
```
```kt
$ ls com/zetcode/
HelloKt.class
......@@ -87,7 +87,7 @@ HelloKt.class
编译器在`com/zetcode`子文件夹中创建`HelloKt.class`。
```
```kt
$ kotlin com.zetcode.HelloKt
Hello, World!
......@@ -99,14 +99,14 @@ Hello, World!
接下来，我们将展示如何将 Kotlin 程序打包到 Java JAR 文件中。
```
```kt
$ kotlinc hello.kt -include-runtime -d hello.jar
```
使用`-include-runtime`选项，我们将 Kotlin 运行时包含在生成的 JAR 文件中。
```
```kt
$ java -jar hello.jar
Hello, World!
......
docs/kotlin/36.md
浏览文件 @ 722256e4
......@@ -16,7 +16,7 @@ Kotlin 中有两种类型的变量：只读和可变。 只读变量（或常量
Kotlin 可以从分配的右侧推断变量的数据类型。 仅当推迟分配时，数据类型才是必需的。
```
```kt
val word = "cloud"
val word: String = "cloud"
......@@ -30,7 +30,7 @@ val word: String = "cloud"
`KotlinVariables.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -49,14 +49,14 @@ fun main(args: Array<String>) {
有一个只读变量和一个可变变量。
```
```kt
val word = "influence"
```
使用`val`关键字，我们定义了一个只读变量。 其值以后无法在程序中更改。 数据类型为 String，这是从赋值右侧的字符串文字推断出来的。
```
```kt
var word2 = "sunshine"
println(word2)
......@@ -67,7 +67,7 @@ println(word2)
使用`var`关键字，我们定义了一个可变变量。 稍后在程序中修改变量的值。
```
```kt
influence
sunshine
rain
......@@ -82,7 +82,7 @@ rain
`KotlinVariableDeffered.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -99,21 +99,21 @@ fun main(args: Array<String>) {
该示例从用户读取输入。
```
```kt
val input: String?
```
我们声明一个`String`数据类型的变量。 后面的问号告诉 Kotlin 该变量可以为 null。 这次必须显式提供数据类型。
```
```kt
print("Enter something: ")
```
我们向用户打印提示。
```
```kt
input = readLine()
```
......@@ -126,7 +126,7 @@ input = readLine()
`KotlinProperties.kt`
```
```kt
package com.zetcode
class Person {
......@@ -152,7 +152,7 @@ fun main(args: Array<String>) {
在示例中，我们有一个`Person`类，具有两个属性：`name`和`age`。
```
```kt
var name:String = ""
var age:Int = 0
......@@ -160,7 +160,7 @@ var age:Int = 0
我们有两个可变属性。
```
```kt
override fun toString(): String {
return "Person(name='$name', age=$age)"
}
......@@ -169,7 +169,7 @@ override fun toString(): String {
我们重写`toString()`方法以获得`Person`对象的字符串表示形式。
```
```kt
val p1 = Person()
p1.name = "Peter"
p1.age = 23
......@@ -178,7 +178,7 @@ p1.age = 23
创建一个`Person`对象。 我们设置两个属性。
```
```kt
Person(name='Peter', age=23)
```
......
docs/kotlin/37.md
浏览文件 @ 722256e4
......@@ -18,7 +18,7 @@
`KotlinSignOperatorsEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -34,7 +34,7 @@ fun main(args: Array<String>) {
`KotlinMinusSignEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -53,21 +53,21 @@ fun main(args: Array<String>) {
赋值运算符`=`将值赋给变量。 变量是值的占位符。 在数学中，=运算符具有不同的含义。 在等式中，`=`运算符是一个相等运算符。 等式的左边等于右边的等式。
```
```kt
val x = 1
```
在这里，我们为`x`变量分配一个数字。
```
```kt
x = x + 1
```
这个表达式在数学上没有意义，但是在编程中是合法的。 该表达式将`x`变量加 1。 右边等于 2，并且 2 分配给`x`。
```
```kt
3 = x
```
......@@ -78,7 +78,7 @@ x = x + 1
扩充赋值运算符是由两个运算符组成的速记运算符。 增强的赋值运算符在其他编程语言中也称为复合赋值运算符。
```
```kt
a = a + 3
a += 3
......@@ -88,7 +88,7 @@ a += 3
Kotlin 扩充分配运算符为：
```
```kt
+= -= *= /= %=
```
......@@ -97,7 +97,7 @@ Kotlin 扩充分配运算符为：
`KotlinAugmentedAssignmentOperatorsEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -118,7 +118,7 @@ fun main(args: Array<String>) {
我们使用`+=`和`*=`复合运算符。
```
```kt
var a = 1
a = a + 1
......@@ -126,21 +126,21 @@ a = a + 1
`a`变量被初始化为 1。 使用非速记符号将值 1 添加到变量。
```
```kt
a += 5
```
使用`+=`复合运算符，将 5 加到 a 变量中。 该语句等于`a = a + 5`。
```
```kt
a *= 3
```
使用`*=`运算符，将 a 乘以 3。该语句等于`a = a * 3`。
```
```kt
2
7
21
......@@ -155,7 +155,7 @@ a *= 3
`KotlinConcatenateStringsEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -168,14 +168,14 @@ fun main(args: Array<String>) {
我们将三个字符串连接在一起。
```
```kt
println("Return " + "of " + "the king.")
```
字符串用`+`运算符连接。
```
```kt
println("Return".plus(" of").plus(" the king."))
```
......@@ -186,7 +186,7 @@ println("Return".plus(" of").plus(" the king."))
将值递增或递减一个是编程中的常见任务。 Kotlin 为此有两个方便的运算符：`++`和`--`。
```
```kt
x++
x = x + 1
...
......@@ -199,7 +199,7 @@ y = y - 1
`KotlinIncDecEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -219,7 +219,7 @@ fun main(args: Array<String>) {
在上面的示例中，我们演示了两个运算符的用法。
```
```kt
int x = 6
x++
......@@ -229,7 +229,7 @@ x++
将`x`变量初始化为 6。然后将`x`递增两次。 现在变量等于 8。
```
```kt
x--
```
......@@ -252,7 +252,7 @@ x--
`KotlinArithmeticOperatorsEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -278,7 +278,7 @@ fun main(args: Array<String>) {
在前面的示例中，我们使用加法，减法，乘法，除法和余数运算。 这些都是数学所熟悉的。
```
```kt
val rem = c % a
```
......@@ -289,7 +289,7 @@ val rem = c % a
`KotlinDivisionEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -305,21 +305,21 @@ fun main(args: Array<String>) {
在前面的示例中，我们将两个数字相除。
```
```kt
val c = 5 / 2
```
在这段代码中，我们完成了整数除法。 除法运算的返回值为整数。 当我们将两个整数相除时，结果是一个整数。
```
```kt
val d = 5 / 2.0
```
如果值之一是 double 或 float，则执行浮点除法。 在我们的例子中，第二个操作数是双精度数，因此结果是双精度数。
```
```kt
2
2.5
......@@ -341,7 +341,7 @@ val d = 5 / 2.0
`KotlinBooleanExpEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -362,7 +362,7 @@ fun main(args: Array<String>) {
许多表达式导致布尔值。 例如，在条件语句中使用布尔值。
```
```kt
println(x == y)
println(y > x)
......@@ -370,7 +370,7 @@ println(y > x)
关系运算符始终导致布尔值。 这两行分别显示 false 和 true。
```
```kt
if (y > x) {
println("y is greater than x")
......@@ -384,7 +384,7 @@ if (y > x) {
`KotlinAndOperatorEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -404,7 +404,7 @@ fun main(args: Array<String>) {
该代码示例显示了逻辑和（& &）运算符。 仅当两个操作数均为 true 时，它的评估结果为 true。
```
```kt
true
false
false
......@@ -418,7 +418,7 @@ false
`KotlinOrOperatorEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -438,7 +438,7 @@ fun main(args: Array<String>) {
如果运算符的任一侧为真，则操作的结果为真。
```
```kt
true
true
true
......@@ -452,7 +452,7 @@ false
`KotlinNegationEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -466,7 +466,7 @@ fun main(args: Array<String>) {
该示例显示了否定运算符的作用。
```
```kt
false
true
true
......@@ -492,7 +492,7 @@ true
`KotlinComparisonOperatorsEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -523,7 +523,7 @@ fun main(args: Array<String>) {
按位操作在两个数字之间进行逐位比较。 仅当操作数中的两个对应位均为 1 时，位位置的结果才为 1。
```
```kt
00110
& 00011
= 00010
......@@ -532,7 +532,7 @@ fun main(args: Array<String>) {
第一个数字是二进制符号 6，第二个数字是 3，结果是 2。
```
```kt
println(6 and 3) // prints 2
println(3 and 6) // prints 2
......@@ -540,7 +540,7 @@ println(3 and 6) // prints 2
按位或操作在两个数字之间进行逐位比较。 如果操作数中的任何对应位为 1，则位位置的结果为 1。
```
```kt
00110
| 00011
= 00111
......@@ -549,7 +549,7 @@ println(3 and 6) // prints 2
结果为`00110`或十进制 7。
```
```kt
println(6 or 3) // prints 7
println(3 or 6) // prints 7
......@@ -561,7 +561,7 @@ println(3 or 6) // prints 7
`KotlinIsOperatorEx.kt`
```
```kt
package com.zetcode
open class Base
......@@ -581,28 +581,28 @@ fun main(args: Array<String>) {
在示例中，我们有两个类：一个基类和一个从基类派生的类。
```
```kt
println(d is Base)
```
此行检查变量`d`是否指向作为`Base`类实例的类。 由于`Derived`类继承自`Base`类，因此它也是`Base`类的实例。 该行打印正确。
```
```kt
println(b is Derived)
```
`b`对象不是`Derived`类的实例。 该行显示 false。
```
```kt
println(d is Any)
```
每个类都有`Any`作为超类。 因此，`d`对象也是`Any`类的实例。
```
```kt
true
false
true
......@@ -617,7 +617,7 @@ Kotlin 具有 lambda 运算符（`-&gt;`）。 它分隔了 lambda 表达式的
`KotlinLambdaOperatorEx.kt`
```
```kt
package com.zetcode
import java.util.Arrays
......@@ -635,7 +635,7 @@ fun main(args: Array<String>) {
在示例中，我们定义了一个字符串数组。 使用`Arrays.sort()`方法和 lambda 表达式对数组进行排序。
```
```kt
[atom, blue, car, kind, massive]
```
......@@ -648,7 +648,7 @@ fun main(args: Array<String>) {
`KotlinDoubleColonOperatorEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -665,7 +665,7 @@ fun main(args: Array<String>) {
在代码示例中，我们使用双冒号运算符创建对类和函数的引用。
```
```kt
val c = String::class
c.supertypes.forEach { e -> println(e) }
......@@ -674,7 +674,7 @@ c.supertypes.forEach { e -> println(e) }
对于双冒号运算符，我们指的是`String`类。 我们打印其所有祖先。
```
```kt
val words = listOf("car", "forest", "Bible")
println(words.map(String::length))
......@@ -682,7 +682,7 @@ println(words.map(String::length))
在这里，我们将`length()`函数应用于列表的所有单词。
```
```kt
kotlin.Comparable<kotlin.String>
kotlin.CharSequence
java.io.Serializable
......@@ -699,7 +699,7 @@ Kotlin 范围运算符（..）允许创建值范围。
`KotlinRanageOperatorEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -714,7 +714,7 @@ fun main(args: Array<String>) {
该示例使用范围运算符在 for 循环中创建整数序列。
```
```kt
1
4
7
......@@ -731,7 +731,7 @@ fun main(args: Array<String>) {
`KotlinNullAssertionOperatorEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -760,7 +760,7 @@ Elvis 运算符？：如果不为 null，则返回其第一个表达式，否则
`KotlinElvisOperatorEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -779,14 +779,14 @@ fun main(args: Array<String>) {
在示例中，我们使用 Elvis 运算符检查列表中的空值。
```
```kt
val n = word?.length ?: 0
```
如果变量`word`包含 null，则？：返回 0。
```
```kt
forest has 6 letters
null has 0 letters
Bible has 5 letters
......@@ -802,7 +802,7 @@ Kotlin 的 null 安全操作符`?.`提供了安全的方法调用-仅当对象
`KotlinNullSafetyOperatorEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -818,7 +818,7 @@ fun main(args: Array<String>) {
在示例中，我们将字符串转换为大写； 我们使用 null 安全运算符。 对于 null 值，不调用该方法。
```
```kt
FOREST
null
BIBLE
......@@ -834,7 +834,7 @@ Kotlin 索引访问运算符用于从数组获取值。
`KotlinIndexAccessOperatorEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -858,7 +858,7 @@ Kotlin 区分结构平等和参照平等。 结构相等运算符（`==`）检
`KotlinreferentialEqualityOperatorEx.kt`
```
```kt
package com.zetcode
data class Item(var name: String, var color: String)
......@@ -882,7 +882,7 @@ fun main(args: Array<String>) {
该示例演示了`==`和`===`运算符之间的区别。
```
```kt
Output: true
Output: true
Output: true
......@@ -898,14 +898,14 @@ Output: false
以下表达式 28 或 40 的结果是什么？
```
```kt
3 + 5 * 5
```
像数学中一样，乘法运算符的优先级高于加法运算符。 结果是 28。
```
```kt
(3 + 5) * 5
```
......@@ -914,7 +914,7 @@ Output: false
`KotlinOperatorPrecedenceEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -930,28 +930,28 @@ fun main(args: Array<String>) {
在此代码示例中，我们显示一些表达式。 每个表达式的结果取决于优先级。
```
```kt
println(3 + 5 * 5)
```
该行打印 28。乘法运算符的优先级高于加法。 首先，计算`5 * 5`的乘积，然后加 3。
```
```kt
println((3 + 5) * 5)
```
可以通过使用方括号来更改表达式的求值。 在这种情况下，将评估`3 + 5`，然后将该值乘以 5。此行显示 40。
```
```kt
println(!true or true)
```
在这种情况下，求反运算符的优先级高于按位或。 首先，将初始 true 值取反为 false，然后`|`运算符将 false 和 true 组合在一起，最后给出 true。
```
```kt
28
40
true
......@@ -965,7 +965,7 @@ false
有时，优先级不能令人满意地确定表达式的结果。 还有另一个规则称为关联性。 运算符的关联性决定了具有相同优先级的运算符的评估顺序。
```
```kt
9 / 3 * 3
```
......@@ -976,7 +976,7 @@ false
`KotlinAssociativityRuleEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -992,7 +992,7 @@ fun main(args: Array<String>) {
在示例中，我们的关联规则确定表达式的结果。
```
```kt
var j = 0
j *= 3 + 1
......@@ -1007,7 +1007,7 @@ j *= 3 + 1
`KotlinPrimeNumbersEx.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -1056,7 +1056,7 @@ fun main(args: Array<String>) {
在上面的示例中，我们处理了几个运算符。 质数（或质数）是一个自然数，它具有两个截然不同的自然数除数：1 和它本身。 我们选择一个数字并将其除以 1 到所选数字的数字。 实际上，我们不必尝试所有较小的数字。 我们可以将数字除以所选数字的平方根。 该公式将起作用。 我们使用余数除法运算符。
```
```kt
val nums = intArrayOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28)
......@@ -1064,7 +1064,7 @@ val nums = intArrayOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
我们将从这些数字计算素数。
```
```kt
if (num == 0 || num == 1) {
continue
}
......@@ -1073,7 +1073,7 @@ if (num == 0 || num == 1) {
值 0 和 1 不被视为素数。
```
```kt
if (num == 2 || num == 3) {
print(num.toString() + " ")
......@@ -1084,14 +1084,14 @@ if (num == 2 || num == 3) {
我们跳过 2 和 3 的计算。它们是质数。 请注意等式和条件或运算符的用法。 `==`的优先级高于`||`运算符。 因此，我们不需要使用括号。
```
```kt
var i = Math.sqrt(num.toDouble()).toInt()
```
如果我们仅尝试小于所讨论数字的平方根的数字，那么我们可以。
```
```kt
while (i > 1) {
...
i--;
......@@ -1101,7 +1101,7 @@ while (i > 1) {
这是一个 while 循环。 `i`是计算出的数字的平方根。 我们使用减量运算符将每个循环周期的`i`减 1。 当 i 小于 1 时，我们终止循环。 例如，我们有 9。9 的平方根是 3。我们将 9 的数字除以 3 和 2。这对于我们的计算就足够了。
```
```kt
if (num % i == 0) {
isPrime = false
......
docs/kotlin/38.md
浏览文件 @ 722256e4
......@@ -14,7 +14,7 @@ Kotlin 在将其参数依次与所有分支匹配之前，直到满足某个分
`day_of_week.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -43,7 +43,7 @@ fun main() {
`day_of_week2.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -67,7 +67,7 @@ Kotlin 什么时候可以用作表达式。 返回满意分支的值。
`when_expression.kt`
```
```kt
package com.zetcode
import java.time.DayOfWeek
......@@ -101,7 +101,7 @@ fun main() {
`age_groups.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -128,7 +128,7 @@ Kotlin 表达式可与枚举一起使用时。
`when_enums.kt`
```
```kt
package com.zetcode
enum class Season {
......@@ -158,7 +158,7 @@ Kotlin 何时可以不带参数使用表达式。
`random_val.kt`
```
```kt
package com.zetcode
import java.util.Random
......@@ -184,7 +184,7 @@ fun main() {
`when_types.kt`
```
```kt
package com.zetcode
import javax.lang.model.type.ArrayType
......
docs/kotlin/39.md
浏览文件 @ 722256e4
......@@ -14,7 +14,7 @@ Kotlin 数组教程展示了如何在 Kotlin 中使用数组。
`KotlinArrayInit.kt`
```
```kt
package com.zetcode
import java.util.Arrays
......@@ -35,35 +35,35 @@ fun main() {
该示例创建三个数组。
```
```kt
val nums = arrayOf(1, 2, 3, 4, 5)
```
使用`arrayOf()`函数创建一个数组。
```
```kt
println(Arrays.toString(nums))
```
我们使用`Arrays'` `toString()`方法来打印数组的内容。
```
```kt
val nums2 = (3..12).toList().toTypedArray()
```
在这一行中，我们根据一系列数字创建一个数组。
```
```kt
val nums3 = IntArray(5, { i -> i * 2 + 3})
```
该行使用`IntArray`创建一个数组。 它以元素数量和工厂功能为参数。
```
```kt
[1, 2, 3, 4, 5]
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
[3, 5, 7, 9, 11]
......@@ -78,7 +78,7 @@ val nums3 = IntArray(5, { i -> i * 2 + 3})
`KotlinArrayIndexing.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -95,7 +95,7 @@ fun main() {
我们使用索引操作来获取和修改数组值。
```
```kt
println(nums[2])
```
......@@ -108,7 +108,7 @@ println(nums[2])
`KotlinArrayBasicOperations.kt`
```
```kt
package com.zetcode
import java.util.Arrays
......@@ -136,35 +136,35 @@ fun main() {
在该示例中，我们检索和修改数组元素，创建切片，并获取元素的索引。
```
```kt
println(nums.get(0))
```
我们使用`get()`函数获得索引为 0 的元素。
```
```kt
nums.set(0, 0)
```
`set()`方法将指定索引处的数组元素设置为指定值。
```
```kt
val nums2 = nums.plus(1)
```
我们向数组添加一个新元素，创建一个新数组。 （请记住，数组是固定大小的；因此，创建了一个新的数组）。
```
```kt
val slice = nums.sliceArray(1..3)
```
使用`sliceArray()`方法，我们从数组中创建一个切片。 索引都包含在内。
```
```kt
println(nums.first())
println(nums.last())
......@@ -172,14 +172,14 @@ println(nums.last())
我们得到数组的第一个和最后一个元素。
```
```kt
println(nums.indexOf(5))
```
我们获得元素 5 首次出现的索引。
```
```kt
1
[0, 2, 3, 4, 5]
[0, 2, 3, 4, 5, 1]
......@@ -198,7 +198,7 @@ println(nums.indexOf(5))
`KotlinArrayBuiltins.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -225,21 +225,21 @@ fun main() {
该示例计算数组的平均值，总和，最大值，最小值和大小。
```
```kt
val avg = nums.average()
```
`average()`函数计算数组值的平均值。
```
```kt
val nOfValues = nums.count()
```
元素数由`count()`确定。
```
```kt
The average is 3.0
There are 5 elements
The sum of values is 15
......@@ -256,7 +256,7 @@ The minimum is 1
`KotlinArrayCount.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -274,7 +274,7 @@ fun main() {
该示例计算数组中值的总数和偶数的数量。
```
```kt
There are 6 elements in the array
There are 3 even values in the array
......@@ -288,7 +288,7 @@ There are 3 even values in the array
`KotlinTraverseArrays.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -320,21 +320,21 @@ fun main() {
该示例使用四种不同的遍历方式遍历数组。
```
```kt
nums.forEach({ e -> print("$e ") })
```
我们使用`forEach()`遍历数组。 此方法对数组的每个元素应用操作。 在我们的情况下将其打印出来。
```
```kt
nums.forEachIndexed({i, e -> println("nums[$i] = $e")})
```
`forEachIndexed()`在每个元素上执行给定的操作，为元素提供顺序索引。
```
```kt
for (e in nums) {
print("$e ")
}
......@@ -343,7 +343,7 @@ for (e in nums) {
我们在 for 循环中遍历数组。
```
```kt
val it: Iterator<Int> = nums.iterator()
while (it.hasNext()) {
......@@ -356,7 +356,7 @@ while (it.hasNext()) {
最后，我们使用迭代器和 while 循环遍历数组。
```
```kt
1 2 3 4 5 6 7
nums[0] = 1
nums[1] = 2
......@@ -378,7 +378,7 @@ nums[6] = 7
`KotlinArraySort.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -396,7 +396,7 @@ fun main() {
该示例对数组进行排序，其中`sortedArray()`为升序，`sortedArrayDescending()`为降序。 该方法创建新的排序数组。
```
```kt
[1, 3, 3, 4, 5, 7, 9]
[9, 7, 5, 4, 3, 3, 1]
......@@ -410,7 +410,7 @@ fun main() {
`KotlinArrayTwoDim.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -426,7 +426,7 @@ fun main() {
该示例通过将`intArrayOf()`函数调用嵌套到`arrayOf()`函数中来创建二维数组。
```
```kt
[[1, 2], [3, 4], [5, 6, 7]]
```
......@@ -439,7 +439,7 @@ fun main() {
`KotlinArrayFilter.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -453,7 +453,7 @@ fun main() {
本示例创建一个正负整数数组。 `filter()`方法仅用于拾取正值。
```
```kt
1 3 4 7
```
......@@ -466,7 +466,7 @@ fun main() {
`KotlinArrayFind.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -484,7 +484,7 @@ fun main() {
该示例在数组中查找第一个和最后一个偶数值。
```
```kt
The first even value is: 2
The last even value is: 8
......@@ -498,7 +498,7 @@ The last even value is: 8
`KotlinArrayReduce.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -514,14 +514,14 @@ fun main() {
我们使用`reduce()`方法从数组元素计算乘积。
```
```kt
val total = nums.reduce { product, next -> product * next }
```
`product`是累加器，`next`是数组中的下一个值。
```
```kt
5040
```
......@@ -534,7 +534,7 @@ val total = nums.reduce { product, next -> product * next }
`KotlinArrayAll.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -556,7 +556,7 @@ fun main() {
该示例检查数组元素是否全部为偶数。
```
```kt
The array contains odd values
```
......@@ -569,7 +569,7 @@ The array contains odd values
`KotlinArrayAny.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -591,7 +591,7 @@ fun main() {
该示例检查数组元素是否包含任何偶数值。
```
```kt
The array contains even values
```
......
docs/kotlin/40.md
浏览文件 @ 722256e4
......@@ -14,7 +14,7 @@ Kotlin Ranges 教程显示了如何在 Kotlin 中使用范围。
`KotlinRangeCreate.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -44,7 +44,7 @@ fun main() {
该示例创建四个值范围。
```
```kt
for (i in 1..30)
print("$i ")
......@@ -52,7 +52,7 @@ for (i in 1..30)
`1..30`创建从 1 到 30 的一系列值，包括边界。 我们使用`for`循环遍历该范围。
```
```kt
for (i in 30 downTo 1)
print("$i ")
......@@ -60,7 +60,7 @@ for (i in 30 downTo 1)
使用`downTo`关键字，我们创建了一系列从 30 降到 1 的值。
```
```kt
for (i in 1.rangeTo(30))
print("$i ")
......@@ -68,7 +68,7 @@ for (i in 1.rangeTo(30))
`rangeTo()`函数在定义的边界之间创建一个值范围； 它等效于`..`运算符。
```
```kt
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
......@@ -84,7 +84,7 @@ for (i in 1.rangeTo(30))
`KotlinRangeChars.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -102,7 +102,7 @@ fun main() {
本示例创建两个字母范围的升序和降序。
```
```kt
for (c in 'a'..'k')
print("$c ")
......@@ -110,7 +110,7 @@ for (c in 'a'..'k')
我们创建并打印“ a”到“ k”个字符。
```
```kt
for (c in 'k' downTo 'a')
print("$c ")
......@@ -118,7 +118,7 @@ for (c in 'k' downTo 'a')
我们创建并将“ k”打印为“ a”字符。
```
```kt
a b c d e f g h i j k
k j i h g f e d c b a
......@@ -132,7 +132,7 @@ k j i h g f e d c b a
`KotlinRangeForEach.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -146,21 +146,21 @@ fun main() {
该示例使用`forEach()`功能遍历范围。
```
```kt
(1..5).forEach(::println)
```
使用`forEach()`功能，我们可以打印`1..5`范围内的所有值。
```
```kt
(1..5).reversed().forEach { e -> print("$e ") }
```
在这一行中，我们使用`reversed()`反转范围，并使用`forEach()`遍历该范围。
```
```kt
1
2
3
......@@ -178,7 +178,7 @@ fun main() {
`KotlinRangeIterator.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -197,7 +197,7 @@ fun main() {
该示例使用迭代器遍历一系列字符。
```
```kt
val chars = ('a'..'f')
val it = chars.iterator()
......@@ -205,7 +205,7 @@ val it = chars.iterator()
我们创建一个字符范围和一个从该范围开始的迭代器。
```
```kt
while (it.hasNext()) {
val e = it.next()
......@@ -216,7 +216,7 @@ while (it.hasNext()) {
在 while 循环中，我们遍历范围的元素。 `hasNext()`方法检查范围内是否有下一个元素，`next()`方法返回范围内的下一个元素。
```
```kt
a
b
c
......@@ -234,7 +234,7 @@ f
`KotlinRangeStep.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -262,7 +262,7 @@ fun main() {
该示例显示了如何在 Kotlin 范围内使用 step。
```
```kt
for (e in 1..20 step 2) {
print("$e ")
}
......@@ -271,7 +271,7 @@ for (e in 1..20 step 2) {
for 循环遍历范围的值。 范围具有步骤 2。
```
```kt
println((1..10 step 2).last)
println((1..10 step 3).first)
println((1..10 step 4).step)
......@@ -280,7 +280,7 @@ println((1..10 step 4).step)
Kotlin 范围包含`last`，`first`和`step`属性，这些属性返回最后一个，第一个值和步骤。
```
```kt
1 3 5 7 9 11 13 15 17 19
1 6 11 16
9
......@@ -297,7 +297,7 @@ Kotlin 范围包含过滤，缩小和映射操作。
`KotlinRangeFilterReduceMap.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -320,28 +320,28 @@ fun main() {
该示例在范围上应用过滤，归约和映射。
```
```kt
val r = rnums.filter { e -> e % 2 == 0 }
```
使用`filter()`功能，我们可以滤除偶数。 偶数可以被二除而无余数。 该操作返回值列表。
```
```kt
val r2 = rnums.reduce { total, next -> next * 2 - 1 }
```
归约运算将给定表达式应用于每个范围元素以产生单个值。
```
```kt
var r3 = rnums.map { e -> e * 5 }
```
映射操作将给定操作应用于每个元素。 映射返回修改值的列表。
```
```kt
1..15
[2, 4, 6, 8, 10, 12, 14]
29
......@@ -357,7 +357,7 @@ Kotlin 范围包含预定义的归约运算，包括`min()`，`max()`，`sum()`
`KotlinRangeMinMaxSumAvg.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -374,7 +374,7 @@ fun main() {
该示例打印范围为`1..10`的值的最小值，最大值，总和和平均值。
```
```kt
1
10
55
......
docs/kotlin/41.md
浏览文件 @ 722256e4
......@@ -20,7 +20,7 @@ Swing 是 Java 编程语言的主要 GUI 工具包。 它是 JFC（Java 基础
`Board.kt`
```
```kt
package com.zetcode
import java.awt.*
......@@ -267,7 +267,7 @@ class Board : JPanel(), ActionListener {
首先，我们将定义游戏中使用的属性。
```
```kt
private val boardWidth = 300
private val boardHeight = 300
private val dotSize = 10
......@@ -279,7 +279,7 @@ private val delay = 140
`boardWidth`和`boardHeight`属性确定电路板的尺寸。 `dotSize`是苹果的大小和蛇的点。 `allDots`属性定义了板上可能的最大点数（900 =（300 * 300）/（10 * 10））。 `randPos`属性用于计算苹果的随机位置。 `delay`属性确定游戏的速度。
```
```kt
private val x = IntArray(allDots)
private val y = IntArray(allDots)
......@@ -287,7 +287,7 @@ private val y = IntArray(allDots)
这两个数组存储蛇的所有关节的 x 和 y 坐标。
```
```kt
private fun loadImages() {
val iid = ImageIcon("src/main/resources/dot.png")
......@@ -304,7 +304,7 @@ private fun loadImages() {
在`loadImages()`方法中，我们获得了游戏的图像。 `ImageIcon`类用于显示 PNG 图像。
```
```kt
private fun initGame() {
nOfDots = 3
......@@ -324,7 +324,7 @@ private fun initGame() {
在`initGame()`方法中，我们创建蛇，在板上随机放置一个苹果，然后启动计时器。
```
```kt
private fun doDrawing(g: Graphics) {
if (inGame) {
......@@ -351,7 +351,7 @@ private fun doDrawing(g: Graphics) {
在`doDrawing()`方法中，我们绘制了苹果和蛇对象。 如果游戏结束，我们将根据消息绘制游戏。
```
```kt
private fun gameOver(g: Graphics) {
val msg = "Game Over"
......@@ -376,7 +376,7 @@ private fun gameOver(g: Graphics) {
`gameOver()`方法在窗口中间绘制“ Game Over”消息。 我们使用渲染提示来平滑地绘制消息。 我们使用字体指标来获取消息的大小。
```
```kt
private fun checkApple() {
if (x[0] == appleX && y[0] == appleY) {
......@@ -392,7 +392,7 @@ private fun checkApple() {
在`move()`方法中，我们有游戏的密钥算法。 要了解它，请看一下蛇是如何运动的。 我们控制蛇的头。 我们可以使用光标键更改其方向。 其余关节在链上向上移动一个位置。 第二关节移动到第一个关节的位置，第三关节移动到第二个关节的位置，依此类推。
```
```kt
for (z in nOfDots downTo 1) {
x[z] = x[z - 1]
y[z] = y[z - 1]
......@@ -402,7 +402,7 @@ for (z in nOfDots downTo 1) {
该代码将关节向上移动。
```
```kt
if (leftDirection) {
x[0] -= dotSize
}
......@@ -413,7 +413,7 @@ if (leftDirection) {
在`checkCollision()`方法中，我们确定蛇是否击中了自己或撞墙之一。
```
```kt
for (z in nOfDots downTo 1) {
if (z > 4 && x[0] == x[z] && y[0] == y[z]) {
......@@ -425,7 +425,7 @@ for (z in nOfDots downTo 1) {
如果蛇用头撞到其关节之一，则游戏结束。
```
```kt
if (y[0] >= boardHeight) {
inGame = false
}
......@@ -436,7 +436,7 @@ if (y[0] >= boardHeight) {
`Snake.kt`
```
```kt
package com.zetcode
import java.awt.EventQueue
......@@ -479,7 +479,7 @@ class Snake : JFrame() {
这是主要的类。
```
```kt
isResizable = false
pack()
......
docs/kotlin/42.md
浏览文件 @ 722256e4
......@@ -12,7 +12,7 @@ Swing 是 Java 编程语言的主要 GUI 工具包。 它是 JFC（Java 基础
`KotlinSwingSimpleEx.kt`
```
```kt
package com.zetcode
import java.awt.EventQueue
......@@ -48,42 +48,42 @@ fun main(args: Array<String>) {
窗口位于屏幕中央。
```
```kt
class KotlinSwingSimpleEx(title: String) : JFrame() {
```
`KotlinSwingSimpleEx`继承自`JFrame`组件。 `JFrame`是顶级容器。 容器的目的是保存应用的组件。
```
```kt
setTitle(title)
```
应用的标题由`setTitle()`设置。
```
```kt
defaultCloseOperation = JFrame.EXIT_ON_CLOSE
```
`defaultCloseOperation`设置关闭框时默认发生的操作。 在我们的情况下，我们退出该应用。
```
```kt
setSize(300, 200)
```
我们用`setSize()`设置初始大小。
```
```kt
setLocationRelativeTo(null)
```
这条线用于使窗口在屏幕上居中。
```
```kt
val frame = KotlinSwingSimpleEx("Simple")
frame.isVisible = true
......@@ -91,7 +91,7 @@ frame.isVisible = true
我们创建应用框架并将其显示在屏幕上。
```
```kt
EventQueue.invokeLater(::createAndShowGUI)
```
......@@ -108,7 +108,7 @@ Figure: Simple example
`KotlinSwingCloseButtonEx.kt`
```
```kt
package com.zetcode
import java.awt.EventQueue
......@@ -168,28 +168,28 @@ fun main(args: Array<String>) {
我们将`JButton`放置在窗口上，然后向该按钮添加一个动作监听器。
```
```kt
val closeBtn = JButton("Close")
```
创建一个按钮组件。 构造函数将字符串标签作为参数。
```
```kt
closeBtn.addActionListener { System.exit(0) }
```
使用`addActionListener()`将动作侦听器添加到按钮。 该操作通过调用`System.exit()`方法来终止应用。
```
```kt
createLayout(closeBtn)
```
子组件（在我们的情况下是一个按钮）需要放入容器中。 我们将任务委托给`createLayout()`方法。
```
```kt
val gl = GroupLayout(contentPane)
contentPane.layout = gl
......@@ -197,14 +197,14 @@ contentPane.layout = gl
`JFrame`的内容窗格是放置子组件的区域。 子级由专门的不可见组件（称为布局管理器）组织。 `BorderLayout`是内容窗格的默认布局管理器。 该管理器非常简单，仅在少数情况下有用。 我们使用功能更强大，更灵活的`GroupLayout`管理器。
```
```kt
gl.autoCreateContainerGaps = true
```
`autoCreateContainerGaps`属性在组件和容器边缘之间创建间隙。 空间或间隙是每个应用设计的重要组成部分。
```
```kt
gl.setHorizontalGroup(gl.createSequentialGroup()
.addComponent(arg[0])
)
......@@ -229,7 +229,7 @@ Figure: Close button
`KotlinSwingStandardColoursEx.kt`
```
```kt
package com.zetcode
import java.awt.Color
......@@ -332,7 +332,7 @@ fun main(args: Array<String>) {
该示例显示了 13 个`JLabel`组件； 每个标签具有不同的背景色。 `JLabel`通常用于显示文本； 但它也可以显示颜色。
```
```kt
val stdCols = arrayOf<Color>(Color.black, Color.blue, Color.cyan,
Color.darkGray, Color.gray, Color.green, Color.lightGray, Color.magenta,
Color.orange, Color.pink, Color.red, Color.white, Color.yellow)
......@@ -341,7 +341,7 @@ val stdCols = arrayOf<Color>(Color.black, Color.blue, Color.cyan,
在这里，我们有一个内置颜色值的数组。
```
```kt
val labels = stdCols.map {
JLabel("", null, LEADING).apply {
......@@ -367,7 +367,7 @@ Figure: Standard colours
`KotlinSwingCheckBoxEx.kt`
```
```kt
package com.zetcode
import java.awt.EventQueue
......@@ -438,14 +438,14 @@ fun main(args: Array<String>) {
我们的代码示例根据是否选中复选框来显示或隐藏窗口的标题。
```
```kt
val checkBox = JCheckBox("Show title", true)
```
`JCheckBox`已创建。 此构造函数将文本和复选框的状态作为参数。 最初已选中该复选框。
```
```kt
checkBox.addItemListener { e ->
val sel: Int = e.stateChange
if (sel == ItemEvent.SELECTED) {
......@@ -469,7 +469,7 @@ Figure: JCheckBox
`KotlinSwingLabelIconEx.kt`
```
```kt
package com.zetcode
import javax.swing.*
......@@ -534,7 +534,7 @@ fun main(args: Array<String>) {
该示例在一行中显示了四个图像。
```
```kt
val lbl1 = JLabel(ImageIcon("src/main/resources/cpu.png"))
```
......@@ -551,7 +551,7 @@ Figure: ImageIcon
`KotlinSwingSimpleMenuExEx.kt`
```
```kt
package com.zetcode
import java.awt.EventQueue
......@@ -610,21 +610,21 @@ fun main(args: Array<String>) {
该示例创建一个带有一个菜单项的简单菜单。 选择退出菜单项，我们关闭应用。
```
```kt
val menubar = JMenuBar()
```
使用 JMenuBar 创建菜单栏。
```
```kt
val icon = ImageIcon("src/main/resources/exit.png")
```
菜单中显示退出图标。
```
```kt
val file = JMenu("File")
file.mnemonic = KeyEvent.VK_F
......@@ -632,21 +632,21 @@ file.mnemonic = KeyEvent.VK_F
使用`JMenu`类创建菜单对象。 也可以通过键盘访问菜单。 要将菜单绑定到特定键，我们使用`setMnemonic()`方法。 在我们的情况下，可以使用`Alt + F + E` 打开菜单。
```
```kt
eMenuItem.toolTipText = "Exit application"
```
此代码行为菜单项创建工具提示。
```
```kt
eMenuItem.addActionListener { _: ActionEvent -> System.exit(0) }
```
`JMenuItem`是一种特殊的按钮组件。 我们向它添加一个动作监听器； 选择后将终止应用。
```
```kt
file.add(eMenuItem)
menubar.add(file)
......@@ -654,7 +654,7 @@ menubar.add(file)
菜单项被添加到菜单对象，菜单对象被插入菜单栏。
```
```kt
jMenuBar = menubar
```
......
docs/kotlin/43.md
浏览文件 @ 722256e4
......@@ -14,7 +14,7 @@ Kotlin 具有用于处理字符串的丰富 API。 它包含许多用于各种
`KotlinStringBasic.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -31,7 +31,7 @@ fun main(args: Array<String>) {
该示例创建一个字符串，使用字符串连接操作，并确定该字符串的宽度。
```
```kt
val s = "Today is a sunny day."
println(s)
......@@ -39,21 +39,21 @@ println(s)
将创建一个字符串文字并将其传递给`s`变量。 使用`println()`将字符串打印到控制台。
```
```kt
println("Old " + "bear")
```
在 Kotlin 中，字符串与`+`运算符连接在一起。
```
```kt
println("The string has " + s.length + " characters")
```
字符串的长度由`length`属性确定。
```
```kt
Today is a sunny day.
Old bear
The string has 21 characters
......@@ -68,7 +68,7 @@ The string has 21 characters
`KotlinStringIndexes.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -86,7 +86,7 @@ fun main(args: Array<String>) {
该示例显示了如何获取字符串的第一个和最后一个字符。 它使用索引操作和替代的字符串方法。
```
```kt
println(s[0])
println(s[s.length-1])
......@@ -94,7 +94,7 @@ println(s[s.length-1])
索引从零开始； 因此，第一个字符的索引为零。 字符的索引放在方括号之间。
```
```kt
println(s.first())
println(s.last())
......@@ -110,7 +110,7 @@ Kotlin 字符串格式化比基本插值功能更强大。
`KotlinStringInterpolate.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -129,7 +129,7 @@ fun main(args: Array<String>) {
该示例显示了如何在 Kotlin 中进行字符串插值。
```
```kt
val name = "Peter"
val age = 34
......@@ -137,21 +137,21 @@ val age = 34
我们有两个变量。
```
```kt
println("$name is $age years old")
```
这两个变量在字符串内插； 即用它们的值替换它们。
```
```kt
println("The string has ${msg.length} characters")
```
在这里，我们得到字符串的长度。 由于它是一个表达式，因此需要将其放在`{}`括号内。
```
```kt
Peter is 34 years old
The string has 20 characters
......@@ -165,7 +165,7 @@ The string has 20 characters
`KotlinCompareStrings.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -198,14 +198,14 @@ fun main(args: Array<String>) {
在示例中，我们比较两个字符串。
```
```kt
if (s1 == s2) {
```
`==`运算符比较结构相等性，即两个字符串的内容。
```
```kt
val res = s1.compareTo(s2, true)
```
......@@ -218,7 +218,7 @@ val res = s1.compareTo(s2, true)
`KotlinStringEscapeCharacters.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -232,21 +232,21 @@ fun main(args: Array<String>) {
该示例显示了 Kotlin 中的转义字符。
```
```kt
println("He said: \"I love ice skating\"")
```
我们通过转义双引号的原始功能，将双 qoutes 插入字符串文字中。
```
```kt
println("Line 1:\nLine 2:\nLine 3:")
```
使用`\n`，我们创建了三行。
```
```kt
Three bottles of wine
He said: "I love ice skating"
Line 1:
......@@ -263,7 +263,7 @@ Kotlin 具有处理字符串字符大小写的方法。
`KotlinStringCase.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -281,7 +281,7 @@ fun main(args: Array<String>) {
该示例提出了四种方法：`capitalize()`，`toUpperCase()`，`toLowerCase()`和`decapitalize()`。
```
```kt
Young eagle
YOUNG EAGLE
young eagle
......@@ -297,7 +297,7 @@ Kotlin 区分空字符串和空字符串。 空字符串不包含任何字符，
`KotlinStringEmptyBlank.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -325,21 +325,21 @@ fun main(args: Array<String>) {
该示例测试字符串是否平淡且为空。
```
```kt
if (s.isEmpty()) {
```
如果字符串为空，则`isEmpty()`返回 true。
```
```kt
if (s.isBlank()) {
```
如果字符串为空白，则`isBlank()`返回 true。
```
```kt
The string is not empty
The string is blank
......@@ -353,7 +353,7 @@ The string is blank
`KotlinStringSort.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -376,21 +376,21 @@ fun main(args: Array<String>) {
该示例介绍了从字符串中去除空格的方法。
```
```kt
val s1 = s.trimEnd()
```
`trimEnd()`方法删除尾随空格。
```
```kt
val s2 = s.trimStart()
```
`trimStart()`方法删除前导空格。
```
```kt
val s3 = s.trim()
```
......@@ -403,7 +403,7 @@ Kotlin 字符串是字符序列。 我们可以循环执行此序列。
`KotlinStringLoop.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -428,7 +428,7 @@ fun main(args: Array<String>) {
该示例使用 for 循环，forEach 循环和 forEachIndexed 循环遍历字符串。
```
```kt
for (e in phrase) {
print("$e ")
......@@ -438,21 +438,21 @@ for (e in phrase) {
我们使用 for 循环遍历字符串并打印每个字符。
```
```kt
phrase.forEach { e -> print(String.format("%#x ", e.toByte())) }
```
我们使用 forEach 遍历一个循环，并打印每个字符的字节值。
```
```kt
phrase.forEachIndexed { idx, e -> println("phrase[$idx]=$e ") }
```
使用 forEachIndexed，我们将打印带有索引的字符。
```
```kt
y o u n g e a g l e
0x79 0x6f 0x75 0x6e 0x67 0x20 0x65 0x61 0x67 0x6c 0x65
phrase[0]=y
......@@ -477,7 +477,7 @@ phrase[10]=e
`KotlinStringFilter.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -502,7 +502,7 @@ fun main(args: Array<String>) {
该示例计算字符串中的所有元音。
```
```kt
fun Char.isEnglishVowel(): Boolean = this.toLowerCase() == 'a'
|| this.toLowerCase() == 'e'
|| this.toLowerCase() == 'i'
......@@ -514,7 +514,7 @@ fun Char.isEnglishVowel(): Boolean = this.toLowerCase() == 'a'
我们创建一个扩展函数； 对于英语元音，它返回 true。
```
```kt
val res = s.filter { e -> e.isEnglishVowel()}
```
......@@ -527,7 +527,7 @@ val res = s.filter { e -> e.isEnglishVowel()}
`KotlinStringStartEnd.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -557,7 +557,7 @@ fun endWithK(word: String): Boolean {
在示例中，我们有一个单词列表。 通过上述方法，我们找出哪些单词以“ t”和“ k”开头。
```
```kt
val words = listOf("tank", "boy", "tourist", "ten",
"pen", "car", "marble", "sonnet", "pleasant",
"ink", "atom")
......@@ -566,7 +566,7 @@ val words = listOf("tank", "boy", "tourist", "ten",
使用`listOf()`，我们定义了一个单词列表。
```
```kt
val res = words.filter { e -> startWithT(e) }
println(res)
......@@ -577,7 +577,7 @@ println(res2)
我们在`filter()`方法中调用了两个自定义函数。
```
```kt
fun startWithT(word: String): Boolean {
return word.startsWith("t")
......@@ -587,7 +587,7 @@ fun startWithT(word: String): Boolean {
`startWithT()`是一个自定义谓词函数，如果字符串以't'开头，则返回 true。
```
```kt
[tank, tourist, ten]
[tank, ink]
......@@ -601,7 +601,7 @@ fun startWithT(word: String): Boolean {
`KotlinStringReplace.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -622,7 +622,7 @@ fun main(args: Array<String>) {
`KotlinToString.kt`
```
```kt
package com.zetcode
class City(private var name: String, private var population: Int) {
......@@ -645,7 +645,7 @@ fun main(args: Array<String>) {
该示例创建一个城市对象列表。 我们遍历列表并将对象打印到控制台。
```
```kt
override fun toString(): String {
return "$name has population $population"
}
......@@ -654,7 +654,7 @@ override fun toString(): String {
我们将覆盖`toString()`的默认实现。 它返回一个字符串，表明一个城市具有指定的人口。
```
```kt
Bratislava has population 432000
Budapest has population 1759000
Prague has population 1280000
......@@ -669,7 +669,7 @@ Prague has population 1280000
`KotlinRawString.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -704,7 +704,7 @@ Kotlin 具有将字符串填充到指定字符或空格的方法。
`KotlinStringPad.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -718,7 +718,7 @@ fun main(args: Array<String>) {
该示例使用`padStart()`将数字用点字符填充。
```
```kt
.................657
.................122
................3245
......
docs/kotlin/44.md
浏览文件 @ 722256e4
......@@ -12,7 +12,7 @@ Kotlin 区分只读列表和可变列表。 用`listOf()`创建只读列表，
`KotlinListOf.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -31,7 +31,7 @@ fun main() {
`KotlinListBasic.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -57,14 +57,14 @@ fun main() {
该示例创建一个数字列表并计算一些统计信息。
```
```kt
val nums = listOf(11, 5, 3, 8, 1, 9, 6, 2)
```
使用`listOf()`功能创建 Kotlin 只读列表。
```
```kt
val len = nums.count()
val max = nums.max()
val min = nums.min()
......@@ -75,7 +75,7 @@ val avg = nums.average()
我们计算值的数量，最大值，最小值，总和和平均值。
```
```kt
max: 11, min: 1,
count: 8, sum: 45,
average: 5.625
......@@ -90,7 +90,7 @@ average: 5.625
`KotlinListIndex.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -118,42 +118,42 @@ fun main() {
该示例介绍了 Kotlin List 索引操作。
```
```kt
val w1 = words.get(0)
```
使用`get()`方法检索元素。 该方法将要检索的元素的索引作为参数。
```
```kt
val w2 = words[0]
```
我们还可以使用经典的 C 索引操作。
```
```kt
val i1 = words.indexOf("cup")
```
`indexOf()`返回列表中单词首次出现的索引。
```
```kt
val i2 = words.lastIndexOf("cup")
```
`lastIndexOf()`返回列表中单词最后一次出现的索引。
```
```kt
val i3 = words.lastIndex
```
`lastIndex`属性返回列表中最后一项的索引；如果列表为空，则返回-1
```
```kt
pen
pen
The first index of cup is 1
......@@ -170,7 +170,7 @@ The last index of the list is 8
`KotlinListCount.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -194,7 +194,7 @@ fun main() {
该示例返回列表中值的数量，负值的数量和偶数的数量。
```
```kt
val len = nums.count()
println("There are $len elements")
......@@ -205,21 +205,21 @@ println("The size of the list is $size")
我们可以使用`count()`方法或`size`属性来确定列表中的元素数量。
```
```kt
val n1 = nums.count { e -> e < 0 }
```
`count()`可以将谓词功能作为参数。 在我们的情况下，它对于小于 0 的值返回 true。
```
```kt
val n2 = nums.count { e -> e % 2 == 0 }
```
我们获得列表中的偶数个数。
```
```kt
There are 11 elements
The size of the list is 11
There are 3 negative values
......@@ -235,7 +235,7 @@ There are 5 even values
`KotlinListFirstLast.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -260,35 +260,35 @@ fun main() {
该示例创建一个单词列表。 我们得到列表的第一个和最后一个元素。
```
```kt
val w1 = words.first()
```
我们用`first()`获得第一个元素。
```
```kt
val w2 = words.last()
```
我们用`last()`获得最后一个元素。
```
```kt
val w3 = words.findLast { w -> w.startsWith('c') }
```
我们以`findLast()`检索以'c'开头的列表的最后一个元素。
```
```kt
val w4 = words.first { w -> w.startsWith('c') }
```
我们以`first()`检索以'c'开头的列表的第一个元素。
```
```kt
pen
spectacles
coal
......@@ -304,7 +304,7 @@ cup
`KotlinListIterate.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -346,14 +346,14 @@ fun main() {
该示例显示了 Kotlin 中遍历列表的五种方法。
```
```kt
words.forEach { e -> print("$e ") }
```
`forEach()`对每个列表元素执行给定的操作。 我们为它传递了一个匿名函数，该函数将打印当前元素。
```
```kt
for (word in words) {
print("$word ")
......@@ -363,7 +363,7 @@ for (word in words) {
我们用`for`循环列表。 `for`循环逐个遍历列表。 在每个循环中，`word`变量指向列表中的下一个元素。
```
```kt
for (i in 0 until words.size) {
print("${words[i]} ")
......@@ -373,14 +373,14 @@ for (i in 0 until words.size) {
另一种`for`循环利用列表的大小。 `until`关键字创建一系列列表索引。
```
```kt
words.forEachIndexed({i, e -> println("words[$i] = $e")})
```
使用`forEachIndexed()`方法，我们遍历具有每次迭代可用索引和值的列表。
```
```kt
val it: ListIterator<String> = words.listIterator()
while (it.hasNext()) {
......@@ -393,7 +393,7 @@ while (it.hasNext()) {
最后一种方法是使用`ListIterator`和`while`循环。
```
```kt
pen cup dog person cement coal spectacles
pen cup dog person cement coal spectacles
pen cup dog person cement coal spectacles
......@@ -416,7 +416,7 @@ pen cup dog person cement coal spectacles
`Car.kt`
```
```kt
package com.zetcode.bean
data class Car(var name: String, var price: Int)
......@@ -427,7 +427,7 @@ data class Car(var name: String, var price: Int)
`KotlinListSorting.kt`
```
```kt
package com.zetcode
import com.zetcode.bean.Car
......@@ -461,28 +461,28 @@ fun main() {
该示例按升序和降序对列表值进行排序，反转列表元素，并按名称对汽车对象进行排序。
```
```kt
val sortAsc = nums.sorted()
```
`sorted()`方法返回根据自然排序顺序排序的所有元素的列表。
```
```kt
val sortDesc = nums.sortedDescending()
```
`sortedDescending()`方法返回所有元素按照其自然排序顺序降序排列的列表。
```
```kt
val revNums = nums.reversed()
```
`reversed()`方法返回具有相反顺序元素的列表。
```
```kt
val cars = listOf(Car("Mazda", 6300), Car("Toyota", 12400),
Car("Skoda", 5670), Car("Mercedes", 18600))
......@@ -490,21 +490,21 @@ val cars = listOf(Car("Mazda", 6300), Car("Toyota", 12400),
我们创建汽车对象列表。 这些对象可以按名称或价格排序。
```
```kt
val res = cars.sortedBy { car -> car.name }
```
使用`sortedBy()`，我们按名称对汽车进行升序排序。
```
```kt
val res2 = cars.sortedByDescending { car -> car.name }
```
使用`sortedByDescending()`，我们按名称对汽车进行降序排序。
```
```kt
[1, 2, 3, 5, 6, 8, 9, 11]
[11, 9, 8, 6, 5, 3, 2, 1]
[2, 6, 9, 1, 8, 3, 5, 11]
......@@ -528,7 +528,7 @@ Car(name=Mazda, price=6300)
`KotlinListContains.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -550,21 +550,21 @@ fun main() {
可以检查列表是否包含一个或多个元素。
```
```kt
val r = nums.contains(4)
```
在这里，我们检查`nums`列表是否包含 4。该方法返回布尔值。
```
```kt
val r2 = nums.containsAll(listOf(1, -1))
```
此行检查列表是否包含两个值：1 和-1。
```
```kt
The list contains 4
The list contains -1 and 1
......@@ -578,7 +578,7 @@ The list contains -1 and 1
`KotlinListMutable.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -632,14 +632,14 @@ fun main() {
该示例创建一个可变列表并提供其几种方法。
```
```kt
val nums = mutableListOf(3, 4, 5)
```
我们创建一个包含三个整数元素的可变列表。
```
```kt
nums.add(6)
nums.add(7)
nums.addAll(listOf(8, 9, 10))
......@@ -648,21 +648,21 @@ nums.addAll(listOf(8, 9, 10))
`add()`在列表末尾添加一个新元素。 `addAll()`在列表的末尾添加了多个元素。
```
```kt
nums.shuffle()
```
`shuffle()`方法随机重新排列列表元素。 改组发生在原地； 即原始列表已修改。
```
```kt
nums.sort()
```
元素按其自然升序排序。
```
```kt
nums.removeAt(0)
nums.remove(10)
......@@ -670,42 +670,42 @@ nums.remove(10)
`removeAt()`方法删除指定索引处的元素。 `remove()`方法从列表中删除第一次出现的指定元素。
```
```kt
nums.replaceAll { e -> e * 2 }
```
`replaceAll()`方法使用给定功能修改列表的所有元素。 在我们的例子中，我们创建一个匿名函数，将每个元素乘以 2。
```
```kt
nums.retainAll(listOf(12, 14, 16, 18))
```
`retainAll()`方法仅保留参数中指定的元素； 其他被删除。
```
```kt
nums.fill(0)
```
`fill()`方法将所有元素替换为给定值。
```
```kt
nums.set(0, 22)
```
`set()`方法用给定元素替换列表中指定位置的元素。
```
```kt
nums.clear()
```
`clear()`方法从列表中删除所有元素。
```
```kt
if (nums.isEmpty()) println("The list is empty")
else println("The list is not epty")
......@@ -713,7 +713,7 @@ else println("The list is not epty")
使用`isEmpty()`方法，我们检查列表是否为空。
```
```kt
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[2, 3, 6, 1, 8, 0, 7, 5, 10, 9, 4]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
......@@ -734,7 +734,7 @@ The list is empty
`KotlinListSlice.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -752,21 +752,21 @@ fun main() {
在示例中，我们创建一个整数列表。 从列表中，我们产生两个切片。
```
```kt
val nums2 = nums.slice(1..3)
```
我们使用范围运算符创建包含索引为 1、2 和 3 的元素的列表切片。所有索引都包括在内。
```
```kt
val nums3 = nums.slice(listOf(3, 4, 5))
```
在第二个示例中，我们显式提供索引列表。
```
```kt
[2, 3, 4]
[4, 5, 6]
......@@ -780,7 +780,7 @@ val nums3 = nums.slice(listOf(3, 4, 5))
`Car.kt`
```
```kt
package com.zetcode.bean
data class Car(var name: String, var price: Int)
......@@ -791,7 +791,7 @@ data class Car(var name: String, var price: Int)
`KotlinListMax.kt`
```
```kt
package com.zetcode
import com.zetcode.bean.Car
......@@ -813,7 +813,7 @@ fun main() {
该示例查找整数列表和汽车对象列表的最大值。
```
```kt
val nums = listOf(11, 5, 23, 8, 1, 9, 6, 2)
println(nums.max())
......@@ -822,7 +822,7 @@ println(nums.max())
可以使用`max()`轻松找到整数列表的最大值。
```
```kt
val cars = listOf(Car("Mazda", 6300), Car("Toyota", 12400),
Car("Skoda", 5670), Car("Mercedes", 18600))
......@@ -833,7 +833,7 @@ println("The max price is ${car?.price} of ${car?.name}")
处理对象时，需要指定用于查找最大值的属性。 `maxBy()`方法具有选择器功能，用于选择汽车的`price`属性。
```
```kt
23
The max price is 18600 of Mercedes
......@@ -847,7 +847,7 @@ The max price is 18600 of Mercedes
`Car.kt`
```
```kt
package com.zetcode.bean
data class Car(var name: String, var price: Int)
......@@ -858,7 +858,7 @@ data class Car(var name: String, var price: Int)
`KotlinListFilter.kt`
```
```kt
package com.zetcode
import com.zetcode.bean.Car
......@@ -890,21 +890,21 @@ fun main(args: Array<String>) {
该示例展示了对 Kotlin 列表的过滤操作。
```
```kt
val words2 = words.filter { e -> e.length == 3 }
```
`filter()`方法采用谓词功能作为参数。 谓词给出了元素必须满足的条件。 我们过滤掉长度等于 3 的单词。
```
```kt
val words3 = words.filterNot { e -> e.length == 3 }
```
`filterNot()`的作用相反：它允许通过不符合给定条件的元素。
```
```kt
val cars = listOf(Car("Mazda", 6300), Car("Toyota", 12400),
Car("Skoda", 5670), Car("Mercedes", 18600))
......@@ -914,7 +914,7 @@ val res = cars.filter { car -> car.price > 10000 }
这些行过滤掉价格大于 10000 的汽车对象。
```
```kt
pen cup dog
person cement coal spectacles
Car(name=Toyota, price=12400)
......@@ -930,7 +930,7 @@ Car(name=Mercedes, price=18600)
`KotlinListMap.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -945,7 +945,7 @@ fun main() {
我们有一个整数列表。 使用`map()`方法，我们将每个列表元素乘以 2。
```
```kt
[2, 4, 6, 8, 10, 12]
```
......@@ -958,7 +958,7 @@ fun main() {
`KotlinListReduce.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -978,21 +978,21 @@ fun main() {
在示例中，我们对整数和字符串列表使用 reduce 操作。
```
```kt
val sum = nums.reduce { total, next -> total + next }
```
我们计算值的总和。 `total`是累加器，`next`是列表中的下一个值。
```
```kt
val res = colours.reduceRight { next, total -> "$total-$next" }
```
`reduceRight()`从最后一个元素开始累加值，并从右到左对每个元素和当前累加器值进行运算。
```
```kt
45
black-blue-white-green-red
......@@ -1006,7 +1006,7 @@ black-blue-white-green-red
`KotlinListFold.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -1023,14 +1023,14 @@ fun main() {
我们有一份支出清单。 这些费用适用于初始可用现金金额。
```
```kt
val res = expenses.fold(cash) {total, next -> total - next}
```
利用`fold()`，我们从`cash`推算出所有费用，并返回剩余值。
```
```kt
370
```
......@@ -1043,7 +1043,7 @@ val res = expenses.fold(cash) {total, next -> total - next}
`KotlinListChunked.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -1059,14 +1059,14 @@ fun main() {
在示例中，我们有六个值的列表。 我们要实现以下操作：`1*2 + 3*4 + 5*6`。 为此，我们需要将列表分成两个值的块。
```
```kt
val res = nums.chunked(2).fold(0) { total, next -> total + next[0] * next[1] }
```
我们将列表分为两个元素的列表，然后对其进行折叠。 `next`是我们可以在其中使用索引操作的列表。
```
```kt
44
```
......@@ -1079,7 +1079,7 @@ val res = nums.chunked(2).fold(0) { total, next -> total + next[0] * next[1] }
`KotlinListPartition.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -1095,14 +1095,14 @@ fun main(args: Array<String>) {
我们有一个整数列表。 使用`partition()`方法，我们将列表分为两个子列表； 一个包含负值，另一个包含正值。
```
```kt
val (nums2, nums3) = nums.partition { e -> e < 0 }
```
使用解构声明，我们一次性将列表分为两部分。
```
```kt
[-5, -1, -6]
[4, 3, 2, 7, 8, 9]
......@@ -1116,7 +1116,7 @@ val (nums2, nums3) = nums.partition { e -> e < 0 }
`KotlinListGroupBy.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -1136,7 +1136,7 @@ fun main() {
该示例显示了如何使用`groupBy()`方法。
```
```kt
val nums = listOf(1, 2, 3, 4, 5, 6, 7, 8)
val res = nums.groupBy { if (it % 2 == 0) "even" else "odd" }
......@@ -1146,7 +1146,7 @@ println(res)
这些行创建了一个地图，该地图具有两个键：“偶数”和“奇数”。 “偶数”指向偶数值列表，“奇数”指向奇数值列表。
```
```kt
val words = listOf("as", "pen", "cup", "doll", "my", "dog", "spectacles")
val res2 = words.groupBy { it.length }
......@@ -1155,7 +1155,7 @@ val res2 = words.groupBy { it.length }
在这里，我们创建一个带有整数键的映射。 每个关键字将具有一定长度的单词分组。
```
```kt
{odd=[1, 3, 5, 7], even=[2, 4, 6, 8]}
{2=[as, my], 3=[pen, cup, dog], 4=[doll], 10=[spectacles]}
......@@ -1169,7 +1169,7 @@ val res2 = words.groupBy { it.length }
`KotlinListAny.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -1189,7 +1189,7 @@ fun main() {
该示例显示`any()`的用法。
```
```kt
val r2 = nums.any { e -> e < 0 }
```
......@@ -1202,7 +1202,7 @@ val r2 = nums.any { e -> e < 0 }
`KotlinListAll.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -1227,7 +1227,7 @@ fun main() {
该示例显示`all()`的用法。
```
```kt
// testing for positive only values
val r = nums.all { e -> e > 0 }
......@@ -1241,7 +1241,7 @@ val r = nums.all { e -> e > 0 }
`KotlinListDrop.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -1265,35 +1265,35 @@ fun main() {
该示例显示了不同放置操作的用法。
```
```kt
val nums2 = nums.drop(3)
```
使用`drop()`方法，我们排除了前三个元素。
```
```kt
val nums3 = nums.dropLast(3)
```
使用`dropLast()`方法，我们排除了最后三个元素。
```
```kt
val nums4 = nums.sorted().dropWhile { e -> e < 0 }
```
使用`dropWhile()`方法，我们排除了满足给定谓词功能的前 n 个元素。
```
```kt
val nums5 = nums.sorted().dropLastWhile { e -> e > 0 }
```
使用`dropLastWhile()`方法，我们排除了满足给定谓词功能的最后 n 个元素。
```
```kt
[2, 1, -1, 7, 6, -8, 9, -12]
[4, 5, 3, 2, 1, -1, 7, 6]
[1, 2, 3, 4, 5, 6, 7, 9]
......@@ -1309,7 +1309,7 @@ val nums5 = nums.sorted().dropLastWhile { e -> e > 0 }
`KotlinListTake.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -1339,35 +1339,35 @@ fun main() {
该示例显示了各种 take 方法的用法。
```
```kt
val nums2 = nums.take(3)
```
`take()`方法创建一个具有原始列表的前三个元素的新列表。
```
```kt
val nums3 = nums.takeLast(3)
```
`takeLast()`方法将最后一个元素放入新列表中。
```
```kt
val nums5 = nums.takeWhile { e -> e > 0 }
```
`takeWhile()`采用满足谓词功能的前 n 个元素。
```
```kt
val nums7 = nums.takeIf { e -> e.contains(6) }
```
如果满足谓词功能中的条件，则`takeIf()`方法将使用列表中的所有元素。
```
```kt
[4, 5, 3]
[-8, 9, -12]
[-12, -8, -1]
......
docs/kotlin/45.md
浏览文件 @ 722256e4
......@@ -16,7 +16,7 @@ Kotlin 区分只读地图和可变地图。 使用`mapOf()`创建只读映射，
`KotlinMapOf.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -32,7 +32,7 @@ fun main() {
该示例创建了两个地图。
```
```kt
{97=a, 98=b, 120=x}
{name=Luke, age=23}
......@@ -46,7 +46,7 @@ fun main() {
`KotlinHashMap.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -72,7 +72,7 @@ fun main() {
`KotlinMapSize.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -90,14 +90,14 @@ fun main() {
该示例计算映射对的数量。
```
```kt
val n = items.count { it.value > 10 }
```
使用`count()`方法，我们可以计算出大于十的值。
```
```kt
Map has 4 items
Map has 4 items
# of values greater that 10: 3
......@@ -112,7 +112,7 @@ Kotlin 映射具有可获取所有条目，键和值的属性。
`KotlinEntriesKeysValues.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -128,7 +128,7 @@ fun main() {
该示例使用`entries`，`keys`和`values`属性。
```
```kt
Entries: [coins=12, books=45, cups=33]
Keys:[coins, books, cups]
Values:[12, 45, 33]
......@@ -143,7 +143,7 @@ Values:[12, 45, 33]
`KotlinMutableMap.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -172,7 +172,7 @@ fun main() {
该示例创建一个可变映射并介绍其方法。
```
```kt
// user.put("location", "USA")
user["location"] = "USA"
println(user)
......@@ -181,21 +181,21 @@ println(user)
新对将添加到地图。 IntelliJ IDEA 建议分配操作。
```
```kt
user.remove("occupation")
```
用`remove()`删除一对。
```
```kt
user.clear()
```
用`clear()`删除所有对。
```
```kt
if (user.isEmpty()) {
println("empty")
} else {
......@@ -206,7 +206,7 @@ if (user.isEmpty()) {
`isEmpty()`方法检查映射是否为空。
```
```kt
{name=John Doe, occupation=programmer}
{name=John Doe, occupation=programmer, location=USA}
{name=John Doe, location=USA}
......@@ -223,7 +223,7 @@ empty
`KotlinMapGet.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -249,7 +249,7 @@ fun main() {
该示例从地图获取值。
```
```kt
// println(items.get("coins"))
println(items["coins"])
......@@ -257,14 +257,14 @@ println(items["coins"])
IntelliJ IDEA 建议使用索引操作代替`get()`。
```
```kt
println(items.getOrDefault("pens", 0))
```
`getOrDefault()`返回与键对应的值，或者如果不存在键，则返回指定的默认值。
```
```kt
val nOfPencils = items.getOrElse("pencils", {
0
})
......@@ -279,7 +279,7 @@ val nOfPencils = items.getOrElse("pencils", {
`KotlinMapContains.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -315,7 +315,7 @@ fun main() {
`KotlinMapForEach.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -329,7 +329,7 @@ fun main() {
该示例使用`forEach()`遍历地图。
```
```kt
There are 12 coins
There are 45 books
There are 33 cups
......@@ -345,7 +345,7 @@ There are 2 pens
`KotlinMapFilter.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -366,28 +366,28 @@ fun main() {
该示例过滤地图。
```
```kt
val filtered = items.filterKeys { it == "A" || it == "C" }
```
我们筛选出所有与指定键匹配的对。
```
```kt
val filtered2 = items.filterValues { it >= 70 }
```
我们筛选出所有与指定值匹配的对。
```
```kt
val filtered3 = items.filter { it.key == "A" || it.value == 50 }
```
在这里，我们筛选出与给定键或值匹配的所有对。
```
```kt
{A=90, C=70}
{A=90, B=80, C=70}
{A=90, E=50}
......@@ -402,7 +402,7 @@ val filtered3 = items.filter { it.key == "A" || it.value == 50 }
`KotlinSortedMap.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -418,7 +418,7 @@ fun main() {
该示例打印未排序和排序的地图。
```
```kt
{coins=12, books=45, cups=33, pens=2}
{books=45, coins=12, cups=33, pens=2}
......@@ -432,7 +432,7 @@ fun main() {
`KotlinMapAny.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -464,7 +464,7 @@ fun main() {
在该示例中，我们检查映射是否包含至少一个值 12，以及是否存在至少一个偶数值。
```
```kt
The map has value 12
The map has even value(s)
......
docs/kotlin/46.md
浏览文件 @ 722256e4
......@@ -12,7 +12,7 @@ Kotlin 区分只读集和可变集。 用`setOf()`创建只读集，用`mutableS
`KotlinSetOf.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -29,7 +29,7 @@ fun main(args: Array<String>) {
`KotlinSetNoDuplicates.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -42,7 +42,7 @@ fun main(args: Array<String>) {
即使我们在`setOf()`中添加了两支笔，也只有一支笔。
```
```kt
pen
cup
dog
......@@ -58,7 +58,7 @@ spectacles
`KotlinSetBasic.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -83,14 +83,14 @@ fun main(args: Array<String>) {
该示例创建了一组数字并计算了一些统计信息。
```
```kt
val nums = setOf(11, 5, 3, 8, 1, 9, 6, 2)
```
使用`setOf()`功能创建 Kotlin 只读集。
```
```kt
val len = nums.count()
val max = nums.max()
val min = nums.min()
......@@ -101,7 +101,7 @@ val avg = nums.average()
我们计算值的数量，最大值，最小值，总和和平均值。
```
```kt
max: 11, min: 1,
count: 8, sum: 45,
average: 5.625
......@@ -116,7 +116,7 @@ average: 5.625
`KotlinSetIndex.kt`
```
```kt
package com.zetcode
fun main(args: Array<String&t;) {
......@@ -138,28 +138,28 @@ fun main(args: Array<String&t;) {
该示例介绍了 Kotlin Set 索引操作。
```
```kt
val w1 = words.elementAt(0)
```
使用`elementAt()`方法检索元素。 该方法将要检索的元素的索引作为参数。
```
```kt
val i1 = words.indexOf("cup")
```
`indexOf()`返回单词在集合中首次出现的索引。
```
```kt
val i2 = words.lastIndexOf("cup")
```
`lastIndexOf()`返回该单词在集合中最后一次出现的索引。
```
```kt
pen
The first index of cup is 1
The last index of cup is 1
......@@ -174,7 +174,7 @@ The last index of cup is 1
`KotlinSetCount.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -198,7 +198,7 @@ fun main(args: Array<String>) {
该示例返回集合中值的数量，负值的数量和偶数的数量。
```
```kt
val len = nums.count()
println("There are $len elements")
......@@ -209,21 +209,21 @@ println("The size of the set is $size")
我们可以使用`count()`方法或`size`属性来确定集合中元素的数量。
```
```kt
val n1 = nums.count { e -> e < 0 }
```
`count()`可以将谓词功能作为参数。 在我们的情况下，它对于小于 0 的值返回 true。
```
```kt
val n2 = nums.count { e -> e % 2 == 0 }
```
我们得到集合中偶数的数量。
```
```kt
There are 11 elements
The size of the set is 11
There are 3 negative values
......@@ -239,7 +239,7 @@ There are 5 even values
`KotlinSetFirstLast.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -264,35 +264,35 @@ fun main(args: Array<String>) {
该示例创建了一组单词。 我们得到集合的第一个和最后一个元素。
```
```kt
val w1 = words.first()
```
我们用`first()`获得第一个元素。
```
```kt
val w2 = words.last()
```
我们用`last()`获得最后一个元素。
```
```kt
val w3 = words.findLast { w -> w.startsWith('d') }
```
我们以`findLast()`检索以'd'开头的集合的最后一个元素。
```
```kt
val w4 = words.first { w -> w.startsWith('d') }
```
我们以`first()`检索以'd'开头的集合的第一个元素。
```
```kt
pen
spectacles
donkey
......@@ -308,7 +308,7 @@ Set 迭代或 Set 循环是一个遍历 set 元素的过程。
`KotlinSetIterate.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -350,14 +350,14 @@ fun main(args: Array<String>) {
该示例显示了在 Kotlin 中循环播放集合的五种方法。
```
```kt
words.forEach { e -> print("$e ") }
```
`forEach()`对每个设置的元素执行给定的动作。 我们为它传递了一个匿名函数，该函数将打印当前元素。
```
```kt
for (word in words) {
print("$word ")
......@@ -367,7 +367,7 @@ for (word in words) {
我们用`for`循环设置。 `for`循环逐个遍历设置的元素； 在每个循环中，`word`变量指向集合中的下一个元素。
```
```kt
for (i in 0 until words.size) {
print("${words.elementAt(i)} ")
......@@ -377,14 +377,14 @@ for (i in 0 until words.size) {
另一种`for`循环利用集合的大小。 `until`关键字创建一系列设置的索引。
```
```kt
words.forEachIndexed({i, e -> println("$i - $e")})
```
使用`forEachIndexed()`方法，我们遍历具有每次迭代可用索引和值的集合。
```
```kt
val it: Iterator<String> = words.asIterable().iterator()
while (it.hasNext()) {
......@@ -397,7 +397,7 @@ while (it.hasNext()) {
最后一种方法是使用`Iterator`和`while`循环。
```
```kt
pen cup dog person cement coal spectacles
pen cup dog person cement coal spectacles
pen cup dog person cement coal spectacles
......@@ -420,7 +420,7 @@ pen cup dog person cement coal spectacles
`Car.kt`
```
```kt
package com.zetcode.bean
data class Car(var name: String, var price: Int)
......@@ -431,7 +431,7 @@ data class Car(var name: String, var price: Int)
`KotlinSetSorting.kt`
```
```kt
package com.zetcode
import com.zetcode.bean.Car
......@@ -465,28 +465,28 @@ fun main(args: Array<String>) {
该示例按升序和降序对集合值进行排序，反转集合元素，并按名称对汽车对象进行排序。
```
```kt
val sortAsc = nums.sorted()
```
`sorted()`方法返回根据自然排序顺序排序的所有元素的列表。
```
```kt
val sortDesc = nums.sortedDescending()
```
`sortedDescending()`方法返回所有元素按照其自然排序顺序降序排列的列表。
```
```kt
val revNums = nums.reversed()
```
`reversed()`方法返回具有相反顺序元素的列表。
```
```kt
val cars = setOf(Car("Mazda", 6300), Car("Toyota", 12400),
Car("Skoda", 5670), Car("Mercedes", 18600))
......@@ -494,21 +494,21 @@ val cars = setOf(Car("Mazda", 6300), Car("Toyota", 12400),
我们创建了一组汽车对象。 这些对象可以按名称或价格排序。
```
```kt
val res = cars.sortedBy { car -> car.name }
```
使用`sortedBy()`，我们按名称对汽车进行升序排序。
```
```kt
val res2 = cars.sortedByDescending { car -> car.name }
```
使用`sortedByDescending()`，我们按名称对汽车进行降序排序。
```
```kt
[1, 2, 3, 5, 6, 8, 9, 11]
[11, 9, 8, 6, 5, 3, 2, 1]
[2, 6, 9, 1, 8, 3, 5, 11]
......@@ -532,7 +532,7 @@ Car(name=Mazda, price=6300)
`KotlinSetContains.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -554,21 +554,21 @@ fun main(args: Array<String>) {
可以检查一组是否包含一个或多个元素。
```
```kt
val r = nums.contains(4)
```
在这里，我们检查`nums`集是否包含 4。该方法返回布尔值。
```
```kt
val r2 = nums.containsAll(setOf(1, -1))
```
此行检查集合是否包含两个值：1 和-1。
```
```kt
The set contains 4
The set contains -1 and 1
......@@ -582,7 +582,7 @@ The set contains -1 and 1
`KotlinListMutable.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -613,14 +613,14 @@ fun main(args: Array<String>) {
该示例创建一个可变集并介绍其几种方法。
```
```kt
val nums = mutableSetOf(3, 4, 5)
```
我们创建了三个整数元素的可变集合。
```
```kt
nums.add(6)
nums.add(7)
nums.addAll(setOf(8, 9, 10))
......@@ -629,14 +629,14 @@ nums.addAll(setOf(8, 9, 10))
`add()`在集合的末尾添加一个新元素。 `addAll()`在集合的末尾添加了多个元素。
```
```kt
nums.clear()
```
`clear()`方法从集合中删除所有元素。
```
```kt
if (nums.isEmpty()) println("The set is empty")
else println("The set is not epty")
......@@ -644,7 +644,7 @@ else println("The set is not epty")
使用`isEmpty()`方法，我们检查集合是否为空。
```
```kt
[3, 4, 5, 6, 7, 8, 9, 10]
[3, 4, 5, 6, 7, 8, 9]
[]
......@@ -660,7 +660,7 @@ The set is empty
`KotlinSetUnion.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -677,7 +677,7 @@ fun main(args: Array<String>) {
在示例中，我们有两组整数。 我们将集合与`union()`方法结合在一起。
```
```kt
[1, 2, 3, 4, 5]
```
......@@ -690,7 +690,7 @@ fun main(args: Array<String>) {
`Car.kt`
```
```kt
package com.zetcode.bean
data class Car(var name: String, var price: Int)
......@@ -701,7 +701,7 @@ data class Car(var name: String, var price: Int)
`KotlinSetMax.kt`
```
```kt
package com.zetcode
import com.zetcode.bean.Car
......@@ -723,7 +723,7 @@ fun main(args: Array<String>) {
该示例查找一组整数和一组汽车对象的最大值。
```
```kt
val nums = setOf(11, 5, 23, 8, 1, 9, 6, 2)
println(nums.max())
......@@ -732,7 +732,7 @@ println(nums.max())
使用`max()`可以轻松找到一组整数的最大值。
```
```kt
val cars = setOf(Car("Mazda", 6300), Car("Toyota", 12400),
Car("Skoda", 5670), Car("Mercedes", 18600))
......@@ -743,7 +743,7 @@ println("The max price is ${car?.price} of ${car?.name}")
处理对象时，需要指定用于查找最大值的属性。 `maxBy()`方法具有选择器功能，用于选择汽车的`price`属性。
```
```kt
23
The max price is 18600 of Mercedes
......@@ -757,7 +757,7 @@ The max price is 18600 of Mercedes
`Car.kt`
```
```kt
package com.zetcode.bean
data class Car(var name: String, var price: Int)
......@@ -768,7 +768,7 @@ data class Car(var name: String, var price: Int)
`KotlinListFilter.kt`
```
```kt
package com.zetcode
import com.zetcode.bean.Car
......@@ -800,21 +800,21 @@ fun main(args: Array<String>) {
该示例介绍了对 Kotlin 集的过滤操作。
```
```kt
val words2 = words.filter { e -> e.length == 3 }
```
`filter()`方法采用谓词功能作为参数。 谓词给出了元素必须满足的条件。 我们过滤掉长度等于 3 的单词。
```
```kt
val words3 = words.filterNot { e -> e.length == 3 }
```
`filterNot()`的作用相反：它允许通过不符合给定条件的元素。
```
```kt
val cars = setOf(Car("Mazda", 6300), Car("Toyota", 12400),
Car("Skoda", 5670), Car("Mercedes", 18600))
......@@ -824,7 +824,7 @@ val res = cars.filter { car -> car.price > 10000 }
这些行过滤掉价格大于 10000 的汽车对象。
```
```kt
pen cup dog
person cement coal spectacles
Car(name=Toyota, price=12400)
......@@ -840,7 +840,7 @@ Car(name=Mercedes, price=18600)
`KotlinListMap.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -855,7 +855,7 @@ fun main(args: Array<String>) {
我们有一组整数。 使用`map()`方法，我们将每个 set 元素乘以 2。该方法将重建一个新列表。
```
```kt
[2, 4, 6, 8, 10, 12]
```
......@@ -868,7 +868,7 @@ fun main(args: Array<String>) {
`KotlinSetReduce.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -883,14 +883,14 @@ fun main(args: Array<String>) {
在示例中，我们对一组整数使用 reduce 操作。
```
```kt
val sum = nums.reduce { total, next -> total + next }
```
我们计算值的总和。 `total`是累加器，`next`是列表中的下一个值。
```
```kt
45
```
......@@ -903,7 +903,7 @@ val sum = nums.reduce { total, next -> total + next }
`KotlinSetFold.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -920,14 +920,14 @@ fun main(args: Array<String>) {
我们有一套费用。 这些费用适用于初始可用现金金额。
```
```kt
val res = expenses.fold(cash) {total, next -> total - next}
```
利用`fold()`，我们从`cash`推算出所有费用，并返回剩余值。
```
```kt
370
```
......@@ -940,7 +940,7 @@ val res = expenses.fold(cash) {total, next -> total - next}
`KotlinSetChunked.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -956,14 +956,14 @@ fun main(args: Array<String>) {
在示例中，我们有一组六个值。 我们要实现以下操作：`1*2 + 3*4 + 5*6`。 为此，我们需要将列表分成两个值的块。
```
```kt
val res = nums.chunked(2).fold(0) { total, next -> total + next[0] * next[1] }
```
我们将集合拆分为两个元素的列表，然后对其进行折叠。 `next`是我们可以在其中使用索引操作的列表。
```
```kt
44
```
......@@ -976,7 +976,7 @@ val res = nums.chunked(2).fold(0) { total, next -> total + next[0] * next[1] }
`KotlinSetPartition.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -993,14 +993,14 @@ fun main(args: Array<String>) {
我们有一组整数。 使用`partition()`方法，我们将集合分为两个子列表： 一个包含负值，另一个包含正值。
```
```kt
val (nums2, nums3) = nums.partition { e -> e < 0 }
```
使用解构声明，我们将集合一次性分成两部分。
```
```kt
[-5, -1, -6]
[4, 3, 2, 7, 8, 9]
......@@ -1014,7 +1014,7 @@ val (nums2, nums3) = nums.partition { e -> e < 0 }
`KotlinSetGroupBy.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -1034,7 +1034,7 @@ fun main(args: Array<String>) {
该示例显示了如何使用`groupBy()`方法。
```
```kt
val nums = setOf(1, 2, 3, 4, 5, 6, 7, 8)
val res = nums.groupBy { if (it % 2 == 0) "even" else "odd" }
......@@ -1044,7 +1044,7 @@ println(res)
这些行创建了一个地图，该地图具有两个键：“偶数”和“奇数”。 “偶数”指向偶数值列表，“奇数”指向奇数值列表。
```
```kt
val words = setOf("as", "pen", "cup", "doll", "my", "dog", "spectacles")
val res2 = words.groupBy { it.length }
......@@ -1053,7 +1053,7 @@ val res2 = words.groupBy { it.length }
在这里，我们创建一个带有整数键的映射。 每个关键字将具有一定长度的单词分组。
```
```kt
{odd=[1, 3, 5, 7], even=[2, 4, 6, 8]}
{2=[as, my], 3=[pen, cup, dog], 4=[doll], 10=[spectacles]}
......@@ -1067,7 +1067,7 @@ val res2 = words.groupBy { it.length }
`KotlinSetAny.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -1086,7 +1086,7 @@ fun main(args: Array<String>) {
该示例显示`any()`的用法。
```
```kt
val r2 = nums.any { e -> e < 0 }
```
......@@ -1099,7 +1099,7 @@ val r2 = nums.any { e -> e < 0 }
`KotlinSetAll.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -1124,7 +1124,7 @@ fun main(args: Array<String>) {
该示例显示`all()`的用法。
```
```kt
// testing for positive only values
val r = nums.all { e -> e > 0 }
......@@ -1138,7 +1138,7 @@ val r = nums.all { e -> e > 0 }
`KotlinSetDrop.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -1159,28 +1159,28 @@ fun main(args: Array<String>) {
该示例显示了不同放置操作的用法。
```
```kt
val nums2 = nums.drop(3)
```
使用`drop()`方法，我们排除了前三个元素。
```
```kt
val nums3 = nums.sorted().dropWhile { e -> e < 0 }
```
使用`dropWhile()`方法，我们排除了满足给定谓词功能的前 n 个元素。
```
```kt
val nums4 = nums.sorted().dropLastWhile { e -> e > 0 }
```
使用`dropLastWhile()`方法，我们排除了满足给定谓词功能的最后 n 个元素。
```
```kt
[2, 1, -1, 7, 6, -8, 9, -12]
[1, 2, 3, 4, 5, 6, 7, 9]
[-12, -8, -1]
......@@ -1195,7 +1195,7 @@ val nums4 = nums.sorted().dropLastWhile { e -> e > 0 }
`KotlinSetTake.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -1222,28 +1222,28 @@ fun main(args: Array<String>) {
该示例显示了各种 take 方法的用法。
```
```kt
val nums2 = nums.take(3)
```
`take()`方法创建一个具有原始集合的前三个元素的新列表。
```
```kt
val nums4 = nums.takeWhile { e -> e > 0 }
```
`takeWhile()`采用满足谓词功能的前 n 个元素。
```
```kt
val nums6 = nums.takeIf { e -> e.contains(6) }
```
如果满足谓词函数中的条件，则`takeIf()`方法将使用集合的所有元素。
```
```kt
[4, 5, 3]
[-12, -8, -1]
[4, 5, 3, 2, 1]
......
docs/kotlin/47.md
浏览文件 @ 722256e4
......@@ -14,7 +14,7 @@ Kotlin 由 JetBrains 创建。 Kotlin 是一种面向对象的功能编程语言
`kotlin_if.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -40,7 +40,7 @@ fun main() {
在示例中，我们提示输入用户的年龄。 我们读取该值，将其转换为整数，然后存储在变量中。
```
```kt
if (age > 18) {
println("You can obtain a driving licence")
......@@ -59,7 +59,7 @@ if (age > 18) {
`ifelseif.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -89,7 +89,7 @@ Kotlin 的 if 是一个表达式，即它返回一个值。
`if_expression.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -114,7 +114,7 @@ Kotlin 的`when`表达式用于评估多个条件。 它是 Java `switch`语句
`when_expression.kt`
```
```kt
package com.zetcode
import java.util.Random
......@@ -140,7 +140,7 @@ fun main() {
`while_loop.kt`
```
```kt
package com.zetcode
fun main() {
......@@ -160,7 +160,7 @@ fun main() {
该示例使用 while 循环从一到十打印值。
```
```kt
while(i < 10) {
```
......@@ -173,7 +173,7 @@ while(i < 10) {
`for_loop.kt`
```
```kt
package com.zetcode
fun main() {
......
docs/kotlin/48.md
浏览文件 @ 722256e4
......@@ -14,7 +14,7 @@ Kotlin 是一种在 Java 虚拟机上运行的静态类型的编程语言。
`writefile.kt`
```
```kt
package com.zetcode
import java.io.File
......@@ -37,21 +37,21 @@ fun main(args: Array<String>) {
该示例使用`PrintWriter`将两行写入文件。
```
```kt
val fileName = "src/resources/myfile.txt"
```
我们写入`src/resources/myfile.txt`文件。
```
```kt
myfile.printWriter().use { out ->
```
`printWriter()`返回用于将内容写入文件的`PrintWriter`。 `use()`方法在文件上执行给定的块功能，然后将其关闭。
```
```kt
out.println("First line")
out.println("Second line")
......@@ -65,7 +65,7 @@ out.println("Second line")
`writefile2.kt`
```
```kt
package com.zetcode
import java.io.File
......@@ -88,7 +88,7 @@ fun main(args: Array<String>) {
该示例使用`BufferedWriter`将两行写入文件。
```
```kt
myfile.bufferedWriter().use { out ->
```
......@@ -101,7 +101,7 @@ myfile.bufferedWriter().use { out ->
`writefile3.kt`
```
```kt
package com.zetcode
import java.io.File
......@@ -128,7 +128,7 @@ fun main(args: Array<String>) {
`writefile4.kt`
```
```kt
package com.zetcode
import java.io.File
......@@ -149,7 +149,7 @@ fun main(args: Array<String>) {
该示例写入具有 Kotlin `Files.write()`扩展功能的文件。
```
```kt
Files.write(myfile.toPath(), content.toByteArray(), StandardOpenOption.APPEND)
```
......
docs/kotlin/49.md
浏览文件 @ 722256e4
......@@ -10,7 +10,7 @@ Kotlin 读取文件教程显示了如何在 Kotlin 中读取文件。 我们展
`thermopylae.txt`
```
```kt
The Battle of Thermopylae was fought between an alliance of Greek city-states,
led by King Leonidas of Sparta, and the Persian Empire of Xerxes I over the
course of three days, during the second Persian invasion of Greece.
......@@ -25,7 +25,7 @@ course of three days, during the second Persian invasion of Greece.
`readfile.kt`
```
```kt
package com.zetcode
import java.io.File
......@@ -49,7 +49,7 @@ fun main(args: Array<String>) {
`readfile2.kt`
```
```kt
package com.zetcode
import java.io.File
......@@ -69,21 +69,21 @@ fun main(args: Array<String>) {
该示例读取文件并将其打印到控制台。 我们在输出中添加行号。
```
```kt
val myList = mutableListOf<String>()
```
可变列表已创建。
```
```kt
File(fileName).useLines { lines -> myList.addAll(lines) }
```
使用`File.useLines()`，我们将行列表复制到上面创建的可变列表中。
```
```kt
myList.forEachIndexed { i, line -> println("${i}: " + line) }
```
......@@ -96,7 +96,7 @@ myList.forEachIndexed { i, line -> println("${i}: " + line) }
`readfile3.kt`
```
```kt
package com.zetcode
import java.io.File
......@@ -120,7 +120,7 @@ fun main(args: Array<String>) {
`readfile4.kt`
```
```kt
package com.zetcode
import java.io.File
......@@ -142,14 +142,14 @@ fun main(args: Array<String>) {
该示例从`File`创建`InputStream`并从中读取字节。 字节转换为文本。
```
```kt
var ins: InputStream = myFile.inputStream()
```
从`File`和`inputStream()`创建一个`InputStream`。
```
```kt
var content = ins.readBytes().toString(Charset.defaultCharset())
```
......@@ -162,7 +162,7 @@ var content = ins.readBytes().toString(Charset.defaultCharset())
`readfile5.kt`
```
```kt
package com.zetcode
import java.io.File
......
docs/kotlin/50.md
浏览文件 @ 722256e4
......@@ -10,7 +10,7 @@ Kotlin 正则表达式教程展示了如何在 Kotlin 中使用正则表达式
在 Kotlin 中，我们使用`Regex`构建正则表达式。
```
```kt
Regex("book")
"book".toRegex()
Regex.fromLiteral("book")
......@@ -46,7 +46,7 @@ Regex.fromLiteral("book")
`KotlinRegexSimple.kt`
```
```kt
package com.zetcode
fun main(args : Array<String>) {
......@@ -79,14 +79,14 @@ fun main(args : Array<String>) {
在示例中，我们使用`matches()`和`containsMatchIn()`方法。 我们有一个单词表。 模式将使用这两种方法在每个单词中寻找一个“ book”字符串。
```
```kt
val pattern = "book".toRegex()
```
使用`toRegex()`方法创建正则表达式模式。 正则表达式由四个普通字符组成。
```
```kt
words.forEach { word ->
if (pattern.containsMatchIn(word)) {
println("$word matches")
......@@ -97,7 +97,7 @@ words.forEach { word ->
我们遍历列表，并对每个单词应用`containsMatchIn()`。
```
```kt
words.forEach { word ->
if (pattern.matches(word)) {
println("$word matches")
......@@ -108,7 +108,7 @@ words.forEach { word ->
我们再次遍历该列表，并对每个单词应用`matches()`。
```
```kt
*********************
containsMatchIn function
book matches
......@@ -131,7 +131,7 @@ book matches
`KotlinRegexFind.kt`
```
```kt
package com.zetcode
fun main(args : Array<String>) {
......@@ -159,7 +159,7 @@ fun main(args : Array<String>) {
在示例中，我们找到了“ fox”项匹配项的索引。
```
```kt
val found = pattern.find(text)
val m = found?.value
......@@ -169,7 +169,7 @@ val idx = found?.range
我们找到“ fox”一词的第一个匹配项。 我们得到它的值和索引。
```
```kt
val found2 = pattern.find(text, 11)
val m2 = found2?.value
......@@ -179,7 +179,7 @@ val idx2 = found2?.range
在第二种情况下，我们从索引 11 开始搜索，从而找到下一项。
```
```kt
fox found at indexes: 8..10
fox found at indexes: 29..31
......@@ -193,7 +193,7 @@ fox found at indexes: 29..31
`KotlinFindAll.kt`
```
```kt
package com.zetcode
fun main(args : Array<String>) {
......@@ -221,7 +221,7 @@ fun main(args : Array<String>) {
`KotlinRegexSplitting.js`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -239,21 +239,21 @@ fun main(args: Array<String>) {
在示例中，我们找出“ fox”项的出现次数。
```
```kt
val pattern = "\\W+".toRegex()
```
该模式包含`\W`命名的字符类，代表非单词字符。 与`+`量词结合使用时，该模式会查找非单词字符，例如空格，逗号或点，这些字符通常用于分隔文本中的单词。 请注意，字符类是两次转义的。
```
```kt
val words = pattern.split(text).filter { it.isNotBlank() }
```
使用`split()`方法，我们将输入字符串分成单词列表。 此外，我们删除了空白的结尾词，该词是由于我们的文本以非单词字符结尾而创建的。
```
```kt
[I, saw, a, fox, in, the, wood, The, fox, had, red, fur]
```
......@@ -266,7 +266,7 @@ val words = pattern.split(text).filter { it.isNotBlank() }
`KotlinRegexCaseInsensitive.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -287,14 +287,14 @@ fun main(args: Array<String>) {
在示例中，无论大小写如何，我们都将模式应用于单词。
```
```kt
val pattern = "dog".toRegex(RegexOption.IGNORE_CASE)
```
我们使用`RegexOption.IGNORE_CASE`忽略输入字符串的大小写。
```
```kt
dog matches
Dog matches
DOG matches
......@@ -309,7 +309,7 @@ DOG matches
`KotlinRegexDotMeta.kt`
```
```kt
package com.zetcode
fun main(args : Array<String>) {
......@@ -331,7 +331,7 @@ fun main(args : Array<String>) {
在示例中，列表中有八个单词。 我们在每个单词上应用一个包含两个点元字符的模式。
```
```kt
prevent matches
eleven matches
......@@ -345,7 +345,7 @@ eleven matches
`KotlinRegexQMarkMeta.kt`
```
```kt
package com.zetcode
fun main(args : Array<String>) {
......@@ -367,7 +367,7 @@ fun main(args : Array<String>) {
在示例中，我们在点字符后添加问号。 这意味着在模式中我们可以有一个任意字符，也可以在那里没有任何字符。
```
```kt
seven matches
even matches
......@@ -381,7 +381,7 @@ even matches
`KotlinRegexMnQuantifier.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -405,14 +405,14 @@ fun main(args: Array<String>) {
在示例中，我们搜索具有三个或四个字符的单词。
```
```kt
val pattern = "\\w{3,4}".toRegex()
```
在模式中，我们将一个单词字符重复三到四次。 请注意，数字之间不能有空格。
```
```kt
pen matches
book matches
cool matches
......@@ -435,7 +435,7 @@ eyes matches
`KotlinRegexAnchors.kt`
```
```kt
package com.zetcode
fun main(args : Array<String>) {
......@@ -464,7 +464,7 @@ fun main(args : Array<String>) {
`KotlinRegexAlternations.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -487,7 +487,7 @@ fun main(args: Array<String>) {
列表中有八个名称。
```
```kt
val pattern = "Jane|Beky|Robert".toRegex()
```
......@@ -500,7 +500,7 @@ val pattern = "Jane|Beky|Robert".toRegex()
`KotlinRegexSubpatterns.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -526,14 +526,14 @@ fun main(args: Array<String>) {
该示例创建一个子模式。
```
```kt
val pattern = "book(worm|mark|keeper)?".toRegex()
```
正则表达式使用子模式。 它与书呆子，书签，簿记员和书本单词匹配。
```
```kt
book matches
bookshelf does not match
bookworm matches
......@@ -553,7 +553,7 @@ bookmark matches
`KotlinRegexChClass.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -575,7 +575,7 @@ fun main(args: Array<String>) {
在该示例中，我们使用字符类同时包含灰色和灰色单词。
```
```kt
val pattern = "gr[ea]y".toRegex()
```
......@@ -588,7 +588,7 @@ val pattern = "gr[ea]y".toRegex()
`KotlinRegexNamedClass.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -608,21 +608,21 @@ fun main(args: Array<String>) {
在示例中，我们在文本中搜索数字。
```
```kt
val pattern = "\\d+".toRegex()
```
`\d+`模式在文本中查找任意数量的数字集。
```
```kt
val found = pattern.findAll(text)
```
用`findAll()`查找所有匹配项。
```
```kt
2013
27
......@@ -638,7 +638,7 @@ val found = pattern.findAll(text)
`KotlinRegexCapturingGroups.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -660,14 +660,14 @@ representation of a regular expression.</p>"""
该代码示例通过捕获一组字符来打印提供的字符串中的所有 HTML 标签。
```
```kt
val found = pattern.findAll(content)
```
为了找到所有标签，我们使用`findAll()`方法。
```
```kt
<p>
<code>
</code>
......@@ -683,7 +683,7 @@ val found = pattern.findAll(content)
`KotlinRegexEmails.kt`
```
```kt
package com.zetcode
fun main(args: Array<String>) {
......@@ -709,7 +709,7 @@ fun main(args: Array<String>) {
本示例提供了一种可能的解决方案。
```
```kt
val pattern = "[a-zA-Z0-9._-]+@[a-zA-Z0-9-]+\\.[a-zA-Z.]{2,18}".toRegex()
```
......@@ -722,7 +722,7 @@ val pattern = "[a-zA-Z0-9._-]+@[a-zA-Z0-9-]+\\.[a-zA-Z.]{2,18}".toRegex()
最后一部分是顶级域名：`[a-zA-Z.]{2,18}`。 顶级域可以包含 2 到 18 个字符，例如 sk，net，信息，旅行，清洁，旅行保险。 最大长度可以为 63 个字符，但是今天大多数域都少于 18 个字符。 还有一个点字符。 这是因为某些顶级域包含两个部分： 例如 co.uk。
```
```kt
luke@gmail.com matches
andy@yahoocom does not match
34234sdfa#2345 does not match
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或