Kotlin泛型-你可能需要知道这些

96
24K男
2018.04.21 22:20 字数 2926

本博文主要讲解一些Kotlin泛型的问题,中间会对比穿插Java泛型。

1. 泛型类型参数

1.1 形式

我们使用泛型的形式无非是类、借口、方法几种,我们先看两个例子。

1.2 声明泛型类

和Java一样,我们通过在类名后面添加一对<>,并把类型参数放在<>内来声明泛型类和泛型接口。

一旦声明完成,我们就可以在类和接口内部,像使用其他类型一样使用类型参数了。

我们来看下标准的Java接口List如何使用Kotlin来声明。
Kotlin中List接口的定义。


public interface List<out E> : Collection<E> {
  
    override val size: Int

    override fun isEmpty(): Boolean
    override fun contains(element: @UnsafeVariance E): Boolean
    override fun iterator(): Iterator<E>
    override fun containsAll(elements: Collection<@UnsafeVariance E>): Boolean
    public operator fun get(index: Int): E
    public fun indexOf(element: @UnsafeVariance E): Int
    public fun lastIndexOf(element: @UnsafeVariance E): Int
    public fun listIterator(): ListIterator<E>
    public fun listIterator(index: Int): ListIterator<E>
    public fun subList(fromIndex: Int, toIndex: Int): List<E>
}

如果你的类继承了泛型类(或者实现了泛型接口),你就得为基础类型的泛型提供一个类型实参,它可以是一个具体的类型或者另外一个类型形参。

class StringList : List<String>{
    override fun get(index:Int):String =...
}

一个简单的泛型类定义:

class Pair<K, V>(key: K, value: V) {
    var key: K = key
    var value = value
}

1.3 泛型方法定义:

fun <T : Any> getClassName(clzObj: T): String {
    return clzObj.javaClass.simpleName
}

泛型T被声明在方法名前面。

泛型T默认为可空类型,并且我们限定了T继承Any,防止clzObj为空。

1.4 和Java泛型的不同之处

(1)和Java不同,Kotlin始终要求类型实参要么被显式的声明,要么能被编译器推到出来。

val readers : MutableList<String> = mutableListOf()
val readers = mutableListOf<String>()

上面这两行代码是等价的。

(2) Kotlin不支持原生类型

Kotlin一开始就有泛型,因此它不支持原生态类型,类型实参必须定义。


2. 类型参数约束

2.1 T上界指定

如果把一个类型指定为泛型类型形参的上界约束,在泛型具体的初始化时,其对应的泛型实参类型就必须为是这个具体类型或者其子类型。

Java中的形式: T extends Number

Kotlin中的形式: T : Number


fun <T : Number> List<T>.sum():T{
    //...
}

一旦指定了类型上界,你就可以在将T当做它的上界类型来使用。

如上面的例子,我们可以将T当作Number类型来使用。

2.2 为一个类型参数指定多个约束

fun <T> ensureTrailingPeriod(seq: T)
        where T : CharSequence, T : Appendable {
    //...
}

上面这个例子,指定了可以作为类型参数实参的类型必须实现了CharSequence和Appendable两个接口。

2.3 让类型形参非空

事实上,没有指定上界的类型形参将会使用Any?这个默认的上界。

看下面的这个例子:

class Processor<T> {
    fun process(value: T) {
        println(value?.hashCode())
    }
}

在process方法中,value是可空的,尽管T没有使用任何的?标记。

如果你想指定任何时候类型形参都是非空的,那么你可以通过指定一个约束来实现。

如果你除了可控性之外没有其他限制,可以使用Any代替默认的Any?作为其上界。

class Processor<T : Any> {
    fun process(value: T) {
        println(value.hashCode())
    }
}

注意:String?不是Any的子类型,它是Any?的子类型;String才是Any的子类型。


3. 运行时泛型

我们知道JVM上的泛型,一般是通过类型擦除来实现的,所以也被成为伪泛型,也就说类型实参在运行时是不保存的。

实际上,我们可以声明一个inline函数,使其类型实参不被擦除,但是这在Java中是不行的。

3.1 类型擦除

和Java一样,Kotlin的泛型在运行时也被擦除了,这意味着实例不会携带用于创建它的类型实参的信息。

例如你创建了一个List<String>并将一堆字符串保存其中,在运行时你只能看到一个List,不能辨别出列表本打算包含的是哪种类型的元素。

看起来类型擦除是不安全的,但在我们编码的时候,编译器是知道类型实参的类型的,确保你只能添加合适类型的元素。

类型擦除的好处就是节省内存。

3.1.1 is

因为类型擦除的原因,所以一般情况下,在is检查中不可能使用类型实参的类型。
对应的Java中,不能在一个确定泛型上执行instanceof操作。

Kotlin不允许使用没有指定类型实参的泛型类型。
那么你可能想知道如何检查一个值是否为列表,而不是Set或者其他对象,可以使用特殊的星号投影语法来做这个检查。

fun <T : Any> process(value: T) {
    if (value is List<String>) {
        // error
    }

    if (value is List<*>) {
        // ok
    }

    var list = listOf<Int>(1, 2, 3)
    if (list is List<Int>) {
        // ok
    }
}

Kotlin的编译器是足够聪明的,如果在编译期已经知道相应的类型信息时,is检查是被允许的。

List<*>相当于Java中的List<?>,拥有某个未知类型实参的泛型类型。
上面的例子中只是检查了value是否为List,而没有得到关于它的元素类型的任何信息。

3.1.2 as/as?

在as和as?转换中,我们仍然可以使用一般的泛型类型。

(1)如果该类有正确的基础类型但类型实参是错误的,转换也不会失败,因为在运行时类型实参是未知的(因为被擦除掉了),但是后面可能会出现ClassCastException。

(2)如果该类型基础类型都不正确的话,as?就会返回一个null值。


fun main(args: Array<String>) {
    var list: List<Int> = listOf(1, 2, 3)
    printSum(list)// 6

    var strList: List<String> = listOf("1", "2", "3")
    printSum(strList)// ClassCastException

    var intSet: Set<Int> = setOf(1, 2, 3)
    printSum(intSet) // IllegalStateException
}

fun printSum(c: Collection<*>) {
    val intList = c as? List<Int> ?:
            throw IllegalStateException("List is expected")
    println(intList.sum())
}

3.2 实化类型参数函数

泛型函数的类型实参,在运行时同样会被擦除。
只有一种特殊的情况:内联函数,内联函数的类型形参能够被实化,意味着在运行时,你可以引用实际的类型实参。


// compile error
fun <T> isA(value: Any) = value is T 

3.2.1 inline

如果使用inline标记函数,编译器会把每一次函数调用都替换为函数实际的代码。

lambda的代码也会被内联,不会创建任何匿名内部类。

inline函数大显身手的另一种场景:他们的类型参数可以被实化。

3.2.2 实化参数函数

inline fun <reified T> isA(value: Any) = value is T

一个实际的例子filterIsInstance:


public inline fun <reified R> Iterable<*>.filterIsInstance(): List<@kotlin.internal.NoInfer R> {
    return filterIsInstanceTo(ArrayList<R>())
}

public inline fun <reified R, C : MutableCollection<in R>> Iterable<*>.filterIsInstanceTo(destination: C): C {
    for (element in this) if (element is R) destination.add(element)
    return destination
}

简化Android的startActivity方法:

inline fun <reified T : Activity> Context.startActivity() {
    val intent = Intent(this,T::class.java)
    startActivity(intent)
}

3.2.2 为什么实化只对inline函数有效

这是什么原理呢?为什么inline函数中可以这样写element is R,而普通的函数不行呢?

正如之前描述的,编译器把实现inline行数的字节码插入到每一次调用发生的地方。
每次你调用带实例化类型参数的inline方法时,编译器都知道这次特定调用中用作类型实参的确切类型,因此编译器可以生成引用实际类型的字节码。

实化类型参数的inline函数不能在Java中调用,普通的内联函数可以在Java中被调用。


4. 变型:泛型和子类型化

4.1 子类和子类型

Int是Number的子类。

Int类型是Int?类型的子类型,他们都对应Int类。

一个非空类型是它的非空版本的子类型,但他们都对应同一个类。

List是一个类,List<String>\List<Int>是类型。

明白子类和子类型很重要。

4.2 不变型

一个泛型类,例如MutableList--如果对于任意的两个类型A和B,Mutable<A>既不是Mutable<B>的父类型,也不是它的父类型,那么该泛型类就称为在该类型参数是不变型。

Java中所有的类都是不变型的。

4.3 协变:保留子类型化

一个协变类是一个泛型类(我们以Poducer<T>类为例),如果A是B的子类型,那么Producer<A>也是Producer<B>的子类型;我们说子类型化被保留了。

Kotlin中,要声明在某个类型参数上是可以协变的,在该类型参数的名称前加out关键字即可:

interface Producer<out T> {
    fun produce(): T
}

一个不可变的例子:


open class Animal {
    open fun feed() {
        println("Animal is feeding.")
    }
}

class Herd<T : Animal> {
    val size: Int = 10
    fun get(index: Int): Animal? {
        return null
    }
}

fun feedAllAnimal(animals: Herd<Animal>) {
    for (i in 0 until animals.size) {
        animals.get(i)?.feed()
    }
}

class Cat : Animal() {
    override fun feed() {
        println("Cat is feeding.")
    }
}


fun takeCareOfCats(cats: Herd<Cat>) {
    feedAllAnimal(cats)//comile error
}


很遗憾,在上面的例子中我们不能把猫群当做动物群被照顾。

在没有使用任何通配符的类型参数上,泛型类在类型参数上是不变型的。

那么我们怎样才能让猫群也能被当做动物群被照顾呢,答案很简单,只需要修改Herd类如下即可:

class Herd<out T : Animal> {
    val size: Int = 10
    fun get(index: Int): Animal? {
        return null
    }
}

in & out

在类的成员声明中类型参数的使用位置可以分为in位置和out位置。

如果函数是把T当成返回类型,我们说它在out位置。

如果T用作函数参数类型,它就在in位置。

类的类型参数前使用out的关键字要求所有使用T的方法只能把T放在out位置上,而不能放在in位置。

现在考虑下,我们能否把MutableList<T>中的T声明为协变的?

答案是不能,因为MutableList既可以添加T元素,也可以获取T元素,因此T既出现在了out位置,也出现在了in位置。

在上面的分析中,我们已经看到过List接口的定义,List<T>在Kotlin中是只读的。

public interface List<out E> : Collection<E>{
    //....
}

我们来看下List和MutableList的定义:

public interface MutableList<E> : List<E>, MutableCollection<E>{
    override fun add(element: E): Boolean
    public fun removeAt(index: Int): E
}

方法的定义验证了我们前面的分析,MutableList的类型参数E既不能声明为out E,也不能声明为in E.

构造方法中的参数既不在in位置也不在out位置,即使类型参数声明为out,我们仍然可以在构造方法参数的声明中使用它。

对于类的var属性,我们不能使用out修饰属性的类型参数。
因为属性的setter方法在in位置上使用了类型参数,而getter方法在out位置使用了类型参数。

注意位置规则只覆盖了类外部可见(public\protected\internal)API,私有方法的参数既不在out位置也不在in位置。


// compile error
class Herd<out T : Animal>(var leadAnimal: T) {
    
}

// ok
class Herd<out T : Animal>(private var leadAnimal: T) {
    
}

4.4 翻转子类型化关系

逆变的概念可以看做是协变的镜像:对一个你逆变类来讲,它的子类型化关系与作用类型实参的类子类型化关系是相反的。

逆变类是一个泛型类(我们以Consumer为例),如果B是A的子类型,那么Consumer<A>是Consumer<B>的子类型。
类型A和B交换了位置,所以我们说子类型化被反转了。

逆变对应的关键字是in。

4.5 点变型:在类型出现的地方指定变型

fun <T : R, R> copyTo(source: MutableList<out T>, destination: MutableList<in T>) {
    source.forEach { item -> destination.add(item) }
}

我们说source不是一个普通的MutableList,而是一个投影(受限)的MutableList,只能调用返回类型是泛型参数的那些方法。

Kotlin中的MutableList<out T>和Java中的MutableList<? extends T>是一个意思。

Kotlin中的MutableList<in T>和Java中的MutableList<? super T>是一个意思。

MutableList<*>的投影为MutableList<out Any?>。

Kotlin中MyType<*>对应Java中的MyType<?>。

5. 总结

Kotlin的泛型和Java的泛型很多都是相同的,只是表现形式不太相同,我们对比学习来加深理解和记忆。

祝各位看官工作愉快。

技术积累
Web note ad 1