Kotlin教程(九)泛型

Kotlin系列之filter、find、any、map、flatMap、takeWhile、reduce、groupBy常见高阶函数 阅读详情

写在开头:本人打算开始写一个Kotlin系列的教程,一是使自己记忆和理解的更加深刻,二是可以分享给同样想学习Kotlin的同学。系列文章的知识点会以《Kotlin实战》这本书中顺序编写,在将书中知识点展示出来同时,我也会添加对应的Java代码用于对比学习和更好的理解。

Kotlin教程(一)基础
Kotlin教程(二)函数
Kotlin教程(三)类、对象和接口
Kotlin教程(四)可空性
Kotlin教程(五)类型
Kotlin教程(六)Lambda编程
Kotlin教程(七)运算符重载及其他约定
Kotlin教程(八)高阶函数
Kotlin教程(九)泛型


泛型类型参数

泛型允许你定义带_类型形参_的类型,当这种类型的实例被创建出来的时候,类型形参被替换成称为类型实参的具体类型。例如:

List<String>
Map<String, Person> 

和一般类型一样,Kotlin编译器也常常能推导出类型实参:

val authors = listOf("Dimtry", "Sevelana") 

如果你想创建一个空的列表,这样就没有任何可以推导出类型实参的线索,你就得显式地指定它(类型形参)。

val readers: MutableList<String> = mutableListOf()

val readers = mutableListOf<String>() 

和Java不同,Kotlin始终要求类型实参要么被显式地说明,要么能被编译器推导出来。因为泛型是1.5版本才引入到Java的,它必须保证和基于老版本的兼容,所以它允许使用没有类型参数的泛型类型——所谓的原生态类型。而Kotlin从一开始就有泛型,所以它不支持原生态类型,类型实参必须定义。

泛型函数和属性

如果要编写一个使用列表的函数,希望它可以在任何列表上使用,而不是某个具体类型的元素的列表,需要编写一个泛型函数。

fun <T> List<T>.slice(indices: IntReange): List<T> 

基本上是和Java的声明类似的,在方法名前声明,即可在函数中使用。

还可以给类或接口的方法,顶层函数,扩展属性以及扩展函数声明类型参数。例如下面你这个返回列表倒数第二个元素的扩展属性:

val <T> List<T>.penultimate: T
    get() = this[size -2] 

不能声明泛型非扩展属性

普通(非扩展)属性不能拥有类型参数,不能再一个类的属性中存储多个不同类型的值,因此声明泛型非扩展函数函数没有任何意义。

声明泛型类

和Java一样,Kotlin通过在类名称后面加上一对尖括号,并把类型参数放在尖括号内来声明泛型类及泛型接口。一旦声明之后,就可以在类的主体内像其他类型一样使用类型参数。

interface List<T> {
    operator fun get(index: Int): T
} 

如果你的类继承了泛型(或者实现了泛型接口),你就得为基础类型的泛型形参提供一个类型实参。

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

类型参数约束

类型参数约束可以限制作为(泛型)类和(泛型)函数的类型实参的类型。 如果你把一个类型指定为泛型类型形参的上界约束,在泛型类型具体的初始化中,其对应的类型实参就必须是这个具体类型或其子类型。你是这样定义约束:把冒号放在类型参数名称之后,作为类型形参上界的类型紧随其后:

fun <T : Number> List<T>.sum(): T 

相当于Java中的:

<T extends Number> T sum(List<T> list) 

一旦指定了类型形参T的上界,你就可以把类型T的值当做它的上界的值使用:

fun <T : Number> oneHalf(value: T): Double {
    return value.toDouble() //调用Number的方法
} 

极少数情况下,需要在一个类型参数上指定多个约束,这时你需要使用不同的语法:

fun <T> ensureTrailingPeriod(seq: T) 
    where T : CharSequence, T : Appendable {
    if(!seq.endWith('.') { //调用CharSequence的方法
        seq.append('.')//调用Appendable的方法
    }
} 

这种情况下,可以说明作为类型实参的类型必须同时实现CharSequence和Appendable两个接口。

让类型形参非空

如果你声明的时泛型类或者泛型函数,任何类型实参,包括哪些可空的类型实参,都可以替换她的类型形参。事实上没有指定上界的类型形参将会使用Any? 这个默认上界:

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

process函数中,参数value是可空的,尽管T并没有使用问号标记。

如果你想保证替换类型形参的始终是非空类型,可以通过制定一个约束来实现。如果你除了可空性之外没有任何限制,可以使用Any代替默认的Any?作为上界。

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

运行时的泛型:擦除和实化类型参数

你可能知道,JVM上的泛型一般是通过类型擦除实现的,就是说泛型类实例的类型实参在运行时是不保留的。

运行时的泛型:类型检查和转换

和Java一样,Kotlin的泛型在运行时也被擦除了。这意味着泛型类实例不会携带用于创建它的类型实参的信息。例如,如果你创建一个List<String>并将一堆字符串放到其中,在运行时你只能看到它是一个List,不能识别出列表本打算包含的时哪种类型的元素。
随着擦除类型信息也带来了约束。因为类型实参没有被存储下来,你不能检查他们。例如,你不能判断一个列表是一个包含字符串的列表还是包含其他对象的列表:

>>> if (value is List<String>)
ERROR: Canot check for instance of erased type 

那么如何检查一个值是否是列表,而不是set或者其他对象。可以使用特殊的*投影语法来做这样的检查:

if (value is List<*>) 

这种表示拥有未知类型实参的泛型类型,类似于Java中的List<?>。

注意,在as和as?转换中仍然可以使用一般的泛型类型。但是如果该类有正确的基础类型但类型实参是错误的,转换也不会失败,因为在运行时转换发生的时候类型实参是未知的。因此,这样的转换会导致编译器发出“unchecked cast”的警告。这仅仅是一个警告,你仍然可以继续使用这个值。

fun printSum(c: Collection<*>) {
    //这里会有警告:Unchecked cast:List<*> to List<Int>
    val intList = c as? List<Int> 
            ?: throw IllegalArgumentException("List is expected")
    println(intList.sum())
}

>>> printSum(listOf(1, 2, 3))
6 

编译一切正常:编译器只是发出了一个警告,这意味着代码是合法的。如果在一个整型的列表或者set上调用该函数,一切都会如预期发生:第一种情况会打印元素之和,第二种情况会抛出IllegalArgumentException异常。但如果你传递了一个错误类型的值,如List<String>,运行时会得到一个ClassCastException。

声明带实化类型参数的函数

前面说过,Kotlin泛型在运行时会被擦除,泛型函数的类型实参也是这样。在调用泛型函数的时候,在函数体中你不能决定调用它用的类型实参:

>>> fun <T> isA(value: Any) = value is T
Error: Cannot check for instance of erased type: T 

通常情况下都是这样的,只有一种例外可以避免这种限制:内联函数。内联函数的类型形参能够被实化,意味着你可以在运行时引用实际的类型实参。
在之前章节中,我们知道如果用inline关键字标记一个函数,编译器会把每一次函数调用都换成函数实际的代码实现。使用内联函数还可以提升性能,如果该函数使用了lambda实参:lambda的代码也会内联,所以不会创建任何匿名类。基于这种实现原理,应该也可以想象到,根据嵌入的上下文,泛型在class文件中已经被确定了。
如果把前面例子中的isA函数声明成inline并且用reified标记类型参数,你就能够用该函数检查value是不是T的实例了。

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

>>> println(isA<String>("abc"))
true
>>> println(isA<String>(123))
false 

一个实化类型参数能发挥作用的最简单的例子就是标准库函数filterIsInstance 。这个函数接收一个集合,选择其中哪些指定类的实例,然后返回这些被选中的实例。

>>> val items = listOf("one", 2, "three")
>>> println(items.filterIsInstance<String>())
[one, three] 

通过指定<String>作为函数的类型实参,你表明感兴趣的只是字符串。因此函数的返回类型是List<String>。这种情况下,类型实参在运行时是已知的,函数filterIsInstance使用它来检查列表中的值是不是指定为该类型实参的类的实例。
下面是Kotlin标准库函数filterIsInstance声明的简化版本:

inline fun <reified T> Iterable<*>.filterIsInstance(): List<T> {
    val destination = mutableListOf<T>()
    for (element in this) {
        if (element is T) {
            destination.add(element)
        }
    }
    return destination
} 

在之前章节,我们提到把函数标记成内联只有在一种情况下有性能优势,即函数拥有函数类型的形参并且其对应的实参lambda和函数一起被内联的时候。而现在我们是为了能够使用实化参数而把函数标记成内联。

为什么实化只对内联函数有效

编译器把实现内联函数的字节码插入每一次调用发生的地方。每次你调用带实化类型参数的函数时,编译器都知道这次特定调用中用作类型实参的切确类型。因此,编译器可以生成引用作为类型实参的具体类的字节码。实际对filterIsInstance<String>掉用来说,生成的代码和下面这段代码是等价的:

for (element in this) {
    if (element is String) {
        destination.add(element)
    }
} 

因为生成的字节码引用了具体类,而不是类型参数,它不会被运行时发生的类型参数擦除影响。
注意,带reified类型参数的inline函数不能再Java代码中调用。 普通内联函数可以像常规函数那样在Java中调用——他们可以被调用而不能被内联。带实化参数类型的函数需要额外的处理,来把类型参数的值替换到字节码中,所以他们必须永远是内联的。这样他们不可能用Java那样的普通方式调用。

使用实化类型参数代替类引用

如果你是Android开发者,显示Activity是一个最常用的方法。也可以使用实化类型参数来代替传递作为java.lang.Class的Activity类:

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

>>> startActivity 

::class.java的语法展现了如何获取java.lang.Class对应的Kotlin类。这和Java中的Service.class是完全等同的。

实化类型参数的限制

尽管实化类型参数是方便的工具,但它们也有一些限制。有一些事实化与生俱来的,而另外一些则是现有的实现决定的,而且可能在未来的Kotlin版本中放松这些限制。
具体来说,可以按下面的方式使用实化类型参数:

  • 用在类型检查和类型转换中(is、!is、as、as?)
  • 使用Kotlin反射API(::class)
  • 获取相应的java.lang.Class(::class.java)
  • 作为调用其他函数的类型实参

不能做下面的这些事情:

  • 创建指定为类型参数的类的实例
  • 调用类型参数类的伴生对象的方法
  • 调用带实化类型参数函数的时候使用非实化类型形参作为类型实参
  • 把类、属性或者非内联函数的类型参数标记成reified

变型:泛型和子类型化

变型的概念描述了拥有相同基础类型和不同类型实参的(泛型)类型之间是如何关联的:例如,List<String>和List<Any>之间如何关联。

为什么存在变型:给函数传递实参

假如你有一个接收List<Any>作为实参的函数。把List<String>类型的变量传给这个函数时候安全?毫无疑问,把一个字符串传给一个期望Any的函数是安全的,因为String继承了Any。但当String和Any变成List接口的类型实参之后,情况就没有这么简单了。

fun printContents(list: List<Any>) {
    println(list.joinToString())
}

>>> printContents(listOf("abc", "bac"))
abc, bac 

这看上去没什么问题,我们来看另一个例子:

fun addAnswer(list: MutableList<Any>) {
    list.add(42)
}

>>> val strings = mutableListOf("abc", "bac")
>>> addAnswer(strings)
Type mismatch. Required: MutableList<Any> Found: MutableList<String> 

这个例子和上面的例子中,区别仅仅是将List<Any>变成了MutableList<Any>,就无法将泛型为String的list传递给函数。
现在可以回答刚才那个问题了,把一个字符串列表传给期望Any对象列表的函数是否安全。如果函数添加或者替换了列表中的元素就是不安全的,因为这样会产生类型不一致的可能性。在Kotlin中,可以通过根据列表是否可变选择合适的接口来轻松的控制。如果函数接收的是只读列表,可以传递具有更具体的元素类型的列表。如果列表是可变的,就不能这么做。

类、类型和子类型

为了讨论类型之间的关系,需要熟悉子类型这个术语。任何时候如果需要的时类型A的值,你都能够使用类型B的值(当做A的值),类型B就称为类型A的子类型。举例来说,Int是Number的子类型,但Int不是String的子类型。这个定义还标明了任何类型都可以被认为是它自己的子类型。
术语超类型是子类型的反义词。如果A是B的子类型,那么B就是A的超类型。
为什么一个类型是否是另一个的子类型这么重要?编译器在每一次给变量赋值或者给函数传递实参的时候都要做这项检查。

fun test(i: Int) {
    val n: Number = i  //可以编译
    fun f(s: String) {/*...*/}
    f(i)  //不能编译
} 

只有值得类型是变量类型的子类型时,才允许变量存储该值。例如,变量n的初始化器i的类型Int是变量的类型Number的子类型,所以n的声明是合法的。只有当表达式的类型是函数参数的类型的子类型时,才允许把该表达式传给函数。这个例子中i的类型Int不是函数参数的类型String的子类型,所以函数f的调用会编译失败。
你可能认为子类型就是子类的概念,但是为什么在Kotlin中称之为子类型呢?因为,Kotlin存在可空类型。一个非空类型是它的可空版本的子类型,但它们都对应着同一个类。你始终能在可空类型的变量中存储非空类型的值,但反过来却不行。

var s: String = "abc"
val t: String? = s //编译通过
s = t  //编译不通过 

前面,我们把List<String>类型的变量传给期望List<Any>的函数是否安全,现在可以使用子类型化术语来重新组织:List<String>是List<Any>的子类型吗?你已经了解了为什么把MutableList<String>当成MutableList<Any>的子类型对待是不安全的。显然,返回来也是不成立的:MutableList<Any>肯定不是MutableList<String>的子类型。
一个泛型类(例如MutableList)如果对于任意两种类型A和B,MutableList<A>既不是MutableList<B>的子类型也不是他的超类型,他就是被称为在该类型参数上是不变型的。Java中所有的类都是不变型的(尽管哪些类具体的使用可以标记成可变型的,稍后你就会看到)。

List类的类型化规则不一样,Kotlin中的List接口表示的是只读集合,如果A是B的子类型,那么List<A>就是List<B>的子类型。这样的类或者接口被称为协变的。

协变:保留子类型化关系

一个协变类是一个泛型类(我们以Producer<T>为例),对这种类来说,下面的描述是成立的:如果A是B的子类型,那么Producer<A>就是Producer<B>的子类型。我们说子类型化被保留了。
在Kotlin中,要声明类在某个类型参数上是可以协变的,在该类型参数的名称前面加上out关键字即可:

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

将一个类的类型参数标记为协变得,在该类型实参没有_精确匹配_到函数中定义的类型形参时,可以让该类的值作为这些函数的实参传递,也可以作为这些函数的返回值。例如,想象一下有这样一个函数,它负责喂养用类Herd代表的一群动物,Herd类的类型参数确定了畜群中动物的类型。

open class Animal {
    fun feed() {...}
}

class Herd<T : Animal> {
    val size: Int
        get() = ...

    operator fun get(i: Int): T {...}
}

fun feeAll(animals: Herd<Animal>) {
    for (i in 0 until animals.size) {
        animals[i].feed()
    }
} 

假设这段代码的用户有一群猫需要照顾:

class Cat : Animal() {
    fun cleanLitter() {...}
}

fun takeCareOfCats(cats: Herd<Cat>) {
    for(i in 0 until cats.size) {
        cats[i].cleanLitter()
        // feedAll(cats)  //错误:类型不匹配
    }
} 

如果尝试把猫群传给feedAll函数,在编译期你就会得到类型不匹配的错误。因为Herd类中的类型参数T没有用任何变型修饰符,猫群不是畜群的子类。可以使用显示得类型转换来绕过这个问题,但是这种方法啰嗦、易出错,而且几乎从来不是解决类型不匹配问题的正确方式。
因为Herd类有一个类似List的API,并且不允许它的调用者添加和改变畜群中的动物,可以把它变成协变并相应地修改调用代码。

class Herd<out T: Animal> {
    ...
} 

你不能把任何类都变成协变得:这样不安全。让类在某个类型参数变为协变,限制了该类中对该类型参数使用的可能性。要保证类型安全,它只能用在所谓的out位置,意味着这个类只能生产类型T的值而不能消费它们。
在类成员的声明中类型参数的使用可以分为in位置和out位置。考虑这样一个类,它声明了一个类型参数T并包含了一个使用T的函数。如果函数是把T当成返回类型,我们说它在out位置。这种情况下,该函数生产类型为T的值。如果T用作函数参数的类型,它就在in位置,这样的函数消费类型为T的值。

interface Transformer<T> {
                //in位置 //out位置
    fun transform(t: T): T
} 

类的类型参数前的out关键字要求所有使用T的方法只能把T放在out位置而不能放在in位置。这个关键字约束了使用T的可能性,这保证了对应子类型关系的安全性。

重申一下,类型参数T上的关键字out有两层含义:

  • 子类型化被保留
  • T只能用在out位置

现在我们看看List<Interface>接口。Kotlin的List是只读的,所以它只有一个返回类型为T的元素的方法get,而没有定义任何把类型为T的元素存储到列表中的方法。因此,它也是协变的。

interface List<out T> : Collection<T> {
    operator fun get(index: Int): T
} 

注意,类型形参不光可以直接当作参数类型或者返回类型使用,还可以当作另一个类型的类型实参。例如,List接口就包含了一个返回List<T>的subList方法:

interface List<out T> : Collection<T> {
    fun subList(fromIndex: Int, toIndex: Int): List<T>
} 

在这个例子中,函数subList中的T也用在out位置。
注意,不能把MutableList<T>在它的类型参数上声明成协变的,因为它既含有接收类型为T的值作为参数的方法,也含有返回这种值得方法(因此,T出现在in和out两种位置上)。

interface MutableList<T>
        : List<T>, MultableCollection<T> {
    override fun add(element: T): Boolean   
} 

编译器强制实施了这种限制。如果这个类被声明成协变得,编译器会报错:Type parameter T is declared as ‘out’ but occurs in ‘in’ position(类型参数T声明为out但出现在in位置)。
注意,构造方法的参数即不在in位置,也不在out位置。即使类型参数声明成了out,仍然可以在构造方法参数的声明中使用它:

class Herd<out T: Animal>(vararg animals: T) {...} 

如果把类的实例当成一个更泛化的类型的实例使用,变型会防止该实例被误用:不能调用存在潜在危险的方法。构造方法不是那种在实例创建之后还能调用的方法,因此它不会有潜在危险。
然后,如果你在构造方法的参数上使用了关键字val和var,同时就会声明一个getter和一个setter(如果属性是可变的)。因此,对只读属性来说,类型参数用在了out位置,而可变属性在out位置和in位置都使用了它:

class Herd<T: Animal>(var leadAnimal: T, vararg animals: T) {...} 

上面这个例子中,T不能用out标记,因为类包含属性leadAnimal的setter,它在in位置用到了T。
还需要注意的是,位置规则只覆盖了类外部可见的(public、protected和internal)API。私有方法的参数即不在in位置也不在out位置。变型规则只会防止外部使用者对类的误用但不会对类自己的实现起作用:

class Herd<out T: Animal>(private var leadAnimal: T, vararg animals: T) {...} 

现在可以安全地让Herd在T上协变,因为属性leadAnimal变成了私有的。

逆变:反转子类型化关系

逆变的概念可以被看成是协变的镜像:对一个逆变来说,它的子类型化关系与用作类型实参的类的子类型化关系是相反的。我们从Comparator接口的例子开始,这个接口定义了一个方法compare类,用于比较两个给定的对象:

interface Comparator<in T> {
    fun compare(e1: T, e2: T): Int {...}
} 

一个为特定类型的值定义的比较器显然可以比较该类型任意子类型的值。例如,如果有一个Comparator<Any>,可以用它比较任意具体类型的值。

interface Comparator<in T> {
    fun compare(e1: T, e2: T): Int
}

fun main(args: Array<String>) {
    val anyComparator = Comparator<Any> { e1, e2 -> e1.hashCode() - e2.hashCode() }
    val strings = listOf("a", "b", "c")
    strings.sortedWith(anyComparator)
} 

sortedWith函数期望一个Comparator<String>(一个可以比较字符串的比较器),传给它一个能比较更一般的类型的比较器是安全的。如果你要在特定类型的对象上执行比较,可以使用能处理该类型或者它的超类型的比较器。这说明Comparator<Any>是Comparator<String>的子类型,其中Any是String的超类型。不同类型之间的子类型关系和这些类型的比较器之间的子类型化关系截然相反。
现在你已经为完整的逆变定义做好了准备。一个在类型参数上逆变的类是这样的一个泛型类(我们以Consumer<T>为例),对这种类来说,下面的描述是成立的:如果B是A的子类,那么Consumer<A>就是Consumer<B>的子类型,类型参数A和B交换了位置,所以我们说子类型化被反转了。

in关键字的意思是,对应类型的值是传递进来给这个类的方法的,并且被这些方法消费。和协变得情况类似,约束类型参数的使用将导致特定的子类型化关系。在类型参数T上的in关键字意味着子类型化被反转了,而且T只能用在in位置。

协变得,逆变的和不变型的类

协变逆变不变型
Producer<out T>Consumer<in T>MutableList<T>
类的子类型化保留了:Producer<Cat>是Producer<Animal>的子类型子类型化反转了:Consumer<Animal>是Consumer<Cat>的子类型没有子类型化
T 只能在out位置T只能在in位置T可以在任何位置

一个类可以在一个类型参数上协变,同时在另外一个类型参数上逆变。Function接口就是一个经典的例子。下面是一个单个参数的Function的声明:

interface Function1<in P, out R> {
    operator fun invoke(p: P): R
} 

Kotlin的表达发(P) -> R是表达Function<P, R>的另一种更具可读性的形式。可以发现用in关键字标记的P(参数类型)只用在in位置,而用out关键字标记的R(返回类型)只用在out位置。这意味着对这个函数类型的第一个类型参数来说,子类型化反转了,而对于第二个类型参数来说,子类型化保留了。

fun enumerateCats(f: (Cat) -> Number) {...}
fun Animal.getIndex(): Int = ...
>>> enumerateCats(Animal::getIndex) 

在Kotlin中这点代码是合法的。Animal是Cat的超类型,而Int是Number的子类型。

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

在类声明的时候就能够指定变型修饰符是很方便的,因为这些修饰符会应用到所有类被使用的地方。这被称作声明点变型。如果你熟悉Java的通配符类型(? extends 和 ? super),你会意识到Java用完全不同的方式处理变型。在Java中,每一次使用带类型参数的类型的时候,还可以指定这个类型参数是否可以用他的子类型或者超类型替换。这叫做使用点变型。

Kotlin的声明点变型 vs. Java通配符

声明点变形带来了更简洁的代码,因为只用指定一次变型修饰符,所有这个类的使用者都不用再考虑这些了,在Java中,库作者不得不一直使用通配符:Function<? super T, ? extends R>,来创建按照用户期望的运行的API。如果你查看Java 8标准库的源码,你会在每次用到Function接口的地方发现通配符。例如,下面是Stream.map方法的声明:

/* Java */
public interface Stream<T> {
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);
} 

Kotlin也支持使用点变型,允许在类型参数出现的具体位置指定变型,即使在类型声明时它不能被声明成协变或逆变的。
你已经见过许多像MutableList这样的接口,通常情况下即不是协变也不是逆变的,因为它同时生产和消费指定为它们类型参数的类型的值。但对于这个类型的变量来说,在某个特定函数中只被当成其中一种角色使用的情况挺常见的:要么是生产者要么是消费者。例如下面这个简单的函数:

fun <T> copyData(source: MutableList<T>, 
        destination: MutableList<T>) {
    for (item in source) {
        destination.add(item)
    }
} 

这个函数从一个集合把元素拷贝到另一个集合中。尽管两个集合都拥有不变型的类型,来源集合只是用于读取,而目标集合只是用于写入。这种情况下,集合元素的类型不需要精确匹配。例如,把一个字符串的集合拷贝到可以包含任意对象的集合中一点儿问题也没有。
要让这个函数支持不同类型的列表,可以引入第二个泛型参数。

fun <T : R, R> copyData(source: MutableList<T>,
                destination: MutableList<R>) {
    for (item in source) {
        destination.add(item)
    }
}

>>> val ints = mutableListOf(1, 2, 3)
>>> val anyItems = mutableListOf<Any>()
>>> copyData(ints, anyItems)
>>> println(anyItems)
[1, 2, 3] 

你声明了两个泛型参数代表来源列表和目标列表中的元素类型。为了能够把一个列表中的元素拷贝到另一个列表中,来源元素类型应该是目标列表中的元素的子类型(Int是Any的子类型)。
但是Kotlin提供了一种更优雅的表达方式。当函数的实现调用了那些类型参数只出现在out位置(或只出现在in位置)的方法时,可以充分利用这一点,在函数定义中给特定用途的类型参数加上变型修饰符。

fun <T> copyData(source: MutableList<out T>,
                 destination: MutableList<T>) {
    for (item in source) {
        destination.add(item)
    }
} 

可以为类型声明中类型参数任意的用法指定变型修饰符,这些用法包括:形参类型、局部变量类型、函数返回类型,等等。这里发生的一切被称作类型投影:我们说source不是一个常规的MutableList,而是一个投影(受限)的MutableList。只能调用返回类型是泛型类型参数的那些方法,或者严格的讲,只在out位置使用它的方法。编译器禁止调用使用类型参数做实参的那些方法(在in位置使用类型参数):

>>> val list: MutableList<out Number> = ...
>>> list.add(42)
Error: Out-projected type 'MutableList<out Number>' prohibits the use of 'fun add (element: E): Boolean' 

不要为使用投影类型后不能调用某些方法而吃惊,如果需要调用那些方法,你要用的时常规类型而不是投影。这可能要求你声明第二个类型参数,它依赖的原本要进行投影的类型。

当然,实现copyData函数的正确方式应该是使用List<T>作为source实参的类型,因为我们只用了声明在List中的方法,并没有用到MutableList中的方法,而且List类型参数的变型在声明时就指定了。但这个例子对展示这个概念依然十分重要,尤其是要记住大多数的类并没有像List和MutableList这样分开的两个接口,一个是协变的读取接口,另一个是不变型的读取/写入接口。
如果类型参数已经有out变型,获取它的out投影没有任何意义。就像List<out T>这样。它和List<T>是一个意思,因为List已经声明成了class List<out T>。编译器会发出警告,标明这样的投影是多余的。

同理,可以对类型参数的用法使用in修饰符,来表明在这个特定的地方,相应的值担当的时消费者,而且类型参数可以使用它的任意子类型替换。

fun <T> copyData(source: MutableList<T>,
                 destination: MutableList<in T>) {
    for (item in source) {
        destination.add(item)
    }
} 

Kotlin的使用点变型直接对应Java的限界通配符。Kotlin中的MutableList<out T>和Java中的MutableList<? extends T>是一个意思。in投影的MutableList<in T>对应到Java的MutableList<? super T>。

星号投影:使用*代替类型参数

本章前面提到类型检查和转换的时候,我们提到了一种特殊的星号投影语法,可以用它来标明你不知道关于泛型实参的任何信息。例如,一个包含未知类型的元素的列表用这种语法表示为List<*>。现在我们深入探讨星号投影的语义。

首先需要注意的是MutableList<*>和MutableList<Any?>不一样。你确信MutableList<Any?>这种列表包含的时任意类型的元素。而另一方面,MutableList<*>是包含某种特定类型元素的列表,但是你不知道是哪个类型。这种列表被创建成一个包含某种特定类型元素的列表,比如String,而且创建它的代码期望只包含那种类型的元素。因为不知道是哪个类型,你不能像列表中写入任何东西,因为你写入的任何值都可能会违反调用代码的期望。但是从列表中读取元素是可行的,因为你心里有数,所有的存储在列表中的值都能匹配所有Kotlin类型的超类型Any?:

fun main(args: Array<String>) {
    val list: MutableList<Any?> = mutableListOf('a', 1, "qwe")
    val chars = mutableListOf('a', 'b', 'c')
    val unknownElements: MutableList<*> = if (Random().nextBoolean()) list else chars
//    unknownElements.add(42) //编译器禁止调用这个方法
    println(unknownElements.first()) //读取元素是安全的
}

//输出
a 

为什么编译器会把MutableList<*>当成out投影的类型?在这个例子的上下文中,MutableList<*>投影成了MutableList<out Any?>,当你没有任何元素类型信息的时候,读取Any?类型的元素任然是安全的,但是向列表中写入元素是不安全的。
Kotlin的MyType<*>相当于Java中的MyType<?>。

对像Consumer<in T>这样的逆变类型的参数来说,星号投影等价于<in Nothing>。实际上,在这种星号投影中无法调用任何签名中有T的方法。如果类型参数是逆变的,它就只能表现为一个消费者,而且,我们之前讨论过,你不知道它可以消费的到底是什么。因此,不能让它消费任何东西。

当类型实参的信息并不重要的时候,可以使用星号投影的语法,不需要使用任何在签名中引用类型参数的方法,或者只是读取数据额不关心它的具体类型。例如,可以实现一个接收List<*>做参数的printFirst函数:

fun printFirst(list: List<*>) {
    if (list.isNotEmpty()) {
        println(list.first())
    }
} 

网络安全工程师(白帽子)企业级学习路线

第一阶段:安全基础(入门)

img

第二阶段:Web渗透(初级网安工程师)

img

第三阶段:进阶部分(中级网络安全工程师)

img

学习资源分享

表现为一个消费者,而且,我们之前讨论过,你不知道它可以消费的到底是什么。因此,不能让它消费任何东西。

当类型实参的信息并不重要的时候,可以使用星号投影的语法,不需要使用任何在签名中引用类型参数的方法,或者只是读取数据额不关心它的具体类型。例如,可以实现一个接收List<*>做参数的printFirst函数:

fun printFirst(list: List<*>) {
    if (list.isNotEmpty()) {
        println(list.first())
    }
} 

网络安全工程师(白帽子)企业级学习路线

第一阶段:安全基础(入门)

[外链图片转存中…(img-q1QV7lei-1715739009680)]

第二阶段:Web渗透(初级网安工程师)

[外链图片转存中…(img-lRLM2ALt-1715739009681)]

第三阶段:进阶部分(中级网络安全工程师)

[外链图片转存中…(img-ohBcNwIb-1715739009681)]

学习资源分享

Kotlin 集合过滤全指南:all、any、filter 及高级用法 在 Kotlin 中,集合过滤是数据处理的核心操作之一。无论是简单的条件筛选,还是复杂的多条件组合,Kotlin 都提供了丰富的 API。通过灵活组合这些操作符,你可以轻松应对各种集合过滤需求!等操作符的用法,并展示如何在实际开发中灵活运用它们。是最常用的集合过滤方法,用于筛选满足条件的元素。在 Android 开发中, 阅读详情

相关推荐

[设计模式](九):过滤器模式(Filter)及Kotlin的Filter模式

过滤器模式(Filter)是常用的一种结构模式,也是最后一种常用的结构模式。由于其的常用,在kotlin中甚至被当做一种lambda函数简化。

身披白袍的博客 3726

Kotlin用高阶函数处理集合数据

一个函数f(x) 的接收参数是另一个函数(g(x))或者它的返回值是另一个函数(h(x)),在Kotlin中f(x)就是一个高阶函数。Kotlin标准库中为开发者提供了丰富的高阶函数,有sumBy, reduce, fold, map,filter,forEach等。本篇文章就来学习这些高阶函数的使用。.........

大模型学习路线 2295

从2D到3D地图开发:手把手教你用Cesium+Three.js实现卫星轨迹可视化(含代码片段)

本文详细介绍了如何结合Cesium与Three.js实现从2D到3D的卫星轨迹可视化。通过对比传统Web GIS框架的局限,阐述了Cesium处理三维地理与轨道数据、Three.js负责高级图形渲染的分工优势,并提供了从环境搭建、坐标同步到动态粒子效果实现的完整代码实战指南。

nut55的博客 673

Kotlin filter 根据条件过滤数组

fun main() { val numbers1 = listOf<Int>(213, 4, 534, 646, 757, 8, 97, 9); val numbers2 = listOf<Int>(214, 5, 535, 647, 758, 9, 98, 10); val numbers3 = listOf(numbers1, numbers2); val res = numbers3.flatMap { it }.fi.

丿灬安之若死 2770

如何用Hugo Stack主题打造极简技术博客?3个必改配置与5个高级美化技巧

本文详细解析了如何深度定制Hugo Stack主题,打造个性化技术博客。文章提供了3个必改配置与5个高级美化技巧,涵盖字体美学、布局重构、代码块视觉强化及细节打磨,帮助开发者超越基础部署,实现从功能到美学的进阶,提升博客质感与用户体验。

carrot的博客 570

UE 动态获取 资源缩略图 下载到本地或返回图片信息

UE 动态加载资源缩略图 返回图片信息或保存到本地

qq_46080252的博客 1939

【编程语言】Kotlin快速入门 - 泛型

Java工程师Kotlin快速入门之泛型

XuanRan的博客 5024

医学图像分割实战:基于TransUNet训练自己的眼底硬渗出物数据集(附完整代码)

本文详细介绍了基于TransUNet的眼底硬渗出物分割实战指南,涵盖数据预处理、模型调优、训练策略及性能优化等关键环节。通过代码复现和实验对比,展示了TransUNet在医学图像分割中的优势,为糖尿病视网膜病变的早期诊断提供技术支持。

weixin_42524708的博客 364

九、kotlin的泛型

theme: Chinese-red我们需要将类型当作参数传递给对象, 传递的类型可能会被用于定义属性或者用于函数的泛型参数需要注意: 泛型约束() 主要内容 很多时候我们需要将泛型的类型约束在某个界限, 比如: sum函数的泛型 参数 和 参数 并不是什么类型都支持 这项操作, 所以我们需要对传入的类型参数(泛型)做限制, 像下面这样 这样操作类似于 java 的 , 限定 必须继承 (或者说必须是的子类).对的, 这样做就不会出现传入俩 的 和 做加法运算符这样尴尬的事情 中的 是两

bangiao的博客 1335

【软考中级】多媒体应用设计师复习笔记第十章【free】

第10章法律法规与标准规范 行业标准 缩写的大写拼音 地方标准 DB加生代码 企业标准Q加斜线企业代号国际标准是国际标准化组织ISO和国际电工委员会IEC制定的标准 国家标准是由国务院标准化行政主管部门制定,全国范围内使用 ?强制性国家标准的代号为GB,推荐性国家标准的代号为GB/T。 ?软件开发规范GB8566-88属于强制性国家标准 在这里插入图片描述 行业标准代号由大写汉语拼音字母组成,加上斜线和T,组成推荐性行业标准,如XX/T。已经发布的行业代号有QJ(航天),SJ(电子

weixin_47120900的博客 642

File Load Error for Untitled.ipynb Unhandled error 解决方案

本文主要介绍了File Load Error for Untitled.ipynb Unhandled error 解决方案,希望能对使用jupyter notebook的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案

weixin_43178406的博客 1万+

Kotlin-泛型

概述一般类和函数,只能使用具体的类型:要么是基本类型,要么是自定义的类。如果要编写可以应用于多种类型的代码,这种刻板的约束对代码的限制很大。而OOP的多态采用了一种泛化的机制,在SE 5种,Java引用了泛型。泛型,即“参数化类型”。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。那么参数化类型怎么理解呢?顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时

行云间 1万+

微信小程序 - 接入腾讯地图 SDK 及详细使用教程,结合小程序 mpa 地图组件展示腾讯地图(基础使用 / 授权当前位置 / 配合小程序map组件的使用 / 腾讯地图逆地址解析 / 坐标系的转化)

微信小程序使用腾讯地图完整流程,微信小程序 接入腾讯地图,如何在微信小程序中接入腾讯地图,微信小程序引入腾讯地图API方法,腾讯地图小程序SDK,微信小程序实现使用腾讯地图SDK步骤详细介绍,微信小程序接入腾讯地图(线路规划、逆解析)、高德地图,微信小程序之使用腾讯地图,微信小程序 接入第三方地图,小程序服务器配置地图,微信小程序接入腾讯地图,微信小程序插入腾讯地图教程,微信小程序如何调用腾讯地图,如何在微信小程序中接入腾讯地图,微信小程序腾讯地图SDK使用方法,在微信小程序上创建一个简单的腾讯地图,微信小

✅ 精选推荐文章 1万+

《Kotlin极简教程》第6章 泛型

第6章 泛型 6.1 泛型(Generic Type)简介 通常情况的类和函数,我们只需要使用具体的类型即可:要么是基本类型,要么是自定义的类。 但是尤其在集合类的场景下,我们需要编写可以应用于多种类型的代码,我们最简单原始的做法是,针对每一种类型,写一套刻板的代码。 这样做,代码复用率会很低,抽象也没有做好。 在SE 5种,Java引用了泛型。泛型,即“参数化类型”(Parameterized Type)。顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式,我们

AI天才研究院 9101

行人检测模型在海思平台上的部署:从 PyTorch 到 NNIE 深度优化与实践

摘要 本文详细介绍行人检测模型从PyTorch到海思NNIE平台的部署流程。首先分析了行人检测面临的挑战(尺度变化、遮挡、姿态多样性等)及边缘部署的优势(实时性、隐私保护等)。重点阐述了模型转换过程:PyTorch→ONNX→Caffe→NNIE-WK,其中PyTorch转ONNX需注意评估模式设置、虚拟输入匹配、操作集版本选择等关键点。文章旨在帮助开发者在海思3516D芯片上实现高效的行人检测,克服部署过程中的常见问题,最终实现边缘设备的实时目标检测能力。

FJN110的博客 218

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

Java与Kotlin中的泛型之:擦除、不变、协变、逆变

本文深入探讨了Java与Kotlin中泛型的关键特性,包括类型擦除、不变性、协变与逆变。通过实例解析了Java泛型类型擦除的机制及其对代码兼容性的影响,同时对比了Kotlin中泛型对数组的支持及协变逆变的应用。文章详细阐述了泛型不变性的概念,并通过Kotlin的out和in关键字展示了协变与逆变的具体实现方式,以及如何通过@UnsafeVariance注解解除协变逆变的限制。此外,还介绍了Kotlin内联函数在获取泛型参数类型中的应用,为深入理解Java与Kotlin泛型提供了全面视角。

zyj13617的博客 2532

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

Kotlin-简约之美-进阶篇(九):泛型

文章目录泛型类泛型方法生产者与消费者声明处型变学习交流 Kotlin 的泛型与 Java 一样,都是一种语法糖,只在源代码里出现,编译时会进行简单的字符串替换。泛型(Generics)其实就是把类型参数化,真正的名字叫做 类型参数,它给强类型编程语言加入了更强的灵活性。在 Java 中,只要是有类型的 API 元素,都可以泛型化,也就是泛型类、泛型接口、泛型方法和泛型属性,泛型类和泛型接口可以统称...

门心叼龙的专栏 6791

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

Kotlin 泛型

Kotlin 泛型定义、where 约束、内联具象化泛型函数、in 和 out。

Chanwing Chow的博客 1115

Kotlin系列之泛型以及与Java中泛型的区别

泛型只在编译期间有效,运行期间会被擦除,所以泛型信息会消失,Java基于栈的形式调用方法得不到泛型的具体类型,Kotlin通过内联机制,编译期间是把方法直接添加到了对应的代码中,不存在栈调用的问题,所以可以通过上下文推导出泛型的具体类型。

小孟来码的博客 6922

kotlin之泛型的使用

泛型 我们最先了解到的泛型应该是来自于Java,在Java SE 1.5的时候,首次提出了泛型的概念,泛型的本质是参数化的类型,也就是说传递操作的数据类型被指定为一个参数,泛型可以被应用于类(泛型类)、接口(泛型接口)、方法(泛型方法)。Java引入泛型的好处就是安全简单。在Java SE 1.5之前,没有泛型的情况下,对参数的“任意化”是通过Object的引用来实现的,然而用这种...

fb0122的博客 5628

七、Kotlin 泛型

T>表示声明了一个泛型T。于是在函数func的定义中(如:形参列表上、函数体中、返回值类型上)才可以使用泛型T表示一个不确定的类型。func(1, 2) // 此时泛型 T 表示 Int 型。func<Int>(1, 'a') // 此时无法根据实参进行类型推导,应该在函数调用时手动指定泛型的具体类型。<T>表示声明了一个泛型T。于是在类中(如:成员方法定义、属性定义、内部类定义、构造器定义上)才可以使用泛型T表示一个不确定的类型。对于泛型类Foo<T>,即使当泛型参数TPerson和Son。

zengkaiqiang562的博客 1901

Kotlin泛型学习篇

有时你想说,你对类型参数一无所知,但仍然希望以安全的方式使用它。这里的安全方式是定义泛型类型的这种投影,该泛型类型的每个具体实例化都会是该投影的子类型。仅使用 Kotlin 时,您不太可能需要显式声明绝对不可为 null 的类型,因为 Kotlin 的类型推断会为您处理此问题。这么做毫无意义, 因为我们可以像以前一样在该对象上调用所有相同的方法,所以更复杂的类型并没有带来价值。由于类型擦除,并没有通用的方法在运行时检测一个泛型类型的实例是否通过指定类型参数所创建 ,并且编译器禁止这种。但这样会有一些影响。

子冉冰清的博客 2059
上一篇: 网络安全——网络层安全协议(3)
下一篇: Rust 所有权:内存管理新流派
heike_沧海
博客等级 码龄3年 4649粉丝 391原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值