Kotlin基础学习 17

学习不停息

已于 2022-06-28 10:21:27 修改

阅读量799

点赞数 1

文章标签：大数据 kotlin 学习 android

于 2022-06-27 16:29:27 首次发布

本文链接：https://blog.csdn.net/m0_57026595/article/details/125483092

版权

1.Kotlin语言的过滤函数-filter

8.注解@JvmOverloads与Kotlin

9.注解@JvmStatic与Kotlin

10.手写RxJava，全部用KT的基础来写

1.Kotlin语言的过滤函数-filter

// TODO 126.Kotlin语言的过滤函数-filter
fun main(){
    val nameLists = listOf(
        listOf("黄晓明","李连杰","李小龙"),
        listOf("刘军","李元","刘明"),
        listOf("刘俊","黄家驹","黄飞鸿")
    )
    nameLists.map {
        println(it)
    }
    println()
    nameLists.flatMap {
        println(it)
        listOf("")
    }
    println()
    nameLists.flatMap {
        //进来3次
        it -> it.filter {
            println("$it filter") //进来9次
            true
        //原理：filter {true,false} true他会加入到新的集合 进行组装新集合 返回，否则返回false，过滤掉，不加入，返回空集合
        }
    }.map {
        print("$it  ")
    }
    println()
    nameLists.flatMap {
        it -> it.filter {
            true
        }
    }.map{
        print("$it  ")
    }
    println()
    //List<T>返回给map后的效果：[黄晓明, 李连杰, 李小龙] [刘军, 李元, 刘明] [刘俊, 黄家驹, 黄飞鸿]
    //List<T>返回给flatMap后的效果：黄晓明  李连杰  李小龙  刘军  李元  刘明  刘俊  黄家驹  黄飞鸿
    nameLists.flatMap {
        it -> it.filter {
            it.contains('黄')
    }
    }.map {
        print("$it  ")
    }
}

2.Kotlin语言的合并函数-zip

// TODO 126.Kotlin语言的合并函数-zip
fun main(){
    val names = listOf("张三","李四","王五")
    val ages = listOf(20,21,22)
    //RxJava zip 合并操作符
    //KT 自带就有zip 合并操作
    //原理：就是把第一个集合和第二个集合合并起来，创建新的集合，并返回
    // 创建新的集合（元素，元素，元素）元素Pair(K,V) K代表第一个集合的元素 V代表集合的第二个元素
    val zip:List<Pair<String,Int>> = names.zip(ages)
    println(zip)
    println(zip.toMap())
    println(zip.toMutableSet())
    println(zip.toMutableList())
    println()
    //遍历
    zip.forEach{
        println("姓名是：${it.first},年龄是：${it.second}")
    }
    println()
    //map普通方式
    zip.toMap().forEach { k,v ->
        println("姓名是：${k},年龄是：${v}")
    }
    println()
    //map 结构的方式
    zip.toMap().forEach { (k,v) ->
        println("姓名是：${k},年龄是：${v}")
    }
    println()
    zip.toMap().forEach {
        println("姓名是：${it.key},年龄是：${it.value}")
    }
}

3.Kotlin语言的函数式编程

// TODO 128.Kotlin语言的函数式编程
fun main(){
    val names = listOf("张三","李四","王五")
    val ages = listOf(20,21,22)
    names.zip(ages).toMap().map { "你的名字是${it.key},你的年龄是${it.value}" }.map { println(it) }
}

4.Kotlin语言的互操作性与可空性

// TODO 129.Kotlin语言的互操作性与可空性
fun main(){
    //下面是java与KT交互，错误的案例
    /**println(KtBase129().info1.length)
    println(KtBase129().info2.length)*/
    //下面是java与KT交互，错误的案例
    //: String! Java与KT交互的时候，Java给KT用的值，都是：String！ 这种类型
    /**val info1 = KtBase129().info1
    val info2 = KtBase129().info2
    println(info1.length)
    println(info2.length)*/
    //下面是Java 与 KT交互正确的案例
    //只要是看到 String！ 的类型，在使用的时候，必须？.xxx 这个是规则1，但是不好，忘记写的话有风险
    val info1s = KtBase129().info1
    val info2s = KtBase129().info2
    println(info1s?.length)
    println(info2s?.length)
    //下面是Java 与 KT交互正确的案例2
    val info1ss:String? = KtBase129().info1
    val info2ss:String?= KtBase129().info2
    println(info1ss?.length)
    println(info2ss?.length)
}

5.单例模式

//1.饿汉式的实现 Java版本
public class SingletonDemo {
    private static SingletonDemo instance = new SingletonDemo();
    private SingletonDemo(){}
    public static SingletonDemo getInstance(){
        return instance;
    }
}
//2.懒汉式的实现 Java版本
public class SingletonDemo2 {
    private static SingletonDemo2 instance ;
    private SingletonDemo2(){}
    public static SingletonDemo2 getInstance(){
        if(instance == null){
            instance = new SingletonDemo2();
        }
        return instance;
    }
}
//3.懒汉式的实现 Java版本 安全
public class SingletonDemo3 {
    private static SingletonDemo3 instance ;
    private SingletonDemo3(){}
    public static synchronized SingletonDemo3 getInstance(){
        if(instance == null){
            instance = new SingletonDemo3();
        }
        return instance;
    }
}
//4.懒汉式的实现 Java版本 双重校验安全
public class SingletonDemo4 {
    private volatile static SingletonDemo4 instance;

    private SingletonDemo4() {
    }

    public static synchronized SingletonDemo4 getInstance() {
        if (instance == null) {
            synchronized (SingletonDemo4.class){
                instance = new SingletonDemo4();
            }
        }
        return instance;
    }
}

//1.饿汉式的实现 KT版本
object SingletonDemoKt
//2.懒汉式实现
class SingletonDemo2Kt {
        companion object{
            private var instance : SingletonDemo2Kt ? = null
                get(){
                    if(field == null){
                        field = SingletonDemo2Kt()
                    }
                    return field
                }
            fun getInstanceAction() = instance!!
        }
    fun show(){
        println("show")
    }
}
fun main(){
    SingletonDemo2Kt.getInstanceAction().show()
}
//3.懒汉式实现 KT版本 安全
class SingletonDemo3Kt {
        companion object{
            private var instance : SingletonDemo3Kt ? = null
                get(){
                    if(field == null){
                        field = SingletonDemo3Kt()
                    }
                    return field
                }
            @Synchronized
            fun getInstanceAction() = instance!!
        }
    fun show(){
        println("show")
    }
}
fun main(){
    SingletonDemo3Kt.getInstanceAction().show()
}
//4.懒汉式实现 KT版本 双重校验安全
class SingletonDemo4Kt {
        companion object{
            val instance : SingletonDemo4Kt by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED){SingletonDemo4Kt()}
        }
    fun show(){
        println("show")
    }
}
fun main(){
    SingletonDemo4Kt.instance.show()
}

6.注解@Jvmname与Kotlin

@file:JvmName("Stu") //在编译器环节，修改我们的类名，让我们的Java端调用更简洁
package com.bxb.s7
// TODO 131.注解@Jvmname与Kotlin
fun getStudentNameValueInfo(str:String) = println(str)
fun main(){

}

public class KtBase131 {
    public static void main(String[] args) {
        Stu.getStudentNameValueInfo("Bxb is ok");
    }
}

7.注解@JvmField与Kotlin

// TODO 132.注解@JvmField与Kotlin
class Person{
    @JvmField
    val names = listOf("张三","李四","王五")
}

public class KtBase132 {
    public static void main(String[] args) {
        Person person = new Person();
        for(String name : person.names){
            System.out.println(name);
        }
    }
}

8.注解@JvmOverloads与Kotlin

// TODO 133.注解@JvmOverloads与Kotlin
@JvmOverloads
fun toast(name:String,sex:Char = 'M'){
    println("name:$name,sex:$sex")
}
fun main(){
    toast("李四")
}

public class KtBase133 {
    public static void main(String[] args) {
        KtBase133Kt.toast("zhangsan");//Java享用KT的默认参数
    }
}

9.注解@JvmStatic与Kotlin

// TODO 134.注解@JvmStatic与Kotlin
class MyObject{
    companion object{
        @JvmField
        val TARGET = "黄石公园"
        @JvmStatic
        fun showAction(name:String) = println("$name 要去 $TARGET 玩")
    }
}
fun main(){
    MyObject.TARGET
    MyObject.showAction("Bxb")
}

public class KtBase134 {
    public static void main(String[] args) {
        System.out.println(MyObject.TARGET);
        MyObject.showAction("Bxb");
    }
}

10.手写RxJava，全部用KT的基础来写

//手写RxJava，全部用KT的基础来写
fun main() {
    //creat输入源，没有任何参数给你     输出源：是输出就行（所有类型，万能类型）
    create {
        "Bxb"
        123
        true
        "AAAAAAAA"
        4563.54f
    }.map {
        "你的值是$this"
    }.map {
        "[$this]"
    }.map {
        "@@$this@@"
    }.observer {
        //只需要把上面输入的内容，打印输出即可，所以不需要管输出
        println(this)
    }
}

//中转站，保存我们的记录 //valueItem == create操作符最后一行的返回值 流向此处了
class RxJavaCoreClassObject<T>(var valueItem: T) //主构造，接受你传递进来的信息，此消息就是create返回的最后一行

inline fun<I> RxJavaCoreClassObject<I>.observer(observerAction:I.()->Unit) = observerAction(valueItem)

inline fun <I, O> RxJavaCoreClassObject<I>.map(mapAction: I.() -> O) = RxJavaCoreClassObject(mapAction(valueItem))

inline fun <OUTPUT> create(action: () -> OUTPUT) = RxJavaCoreClassObject((action()))