前言
以一个java老鸟的角度,如何去看 kotlin。 Java源代码应该如何用Kotlin重构。 如何正确学习kotlin并且应用到实际开发中。本文将会探究。
本文分两大块,重难点和潜规则。
重难点:Kotlin中可以独立出来讲解的大块知识点。提供单独Demo。这部分大多数是Kotlin开创的新概念(相比于Java)。
潜规则:Kotlin是谷歌用来替换Java的,它和java百分百完全兼容,但是实际上java转成kotlin之后,需要我们手动修改很多东西,甚至某些部分必须打散重构来达到最优编码。其中,kotlin的某些特性和java不同,甚至完全反转。这部分知识点比较零碎,单独Demo不方便提供,就以小例子的形式来写。
正文大纲
-
重难点
- lambda以及操作符
- 高阶函数以及操作符
- Kotlin泛型
- 集合操作
- 协程
- 操作符重载
-
潜规则
-
Kotlin文件和类不存在一对一关系
-
共生体
-
继承
-
修饰符
-
空指针问题
-
正文
重难点
Kotlin泛型
类型擦除
我们在编码java的时候,写一个泛型类,可能是这样的
class Plate<T>{
T t;
Plate(T t){
this.t = t;
}
T get(){
return t;
}
void set(T t){
this.t =
t;
}
}
以上是java代码。
Java泛型是伪泛型,在编译之后,所有的泛型写法都会被移除,而会用实际的类型去替换。
mian函数运行的时候, 被移除。而原来的T,就变成了Object。
所以,Plate的字节码反编译过来就应该是
class Plate{
Object t;
Plate(Object t){
this.t = t;
}
Object get(){
return t;
}
void set(Object t){
this.t = t;
}
}
那么既然运行的时候,泛型限制全都没有了。那么怎么保证 泛型的作用呢?
答案:编码的时候,编译器帮我们进行校验。
strList.add(123);//报错
PECS 法则 和 上下边界的问题
public class Panzi<T> {
T mT;
public Panzi(T t) { mT = t;}
public T get() { return mT; }
public void set(T t) { mT = t; }
}
class Fruit {}
class Banana extends Fruit {}
class Apple extends Fruit {}
Panzi<Apple> applePanzi = new Panzi<>(new Apple());
Panzi<Fruit> fruitPanzi = new Panzi<>(new Fruit());
fruitPanzi = applePanzi;
虽然 Apple和Fruit是父子继承关系。但是Panzi 和 Panzi是半毛钱关系都没有,如果你想fruitPanzi = applePanzi ,把后者赋值给前者,是会报编译错误的。
如果想让装水果的盘子和 装 苹果的盘子发生一点关系,能够后者赋值给前者.
Panzi<Apple> 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: T) {
var t: T = t
fun get(): T {
return t
}
fun set(t: T) {
this.t = t
}
}
fun test1() {
// 试试能不能相互赋值
var fruitPanzi: Panzi<Fruit> = Panzi(Fruit()) //一个水果盘子
var applePanzi: Panzi<Apple> = Panzi(Apple()) //一个苹果盘子
//试试相互赋值
// fruitPanzi = applePanzi // 编译报错
// applePanzi = fruitPanzi // 编译报错
//双方完全是不相干的类,不能相互赋值 ,
}
/**
* 加边界之后再赋值
*/
fun test2() {
//如果你非要认为苹果盘子归属于水果盘子,那么可以这样
var fruitPanzi2: Panzi<out Fruit> = Panzi(Fruit()) //一个水果盘子
var applePanzi2: Panzi<Apple> = Panzi(Apple()) //一个苹果盘子
fruitPanzi2 = applePanzi2 //那么这就是out决定泛型上边界的案例
}
/**
* PECS法则,OUT表示 ? extends 决定上界,上界生产者只取不存
*/
fun test3() {
//看一下get set方法
// 决定上界之后的泛型,只取不存
var fruitPanzi2: Panzi<out Fruit> = Panzi(Fruit())
fruitPanzi2.get()
// fruitPanzi2.set(Apple()) // 这里编译报错,和java泛型的表现一样
}
/**
* PECS法则,IN表示 ? super 决定下界,下界消费者,只存不取
*/
fun test4() {
//试试泛型下界 in
var fruitPanzi: Panzi<in Fruit> = 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<String>("str1", "str2", "str3")
listOf.forEach { print("$it ") }
}
执行结果:
str1 str2 str3
通过动态创建过程来指定元素值
fun main() {
val list = List(3) {
"str$it"
}
list.forEach { print("$it ") }
}
执行结果:
str0 str1 str2
api的调用
对象已经创建,我们要利用kotlin提供的方法来完成业务代码。
一级难度api(all,any,count,find,groupBy)
fun testCollectionFun() {
val ages = listOf<Int>(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<Int>(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("数学成绩的总分是:$total 平均分是:${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("平铺之前:$list \n平铺之后$listsOfList")
}
fun main() {
testFlatten()
}
执行结果:
平铺之前:[[Str1, Str3], [Str4, Str2]]
平铺之后[Str1, Str3, Str4, Str2]
在存在List嵌套的情况下,flatten可以把复合式的数据结构 变成 扁平式的。它和flatMap不同,flatMap适合在复杂数据结构中在指定的层级形成一个集合,方便统计和计算。而flatten则更适用于类型相似的集合嵌套扁平化操作。适用场景还是有差别的。
~ o(* ̄▽ ̄*)ブ小编更新了一份“金三银四”面试资源包,在后台私信即可免费领取,手慢无~~~