Kotlin学习_解构声明(Destructuring Declarations)

Kotlin1.1.3发布,Kotlin 插件现在支持在编辑器的提示中显示推导的变量、函数和参数类型。默认情况下该功能是禁用的,可以在编辑器的设置中启用它。

下面进入正文,有时候要获取一个对象的属性,会定义很多个变量,这样子就会很麻烦,而在Kotlin中有个很方便的用法,就是使用解构声明。

创建变量

在Java中创建多个变量

1
2
3
Person person = new Person("person", 1);
String name = person.getPerson();
int age = person.getAge();

而在Kotlin中创建变量的话是这样的

1
2
3
4
5
data class Person(val name: String, val age: Int)

val person = Person("jowan", 1)
var name = person.name
var age = person.age

使用解构变量,同时创建多个变量

1
2
3
4
5
6
7
data class Person(val name: String, val age: Int)

fun main(args: Array<String>) {
val (name, age) = Person("person", 1)
println(name) // 打印person
println(age) // 打印1
}

这种语法就是解构声明,解构声明可以一次创建多个变量,通常用于数据类当中。
我们来看一下解构声明跟普通变量创建的区别:

编译后的代码:

在声明数据类的时候,会自动生成componentN()方法,对应按声明顺序出现的所有属性,如name就是component1()age就是component2(),而解构声明的val (dName, dAge)事实上就是调用component1()component2()方法。

循环

解构声明同样可以用在循环当中:

1
2
3
4
5
6
7
8
9
10
11
12
data class Person(val name: String, val age: Int)

val list: List<Person> = listOf(Person("one", 1),
Person("two", 2),
Person("three", 3),
Person("four", 4))

fun main(args: Array<String>) {
list.forEach { (name, age) ->
println("name:$name, age:$age")
}
}

我们来看一下编译后的代码:

打印结果:
用于循环

函数

解构声明也可以用在函数中,从函数中返回值:

1
2
3
4
5
6
7
8
9
10
11
12
13
fun getPair(after: String?, afterAge: Int?): Pair<String, Int> {
var name = "wangzai"
var age = 23
// 处理返回的数据
name = after ?: name
age = afterAge ?: age
return Pair(name, age)
}

fun main(args: Array<String>) {
val (name, age) = getPair("jowan", null)
println("name:$name, age:$age") // 打印name:jowan, age:23
}

编译后的代码:

用于函数

Map

解构声明还可以Map中,前提条件是:

  • 通过提供一个iterator()函数将映射表示为一个值的序列
  • 通过提供函数component1()component2()来将每个元素呈现为一对

在Kotlin标准库里面自带有这样的扩展:

iterator

component

举个栗子:

1
2
3
4
5
6
7
val map: Map<String, Int> = mapOf("one" to 1, "two" to 2, "three" to 3, "four" to 4)

fun main(args: Array<String>) {
map.forEach { (name, age) ->
println("name:$name, age:$age")
}
}

编译后的代码:

下划线代替未使用变量(1.1版本)-Underscore for unused variables (since 1.1)

如果在解构声明中有用不到的变量,则可以使用下划线代替,如上面的栗子:

1
2
3
4
5
6
7
8
fun getPair(): Pair<String, Int> {
return Pair("one", 1)
}

fun main(args: Array<String>) {
val (_, age) = getPair()
println("age:$age") // 打印出age:1
}

来看看编译后的内容

可以看出没有声明使用下划线的变量。

在Lambda中的解构(1.1版本)-Destructuring in Lambdas (since 1.1)

如果Lambda具有Pair类型的参数(或Map.Entry或具有相应componentN函数的任何其他类型),则可以通过将它们放在括号中来引入几个新参数:

1
2
3
4
5
6
7
8
9
val map = mapOf(1 to 1, 2 to 2, 3 to 3)
map.forEach {
entry ->
println("${entry.value}!")
}
map.forEach {
a, b ->
println("$a!$b!")
}

注意声明参数和声明解构对之间的区别:
{ a -> ... }一个参数:

1
2
3
4
5
6
val map = mapOf(1 to 1, 2 to 2, 3 to 3)

map.forEach {
entry ->
println("${entry.value}!") // 打印1!2!3!
}

编译后的内容:

{ a, b -> ... }两个参数:

1
2
3
4
5
6
val map = mapOf(1 to 1, 2 to 2, 3 to 3)

map.forEach {
a, b ->
println("$a!$b!") // 打印1!1!2!2!3!3!
}

编译后的内容:

居然是这个样子的,我IDE是用IntelliJ IDEA的。

这时候怎么办呢?问了下大佬,大佬说可以换一种反编译的工具来看。。。

那么就换一种反编译的工具,在这里使用jd-gui来查看class文件里面的内容,打开jd-gui,然后把class文件拖进去就可以:

{ (a, b) -> ... } 一个Pair类型的解构:

1
2
3
4
5
6
val map = mapOf(1 to 1, 2 to 2, 3 to 3)

map.forEach {
(_, value) ->
println("$value!") // 打印1!2!3!
}

编译后的内容:

这里可以看出解构对两个参数的区别,解构对是通过调用iterator的,而两个参数则是通过调用BiConsumer里面的accept方法的。

{ (a, b), c -> ... }一个Pair类型的解构和一个参数:

1
2
3
4
5
val maps = mapOf((1 to 1) to 3, (2 to 2) to 2, (3 to 3) to 1)

maps.forEach { (a, b), c ->
println("$a!$b!$c") // 打印1!1!32!2!23!3!1
}

编译后的内容:

同样用jd-gui来看编译后的代码:

解构声明也可以指定解构的类型:

1
2
3
4
5
map.mapValues { (_, value) -> "$value!" }

map.mapValues { (_, value): Map.Entry<Int, String> -> "$value!" }

map.mapValues { (_, value: String) -> "$value!" }