Kotlin基础（三）：表达式

前言

本文主要讲解常量和变量、分支表达式、运算符与中缀表达式、Lambda表达式、案例：为Person实现equals和hashCode、案例：为String实现四则运算

---

Kotlin文章列表

Kotlin文章列表: 点击此处跳转查看

---

目录

---

（一）常量和变量

（1）变量

java：

int a = 2;
a = 3;

final int b = 3;  // 只读变量

kotlin：

var a = 2
a = 3

val b = 3 // 只读变量

---

（2）常量

java：

static final int b = 3;   

kotlin：

const val b = 3
// 只能定义在全局范围  
// 只能修饰基本类型  
// 必须立即用突面量初始化

---

（二）分支表达式

（1）if…else…

java：

if (a == 3) {
    c = 4;
} else {
    c = 5;
}

c = a == 3 ? 4 : 5;

kotlin：

if (a == 3) {
    c = 4
} else {
    c = 5
}

c = if (a == 3) 4 else 5

---

（2）when…

java：

switch (a) {
    case 0:
        c = 5;
        break;

    case 1:
        c = 100;
        break;

    default:
        c = 20;
}

kotlin：

c = when (a) {
    0 -> 5
    1 -> 100
    else -> 20
}
如果a = 0，则c = 5
如果a = 1，则c = 100
...

var x: Any = Any()
c = when {
    x is String -> x.length
    x == 1 -> 100
    else -> 20
}

c = when(val input = readLine()){
    null -> 0
    else -> input.length
}

---

（3）try … catch

java：

try {
    c = a / b;
} catch (ArithmeticException | NullPointerException e) {
    e.printStackTrace();
    c = 0;
}

kotlin：

try {
    c = a / b
} catch (e: Exception) {
    e.printStackTrace()
    c = 0
}

c = try {
    a / b
} catch (e: ArithmeticException) {
    2 // 如果抛出异常，则c = 2
} catch (e: Exception) {
    e.printStackTrace()
    0 // 如果抛出异常，则c = 0
}

c = try {
    a / b
} catch (e: ArithmeticException) {
    2
} catch (e: Exception) {
    e.printStackTrace()
    0
}

---

（三）运算符与中缀表达式

（1）kotlin官方提供的运算符

"Hello" == "World"
"Hello".equals("World")

2 + 3
2.plus(3)


val list = listOf(1, 2, 3, 4)
2 in list
list.contains(2)


val map = mutableMapOf(
    "Hello" to 2,
    "World" to 3
)
val value = map["Hello"]
// val value = map.get("Hello")

map["World"] = 4
map.set("World", 4)


2 > 3
2.compareTo(3) > 0


val func = fun() {
    println("Hello")
}
func.invoke()
func()


2 to 3
2.to(3)

---

（2）中缀表达式

运算符的数量是有上限的，虽然跟随 Kotlin版本迭代会有相应的变化但是对开发者而言还是固定的，因此当运算符不够的时候我就需要通过中缀表达式的形式去扩展我们所需要的逻辑。两个重点：一是infix，二是函数名（rotate）

println("HelloWorld" rotate 5) // 对rotate的功能进行扩展

infix fun String.rotate(count: Int): String {
    val index = count % length
    return this.substring(index) + this.substring(0, index)
}


val book = Book()
val desk = Desk()
book on desk

class Book
class Desk

infix fun Book.on(desk: Desk) {

}

---

（四）Lambda表达式

（1）匿名函数

普通函数：

fun func() {
    println("Hello")
}

匿名函数：（没有函数名）

fun() {
    println("Hello")
}

匿名函数的使用：

val func = fun() { // func是变量名
    println("Hello")
}

func() // 用变量调用函数

匿名函数的类型：（最后一行返回值是什么类型，则匿名函数就是什么类型）

val func: () -> Unit = fun() {
    println("Hello")
}

---

（2）Lambda表达式

kotlin中Lambda表达式的本质其实是匿名函数，Lambda的出现确实是减少了代码量的编写，同时也是代码变得更加简洁明了

val func: () -> Unit = fun() {
    println("Hello")
}

val lambda: () -> Unit = {
    println("Hello")
}

val f1 = { p: Int ->
    println(p)
    "Hello"
}

---

（五）案例：为Person实现equals和hashCode

class Person(val age: Int, val name: String) {
    override fun equals(other: Any?): Boolean {
        val other = (other as? Person) ?: return false
        return other.age == age && other.name == name
    }

    override fun hashCode(): Int {
        return 1 + 7 * age + 13 * name.hashCode()
    }
}

fun main() {
    val persons = HashSet<Person>()

    (0..5).forEach {
        persons += Person(20, "Benny")
    }

    println(persons.size)  // 1
}

---

（六）案例：为String实现四则运算

operator fun String.minus(right: Any?)
        = this.replaceFirst(right.toString(), "")
// 把字符串中第一次出现right的位置，替换为空
// 例如字符串为HelloWorld World，right为Hello，则得到结果为World World

operator fun String.times(right: Int): String {
    return (1..right).joinToString(""){ this }
    // 将传入的字符重复right遍，以空格分隔（也可以以","分隔）
}

operator fun String.div(right: Any?): Int {
    val right = right.toString()
    // 第一个参数：传入字符串的长度
    // 第二个参数：每次向后滑动的步数（从第一位开始，如果参数是1，则判断结束后下次开始的位置是2）
    // 第三个参数：是否与传入的字符串相等
    // 例如传入ld，先判断He，是否与ld相等，如果相等则it + 1，如果不等向后移动一位
    // 判断el（注意不是ll）是否与ld相等，如果相等则it + 1，如果不等向后移动一位
    return this.windowed(right.length, 1, transform = {
        it == right
    }) // [false, false, false, false ... false, true, ..., true]
        .count { it }
}

fun main() {
    val value = "HelloWorld World"

    println(value - "World")
    println(value * 2)

    val star = "*"
    println("*" * 20)

    println(value / 3)
    println(value / "l")
    println(value / "ld")
}

结果：

Hello World
HelloWorld WorldHelloWorld World
********************
0
4
2