Kotlin开发笔记:集合和逆变协变

Kotlin开发笔记:集合和逆变协变

Kotlin开发笔记:集合和逆变协变_第1张图片

Kotlin中的集合

基本的集合类型

Kotlin中的集合类型和Java差不多,不过有些在名称上可能有出入,下面是Kotlin中的一些基本集合类型:

类型 介绍
Pair 两个值的元组
Triple 三个值的元组
Array 经过索引的,固定大小的对象和基元集合
List 有序的对象集合
Set 无序的对象集合
Map 键值对对象集合

Kotlin中的视图

在Kotlin引入了视图的概念,简而言之,不同的视图类型会赋予我们对操作集合的不同权限。Kotlin中有两种不同的视图:只读或不可变视图,以及读写或可变视图

比如对于List来说,有两种视图,分别是List和MutableList,前者提供只读视图,后者提供读写视图。当我们用List视图时将无法修改列表,而用MutableList就可以。

    var li = listOf(1,2,3) as MutableList
    li.add(5)

比如我们运行上述代码就会报错,因为listOf函数会产生List视图的集合,这将导致我们无法修改列表,如果我们要续写就需要产生读写视图的列表:

    var li = mutableListOf(1,2,3) 
    li.add(5)

不过本质上这两种视图都是对List的引用,比如说我们可以用List视图引用同一个ArrayList:

    val ar = arrayListOf(1,2,3,4)
    val li:List<Int> = ar
    val li1:MutableList<Int> = ar

不过List视图的引用将无法修改列表本身。

Kotlin中的一些技巧

使用listOf等函数快速创建集合

这个其实在上面给的例子里已经体现了,我们可以使用arrayListOf,listOf等函数快速创建出我们想要的集合而无需再用构造函数。

使用to和mapOf快速创建表

Kotlin中提供了一个to拓展函数,这个函数将生成一个Pair类型的对象,比如

val p1 = "age" to 18

将会创建一个First为"age",Second为18的Pair对象。而这个对象又可以用于mapOf函数。这样我们就可以快速创建一个map,比如:

val mMap = mapOf("age" to 18,"code" to 10086)

这样就创建了一个键值对为< String , Int >类型的map,其中to之前的为Key,之后的为Value。

同时获取索引和值

在Java中,如果我们想要同时获取一个List的索引和值的话可能需要遍历或者采取别的手段来达到这个目的,而在Kotlin中,我们可以用解构来实现这个目的:

fun main() {
    val li = listOf("jack","anderson")
    for((index,value) in li.withIndex()){
        println("index : $index, value:$value")
    }
}

withIndex将返回一个包含键值对的对象,我们将其解构出来就可以同时获得索引和值了。

创建有规律的数组

接下来介绍的是如何创建出一个有规律的数字,比如我们可以创建出一个物的倍数的数组:

fun main() {
    val li = Array(5){index -> index * 5}
    for(value in li){
        println(value)
    }
}

Array括号后面的5是元素个数,index下标是从0开始,我们可以打印出值:
Kotlin开发笔记:集合和逆变协变_第2张图片
成功创建了一个包含五的倍数的数组,利用这个技巧我们再加上Array内置的一些方法,就可以实现许多计算,比如我们想要计算从1到5的平方和的话就可以直接这样写:

fun main() {
    val li = Array(5){index -> (index+1) * (index+1)}.sum()
    println(li)
}

使用in

在Java中如果我们想要判断一个元素是否在一个集合中,一般会使用contains方法,不过在Kotlin中提供了in运算符实现了同样的效果:

fun main() {
    val li = Array(5){index -> index*5}
    println(0 in li)
}

实际上在迭代时我们会用到in运算符也是这样。

Kotlin中的逆变和协变

什么是逆变和协变

首先我们需要介绍逆变和协变的概念,协变和逆变都是术语,前者指能够使用比原始指定的派生类型的派生程度更大(更具体的)的类型,后者指能够使用比原始指定的派生类型的派生程度更小(不太具体的)的类型。

以我的理解,协变应该接近于extend,而逆变接近于super。

默认情况下,在Java中泛型强制实行类型不变性–也就是说,如果泛型函数期望一个参数类型T,则不允许替换基类型T或者派生类型T,类型必须是完全预期的类型

实际上,在Java中我也没有对通配符和一般的泛型T的区别和相同有什么很深的理解。我的理解是,通配符?代表不确定的类型,泛型类型T代表确定的类型

类型不变性

这里再介绍一下类型不变性,当一个方法接收到一个类型为T的对象(确定对象,不是泛型对象)时,我们可以传入为T类型或者是T的子类的对象。比如如果一个方法接收一个Animal类型的对象,那么身为Animal子类的Cat类型的对象也可以被传进去。

但是,如果这个方法接收的是一个泛型类型为T的对象,那么将不允许传递派生类型为T的泛型对象。比如,如果可以传递List< Animal >类型的对象,那么将不允许传入List< Cat >类型的对象,这和Java中的类型擦除有关。

书上的一个例子我觉得很形象,比如说我们创建一个Fruit类和两个继承它的类还有一个接收水果的方法:

open class Fruit
class Orange:Fruit()
class Banana:Fruit()

fun receiveFruits(fruits:Array<Fruit>){
    println("水果的数量是${fruits.size}")
}

这个方法可以接受泛型类型为Fruit的数组,如果我们传入Orange或者Banana会怎么样呢?
Kotlin开发笔记:集合和逆变协变_第3张图片
可以看到,编译器提示类型不匹配了。香蕉是从水果继承而来的,但是显然一篮子香蕉不是从一篮子水果继承而来的

不过一旦我们用list视图来操作,上述代码就不会报错了:
Kotlin开发笔记:集合和逆变协变_第4张图片
这是因为List视图只允许我们进行读而不允许我们进行写,这样是安全的。在Kotlin中,这个效果是由于List视图是out修饰的,我们将在后面的协变中介绍。
Kotlin开发笔记:集合和逆变协变_第5张图片

使用协变

上边介绍到了,一旦我们使用List视图,那么receiveFruits方法就可以被调用了,这正是由于使用了协变的原因。接下来我们创建一个方法来模拟协变的使用场景,比如我们想要把一个Fruit的Array复制到另一个Fruit的Array中:

fun copyFromTo(from:Array<Fruit>,to:Array<Fruit>){
    for(i in 0 until from.size){
        to[i] = from[i]
    }
}

这种情况下我们显然不能传入除Fruit类之外的泛型类,比如:
Kotlin开发笔记:集合和逆变协变_第6张图片
编译器是不会允许我们传入泛型类型为Banana的参数给from的,这个时候我们只需要修改一下这个函数,在传入的from参数处使用协变即可:

fun copyFromTo(from:Array<out Fruit>,to:Array<Fruit>){
    for(i in 0 until from.size){
        to[i] = from[i]
    }
}

Kotlin开发笔记:集合和逆变协变_第7张图片
这样编译器就不会报错了。要理解这个协变的含义我们可以从编译器为什么不让我们传入Banana类型的参数看。如果我们可以传入Banana类型的参数,我们就有可能对Banana执行一些Fruit层面的指令。

举个例子来说,大部分水果冲洗完成之后就可以直接食用了,但是香蕉的果皮较厚,我们就不能直接食用,在这之前还需要剥皮。身为子类的Banana肯定是有其特殊之处的,不能用基类Fruit的一些操作直接用在Banana上。但是如果我们不对这个Banana进行操作的话,那么就不会有什么大问题了,这就是协变的含义。

这里对copyFromTo方法的from参数加上out参数后就说明我们不会对这个from参数进行任何方法的调用了,我们只是单单读取这个参数,这样编译器就允许我们传入Fruit的子类的泛型类型了,换言之,我们就实现了协变。这种在使用泛型类型时使用协变的行为称之为“使用点型变”。

使用逆变

与协变相对的就是逆变了,如果说协变是只读不写的话,那么逆变就是只写不读。实际上也确实是这样,使用逆变将允许我们在该参数上进行设置值的方法调用,而不允许读取的方法。

我们依旧以上面的copyFromTo方法为例,现在我们希望可以将任意Fruit或者Fruit子类的元素复制到Fruit或Fruit超类的集合中,比如说我们传一个Any类的参数:
Kotlin开发笔记:集合和逆变协变_第8张图片
显然由于类型不变性这样是行不通的,在这里我们再次对copyFromTo方法做修改,这次我们对to参数使用逆变:

fun copyFromTo(from:Array<out Fruit>,to:Array<in Fruit>){
    for(i in 0 until from.size){
        to[i] = from[i]
    }
}

Kotlin开发笔记:集合和逆变协变_第9张图片
这样编译器就允许我们这样调用了。

使用Where的参数类型约束

这部分内容说白了就是约束泛型类型的范围,比如说我们有一个方法需要传入一个泛型类,这个泛型类需要实现AutoCloseable接口,那么我们就可以这样写

fun <T:AutoCloseable> useAndClose(input:T)
{
    input.close()
}

实际上上面的和Java中的写法也差不多,不过如果是一个泛型需要实现多个接口的话就不能这么写了,需要我们用where参数进行约束:

fun <T> useAndClose(input:T)
    where T:AutoCloseable,
        T:Appendable
{
    input.append("haha")
    input.close()
}

where约束跟在参数列表后面,花括号前面。约束参数中用逗号分隔。

星投影

星投影用<*>定义参数类型,它是指定泛型只读类型和原始类型的Kotlin等效物,**简单来说,我们可以用星投影捕获泛型类型,但是我们只能对捕获的泛型类型进行读取而不能修改。**当你想表达对类型不太了解但有希望类型安全时,请使用星投影,星投影只允许读出而不允许写入,比如:

fun printValues(values:Array<*>){
    for(value in values){
        println(value)
    }
}

在这个方法中我们用星投影捕获了泛型类型,但是我们只能读取values值不能写入或者更改values值,实际上就相当于out T,但是写起来更简洁。

你可能感兴趣的:(Kotlin学习笔记,kotlin,笔记,开发语言)