解构声明(Destructuring Declarations)

解构声明的概念和作用

把一个对象成员解构(destructure)成多个变量,称为解构声明(destructuring declaration)。

component1(),component2()等函数是Kotlin约定的操作符,componentN是操作符(类似加减乘除的运算符),重载操作符必须要用operator修饰以允许使用

class MyPair<K, V>(val first: K, val second: V) {
 operator fun component1(): K {
 return first;
 }

 operator fun component2(): V {
 return second;
 }
}

fun main(args: Array<String>) {
    val pair = MyPair(1, "one")
    val (num, name) = pair
 println("num = $num, name = $name")
}

数据类(data class)

编译器会为数据类(data class)自动声明/定义componentN()函数,可直接使用解构声明。

data class Person (val name: String,val age: Int,val addr:String){
}

fun main(args: Array<String>) {
   var person = Person("Jone", 20, "henan")
   println("name:${person.component1()},age:${person.component2()},addr:${person.component3()}")
}

函数返回多个变量(Return Values)

 如果需要一个函数返回多个变量,Kotlin最简洁的实现是声明一个数据类并返回其实例对象。

for循环-解构声明

 var personA: Person = Person("Door", 22, "ShanDong")
 var personB: Person = Person("Green", 30, "BeiJing")
 var personC: Person = Person("Dark", 23, "YunNan")
 var personD: Person = Person("Tool", 26, "GuanDong")
 var personE: Person = Person("Mark", 24, "TianJin")
 var pers = listOf(personA, personB, personC, personD, personE)
 for ((name, age,addr) in pers) {
     println("name:$name,age:$age,addr:$addr")
 }

自定义componentN

在Kotlin数据类中，编译器会根据主构造器中声明的全部属性, 自动推断产生componentN() 函数，但是对于普通类的成员属性，编译器并不会自动推断产生componentN() ，此时componentN()需要我们自己定义了。

data class Person (val name: String,val age: Int,val addr:String){
    var mobile: String ?= null
    operator fun component4(): String {
        return this.mobile!!
    }
}

fun main(args: Array<String>) {
    var person: Person = Person("Jone", 20, "ShangHai")
    person.mobile = "147323"
    var (name, age, addr, mobile) = person
    println("name: $name, age: $age, addr: $addr, mobile: $mobile")
}

对于自定义的componentN()，componentN()函数需要标记为 operator，才可以在解构声明中使用

Map-解构声明

在Kotlin的标准库中，对Map实现了这些扩展函数：

operator fun <K, V> Map<K, V>.iterator(): Iterator<Map.Entry<K, V>> = entrySet().iterator()

operator fun <K, V> Map.Entry<K, V>.component1() = getKey()

operator fun <K, V> Map.Entry<K, V>.component2() = getValue()

 也就是意味着：
- 实现 iterator() 函数, 使得 map 成为多个值构成的序列
- 实现 component1() 和 component2() 函数, 使得 map 内的每个元素成为一对值

这样，我们可以对 map 的for循环中自由地使用解构声明，例如:

fun main(args:Array<String>){
    val map = hashMapOf<String, Int>()
    map.put("one", 1)
    map.put("two", 2)
    for ((key, value) in map) {
        println("key = $key,value = $value")
    }
}