Kotlin(2)-泛型与集合(1)

最新推荐文章于 2024-11-12 17:28:20 发布

2401_84897096

最新推荐文章于 2024-11-12 17:28:20 发布

阅读量735

点赞数 15

分类专栏：程序员文章标签： kotlin 开发语言 android

本文链接：https://blog.csdn.net/2401_84897096/article/details/138926860

版权

程序员专栏收录该内容

77 篇文章 0 订阅

订阅专栏

Panzi fruitPanzi = new Panzi<>(new Fruit());
fruitPanzi = applePanzi;

虽然 Apple和Fruit是父子继承关系。但是Panzi 和 Panzi是半毛钱关系都没有，如果你想fruitPanzi = applePanzi ,把后者赋值给前者，是会报编译错误的。

如果想让装水果的盘子和装苹果的盘子发生一点关系，能够后者赋值给前者.

Panzi applePanzi = new Panzi<>(new Apple());
Panzi<? extends Fruit> fruitPanzi = new Panzi<>(new Fruit());
fruitPanzi = applePanzi;

那就必须使用到上下边界的关键字 extends

extends 在泛型中表示指定上界，也就是说，实际类型都必须在Fruit之下（包括Fruit自己）。那么既然apple也是Fruit的子类，那么赋值就可以做到。

PECS法则

刚才说到了上边界 extends。而下边界是 super关键字

Panzi<? extends Fruit> extendsFruit = new Panzi<>(new Apple());
Panzi<? super Fruit> superFruit = new Panzi<>(new Fruit());

super关键字，在泛型中表示定义下界，实际类型必须在Fruit之上，同时也在Object之下（包括Fruit和Object）

所以会出现这么一个情况：

Panzi<? extends Fruit> extendsFruit = new Panzi<>(new Apple());
Panzi<? super Fruit> superFruit = new Panzi<>(new Object());

我们有这么两个Panzi，前者是 Fruit作为泛型上界，一个是Fruit作为下界。

现在，我们从Panzi中去调用get/set方法。会发现。

PE:

extendsFruit.set(new Apple()); // 编译报错！
Fruit fruit2 = extendsFruit.get();// 编译正常

为何？因为 Fruit作为上界，我get出来的类型可以确定一定是Fruit类型的。但是我set进去的时候，JVM无法判定实际类型（因为泛型被擦除，JVM只人为set(Object t) 的参数是一个Object），JVM要求是Object，但是你却给了一个Apple，编译器无法处理。所以干脆 java的泛型，? extends 定义了上界，只允许get，不允许set。这就是PECS中的PE，意思就是 Pruducer Extends ，生产者 Extends，只取不存。

相对应：

CS：则是 Cunsumer super 消费者只存不取。

Object object = superFruit.get(); //get，get出来虽然不报错，但是没有任何意义。因为不能确定类型，只知道是一个Object，无法调用API
superFruit.set(new Fruit());// 但是set进去的时候，可以确定一定是一个Fruit的

这就是java泛型的 PECS法则.

kotlin泛型使用实例

java泛型里面比较纠结的难点就是类型擦除和PECS法则了。

那么kotlin泛型，原理上和java泛型和没有区别。只是写法上有了区别。

open class Fruit
class Apple : Fruit()
class Banana : Fruit()
class Panzi(t: T) {
var t: T = t
fun get(): T {
return t
}
fun set(t: T) {
this.t = t
}
}

fun test1() {
// 试试能不能相互赋值
var fruitPanzi: Panzi = Panzi(Fruit()) //一个水果盘子
var applePanzi: Panzi = Panzi(Apple()) //一个苹果盘子
//试试相互赋值
// fruitPanzi = applePanzi // 编译报错
// applePanzi = fruitPanzi // 编译报错
//双方完全是不相干的类，不能相互赋值 ,
}

/**

加边界之后再赋值
*/
fun test2() {
//如果你非要认为苹果盘子归属于水果盘子，那么可以这样
var fruitPanzi2: Panzi = Panzi(Fruit()) //一个水果盘子
var applePanzi2: Panzi = Panzi(Apple()) //一个苹果盘子

fruitPanzi2 = applePanzi2 //那么这就是out决定泛型上边界的案例
}

/**

PECS法则，OUT表示 ? extends 决定上界，上界生产者只取不存
*/
fun test3() {
//看一下get set方法
// 决定上界之后的泛型，只取不存
var fruitPanzi2: Panzi = Panzi(Fruit())
fruitPanzi2.get()
// fruitPanzi2.set(Apple()) // 这里编译报错，和java泛型的表现一样
}

/**

PECS法则，IN表示 ? super 决定下界，下界消费者，只存不取
*/
fun test4() {
//试试泛型下界 in
var fruitPanzi: Panzi = Panzi(Fruit())
fruitPanzi.set(Fruit())//可以set，但是看看get
val get = fruitPanzi.get()//不会报错，get出来的类型就完全不能确定了，只知道是顶级类Any? 的子类,获得它也没有意义

}

集合操作

Kotlin的集合，并没有重新开创一套规则，它的底层依然是java的Collection。Kotlin提供了可变集合和不可变集合的接口。

不可变集合：List，Set，Map （内部元素不可以增减或者修改，在定义的时候就已经将容量和内部元素定死）
不可变集合: MutableList , MutableSet , MutableMap (声明的时候可以随意指定初始值，后续可以随意增删和修改内部元素)

集合操作分为：对象的创建和 api的调用

对象的创建

方式有多种，以不可变集合 List 为例，kotlin的List底层和Java的List一致，底层数据结构是数组。

静态指定元素值

fun main() {
val listOf = listOf(“str1”, “str2”, “str3”)
listOf.forEach { print("$it ") }
}

执行结果：

str1 str2 str3

通过动态创建过程来指定元素值

fun main() {

val list = List(3) {
"str $KaTeX parse error: Expected 'EOF', got '}' at position 5: it" }̲ list.forEach {\dots$ it ") }
}

执行结果：

str0 str1 str2

api的调用

对象已经创建，我们要利用kotlin提供的方法来完成业务代码。

一级难度api（all，any，count，find，groupBy）

fun testCollectionFun() {
val ages = listOf(1, 2, 3, 4, 5, 6, 7, 100, 200)
//那么是不是所有的元素都大于10

ages.apply { print(“all:”) }.all { it > 10 }.apply { println(this) } //结果是false

//是不是存在任意一个元素大于10
ages.apply { print(“any:”) }.any { it > 10 }.apply { println(this) }

// 符合指定条件的元素个数
ages.apply { print(“count:”) }.count { it < 10 }.apply { println(this) }

//找到第一个符合条件的元素
ages.apply { print(“find:”) }.find { it > 10 }.apply { println(this) }

// 按照条件进行分组
val groupBy = ages.apply { print(“groupBy:”) }.groupBy { it > 10 }
groupBy[false].apply { println(this) }
groupBy[true].apply { println(this) }

}

fun main() {
testCollectionFun()
}

针对数组元素的简单判断，上述提供了简明的示例代码，用List为例，至于Set和Map类似。可以自主去推断写法。

执行结果：

all:false
any:true
count:7
find:100
groupBy:[1, 2, 3, 4, 5, 6, 7]
[100, 200]

二级难度api (filter,map,flatMap,flatten)

filter和map

fun testCollectionFun2() {
//二级难度api
val ages = listOf(1, 2, 3, 4, 5, 6, 7, 100, 200)
// 只保留大于10的元素,并返回一个新数组
ages.filter { it > 10 }.apply { println(this) }
//遍历List的所有元素，根据条件返回值，创建新的元素内容并放到新List中返回出来
ages.map { if (it > 10) “大于10” else “小于等于10” }.apply { println(this) }
}
fun main() {
testCollectionFun2()
}

执行结果：

[100, 200]
[小于等于10, 小于等于10, 小于等于10, 小于等于10, 小于等于10, 小于等于10, 小于等于10, 大于10, 大于10]

flatMap，因为稍复杂

// 比如一个学生，作为一个实体
class Student(name: String, math: Int, chinese: Int) {
val name: String = name
val score = Score(math, chinese)
}

//学生的成绩分数作为一个主体
class Score(math: Int, chinese: Int) {
val math: Int = math
val chinese: Int = chinese
}

fun testFlatMap() {
val students = listOf(
Student(“zero”, 100, 80),
Student(“alvin”, 70, 70),
Student(“lance”, 90, 60)
)
//我只想统计所有的数学成绩的总分和平均分,怎么办
students.flatMap { listOf(it.score.math) }.apply {
var total = 0
this.forEach {
total += it
}
println(“数学成绩的总分是： $t o t a l 平均分是：$ {total / this.size}”)
}
}

fun main() {
testFlatMap()
}

执行结果：

数学成绩的总分是：260 平均分是：86

当面对复杂数据结构时，我们想要提炼出其中的某一层数据，并不关心其他无关字段。就适合使用 flatMap 进行扁平化提炼。

flatten

意味:“平铺”

fun testFlatten(){
val list = listOf(listOf(“Str1”,“Str3”), listOf(“Str4”,“Str2”))
val listsOfList = list.flatten()
println(“平铺之前： $KaTeX parse error: Undefined control sequence: \n at position 6: list \̲n̲平铺之后$ listsOfList”)
}

fun main() {