本系列学习教程笔记属于详细讲解Kotlin语法的教程，需要快速学习Kotlin语法的小伙伴可以查看“简洁” 系列的教程
快速入门请阅读如下简洁教程：
Kotlin学习教程(一)
Kotlin学习教程(二)
Kotlin学习教程(三)
Kotlin学习教程(四)
Kotlin学习教程(五)
Kotlin学习教程(六)
Kotlin学习教程(七)
Kotlin学习教程(八)
Kotlin学习教程(九)
Kotlin学习教程(十)
Kotlin教程笔记(30) - 泛型详解
泛型：in、out、where
Kotlin 中的类可以有类型参数，与 Java 类似：
class Box(t: T) {
var value = t
}
创建这样类的实例只需提供类型参数即可：
val box: Box = Box(1)
但是如果类型参数可以推断出来，例如从构造函数的参数或者从其他途径， 就可以省略类型参数：
val box = Box(1) // 1 具有类型 Int，所以编译器推算出它是 Box
型变
Java 类型系统中最棘手的部分之一是通配符类型（参见 Java Generics FAQ）。 而 Kotlin 中没有。 相反，Kotlin 有声明处型变（declaration-site variance）与类型投影（type projections）。
Variance and wildcards in Java
我们来思考下为什么 Java 需要这些神秘的通配符。 首先，Java 中的泛型是不型变的， 这意味着 List 并不是 List
简而言之，可以说类 C 是在参数 T 上是协变的，或者说 T 是一个协变的类型参数。 可以认为 C 是 T 的生产者，而不是 T 的消费者。
out 修饰符称为型变注解，并且由于它在类型参数声明处提供， 所以它提供了声明处型变。 这与 Java 的使用处型变相反，其类型用途通配符使得类型协变。
另外除了 out，Kotlin 又补充了一个型变注解：in。它使得一个类型参数逆变，即只可以消费而不可以生产。逆变类型的一个很好的例子是 Comparable：
interface Comparable {
operator fun compareTo(other: T): Int
}
fun demo(x: Comparable) {
x.compareTo(1.0) // 1.0 拥有类型 Double，它是 Number 的子类型
// 因此，可以将 x 赋给类型为 Comparable 的变量
val y: Comparable = x // OK！
}
in 和 out 两词看起来是自解释的（因为它们已经在 C# 中成功使用很长时间了）， 因此上面提到的助记符不是真正需要的。可以将其改写为更高级的抽象：
存在性（The Existential） 变换：消费者 in, 生产者 out! :-)
类型投影
使用处型变：类型投影
将类型参数 T 声明为 out 非常简单，并且能避免使用处子类型化的麻烦， 但是有些类实际上不能限制为只返回 T！ 一个很好的例子是 Array：
class Array(val size: Int) {
operator fun get(index: Int): T { …… }
operator fun set(index: Int, value: T) { …… }
}
该类在 T 上既不能是协变的也不能是逆变的。这造成了一些不灵活性。考虑下述函数：
fun copy(from: Array, to: Array) {
assert(from.size == to.size)
for (i in from.indices)
to[i] = from[i]
}
这个函数应该将项目从一个数组复制到另一个数组。让我们尝试在实践中应用它：
val ints: Array = arrayOf(1, 2, 3)
val any = Array(3) { "" }
copy(ints, any)
// ^ 其类型为 Array 但此处期望 Array
这里我们遇到同样熟悉的问题：Array 在 T 上是不型变的，因此 Array 与 Array 都不是另一个的子类型。为什么？ 再次重复，因为 copy 可能有非预期行为，例如它可能尝试写一个 String 到 from， 并且如果我们实际上传递一个 Int 的数组，以后会抛 ClassCastException 异常。
To prohibit the copy function from writing to from, you can do the following:
fun copy(from: Array, to: Array) { …… }
这就是类型投影：意味着 from 不仅仅是一个数组，而是一个受限制的（投影的）数组。 只可以调用返回类型为类型参数 T 的方法，如上，这意味着只能调用 get()。 这就是使用处型变的用法，并且是对应于 Java 的 Array<? extends Object>、 但更简单。
你也可以使用 in 投影一个类型：
fun fill(dest: Array, value: String) { …… }
Array 对应于 Java 的 Array<? super String>，也就是说，你可以传递一个 CharSequence 数组或一个 Object 数组给 fill() 函数。
星投影
有时你想说，你对类型参数一无所知，但仍然希望以安全的方式使用它。 这里的安全方式是定义泛型类型的这种投影，该泛型类型的每个具体实例化都会是该投影的子类型。
Kotlin 为此提供了所谓的星投影语法：
对于 Foo ，其中 T 是一个具有上界 TUpper 的协变类型参数，Foo <> 等价于 Foo 。 意味着当 T 未知时，你可以安全地从 Foo <> 读取 TUpper 的值。
对于 Foo ，其中 T 是一个逆变类型参数，Foo <> 等价于 Foo 。 意味着当 T 未知时， 没有什么可以以安全的方式写入 Foo <>。
对于 Foo ，其中 T 是一个具有上界 TUpper 的不型变类型参数，Foo<*> 对于读取值时等价于 Foo 而对于写值时等价于Foo。
如果泛型类型具有多个类型参数，则每个类型参数都可以单独投影。 例如，如果类型被声明为 interface Function ，可以使用以下星投影：
Function<, String> 表示 Function。
Function<Int, > 表示 Function。
Function<, > 表示 Function。
星投影非常像 Java 的原始类型，但是安全。
泛型函数
不仅类可以有类型参数。函数也可以有。类型参数要放在函数名称之前：
fun singletonList(item: T): List {
// ……
}
fun T.basicToString(): String { // 扩展函数
// ……
}
要调用泛型函数，在调用处函数名之后指定类型参数即可：
val l = singletonList(1)
可以省略能够从上下文中推断出来的类型参数，所以以下示例同样适用：
val l = singletonList(1)
泛型约束
能够替换给定类型参数的所有可能类型的集合可以由泛型约束限制。
上界
最常见的约束类型是上界，与 Java 的 extends 关键字对应：
fun > sort(list: List) { …… }
冒号之后指定的类型是上界，表明只有 Comparable 的子类型可以替代 T。 例如：
sort(listOf(1, 2, 3)) // OK。Int 是 Comparable 的子类型
sort(listOf(HashMap())) // 错误：HashMap 不是 Comparable> 的子类型
默认的上界（如果没有声明）是 Any?。在尖括号中只能指定一个上界。 如果同一类型参数需要多个上界，需要一个单独的 where-子句：
fun copyWhenGreater(list: List, threshold: T): List
where T : CharSequence,
T : Comparable {
return list.filter { it > threshold }.map { it.toString() }
}
所传递的类型必须同时满足 where 子句的所有条件。在上述示例中，类型 T 必须 既实现了 CharSequence 也实现了 Comparable。
Definitely non-nullable types
To make interoperability with generic Java classes and interfaces easier, Kotlin supports declaring a generic type parameter as definitely non-nullable.
To declare a generic type T as definitely non-nullable, declare the type with & Any. For example: T & Any.
A definitely non-nullable type must have a nullable upper bound.
The most common use case for declaring definitely non-nullable types is when you want to override a Java method that contains @NotNull as an argument. For example, consider the load() method:
import org.jetbrains.annotations.*;
public interface Game {
public T save(T x) {
}
@NotNull
public T load(@NotNull T x) {
}
}
To override the load() method in Kotlin successfully, you need T1 to be declared as definitely non-nullable:
interface ArcadeGame : Game {
override fun save(x: T1): T1
// T1 is definitely non-nullable
override fun load(x: T1 & Any): T1 & Any
}
When working only with Kotlin, it's unlikely that you will need to declare definitely non-nullable types explicitly because Kotlin's type inference takes care of this for you.
类型擦除
Kotlin 为泛型声明用法执行的类型安全检测在编译期进行。 运行时泛型类型的实例不保留关于其类型实参的任何信息。 其类型信息称为被擦除。例如，Foo 与 Foo 的实例都会被擦除为 Foo<*>。
泛型类型检测与类型转换
由于类型擦除，并没有通用的方法在运行时检测一个泛型类型的实例是否通过指定类型参数所创建 ，并且编译器禁止这种 is 检测，例如 ints is List or list is T (type parameter). 当然，你可以对一个实例检测星投影的类型：
if (something is List<*>) {
something.forEach { println(it) } // 每一项的类型都是 Any?
}
类似地，当已经让一个实例的类型参数（在编译期）静态检测， 就可以对涉及非泛型部分做 is 检测或者类型转换。请注意， 在这种情况下，会省略尖括号：
fun handleStrings(list: MutableList) {
if (list is ArrayList) {
// list 智能转换为 ArrayList<String>
}
}
省略类型参数的这种语法可用于不考虑类型参数的类型转换：list as ArrayList。
泛型函数调用的类型参数也同样只在编译期检测。在函数体内部， 类型参数不能用于类型检测，并且类型转换为类型参数（foo as T）也是非受检的。 The only exclusion is inline functions with reified type parameters, which have their actual type arguments inlined at each call site. This enables type checks and casts for the type parameters. However, the restrictions described above still apply for instances of generic types used inside checks or casts. For example, in the type check arg is T, if arg is an instance of a generic type itself, its type arguments are still erased.
//sampleStart
inline fun Pair<, >.asPairOf(): Pair? {
if (first !is A || second !is B) return null
return first as A to second as B
}
val somePair: Pair = "items" to listOf(1, 2, 3)
val stringToSomething = somePair.asPairOf()
val stringToInt = somePair.asPairOf()
val stringToList = somePair.asPairOf>()
val stringToStringList = somePair.asPairOf>() // Compiles but breaks type safety!
// Expand the sample for more details
//sampleEnd
fun main() {
println("stringToSomething = " + stringToSomething)
println("stringToInt = " + stringToInt)
println("stringToList = " + stringToList)
println("stringToStringList = " + stringToStringList)
//println(stringToStringList?.second?.forEach() {it.length}) // This will throw ClassCastException as list items are not String
}
非受检类型转换
类型转换为带有具体类型参数的泛型类型，如 foo as List 无法在运行时检测。 当高级程序逻辑隐含了类型转换的类型安全而无法直接通过编译器推断时， 可以使用这种非受检类型转换。 See the example below.
fun readDictionary(file: File): Map = file.inputStream().use {
TODO("Read a mapping of strings to arbitrary elements.")
}
// 我们已将存有一些 Int 的映射保存到这个文件
val intsFile = File("ints.dictionary")
// Warning: Unchecked cast: Map<String, *> to Map<String, Int>
val intsDictionary: Map = readDictionary(intsFile) as Map
最后一行的类型转换会出现一个警告。编译器无法在运行时完全检测该类型转换，并且不能保证映射中的值是“Int”。
为避免未受检类型转换，可以重新设计程序结构。在上例中，可以使用具有类型安全实现的不同接口 DictionaryReader 与 DictionaryWriter。 可以引入合理的抽象，将未受检的类型转换从调用处移动到实现细节中。 正确使用泛型型变也有帮助。
对于泛型函数，使用具体化的类型参数可以使形如 arg as T 这样的类型转换受检，除非 arg 对应类型的自身类型参数已被擦除。
可以通过在产生警告的语句或声明上用注解 @Suppress("UNCHECKED_CAST") 标注来禁止未受检类型转换警告：
inline fun List<>.asListOfType(): List? =
if (all { it is T })
@Suppress("UNCHECKED_CAST")
this as List else
null
对于 JVM 平台：数组类型（Array）会保留关于其元素被擦除类型的信息，并且类型转换为一个数组类型可以部分受检： 元素类型的可空性与类型实参仍然会被擦除。例如， 如果 foo 是一个保存了任何 List<>（无论可不可空）的数组的话，类型转换 foo as Array?> 都会成功。
Underscore operator for type arguments
The underscore operator _ can be used for type arguments. Use it to automatically infer a type of the argument when other types are explicitly specified:
abstract class SomeClass {
abstract fun execute() : T
}
class SomeImplementation : SomeClass() {
override fun execute(): String = "Test"
}
class OtherImplementation : SomeClass() {
override fun execute(): Int = 42
}
object Runner {
inline fun , T> run() : T {
return S::class.java.getDeclaredConstructor().newInstance().execute()
}
}
fun main() {
// T is inferred as String because SomeImplementation derives from SomeClass
val s = Runner.run()
assert(s == "Test")
// T is inferred as Int because OtherImplementation derives from SomeClass<Int>
val n = Runner.run<OtherImplementation, _>()
assert(n == 42)
}
参考文献：
