kotlin练习2

package com.zsw.myandroidlearnapplication.kotlin

import android.os.Build
import androidx.annotation.RequiresApi

/**
 *@author zengsuwa
 *@date 2023/4/25
 *@desc 基础练习
 */
class Base02(private var name: String) {

}

@RequiresApi(Build.VERSION_CODES.N)
fun main() {
    //list创建和元素的获取学习
    //不可变集合
    val list = listOf("aaa", "bbb", "ccc", "ddd")

    //普通取值  索引 内部是运算符重载 [] == get
    println(list[0])
    println(list[1])
    println(list[2])
    println(list[3])
//    println(list[4])//崩溃,数组下标越界

    //我们写KT代码一定不会再出现空指针异常,下标越界异常
//    防止崩溃的取值方式 getOrElse getOrNull 尽量使用这种方式取值,体现KT的亮点
    //getOrNull 一般配合?:(空并操作符)一起使用过
    println(list.getOrElse(3) { "越界" })
    println(list.getOrElse(4) { "越界" })

    println(list.getOrNull(4))
    println(list.getOrNull(4) ?: "你越界了哦")
    //打印::
    //aaa
    //bbb
    //ccc
    //ddd
    //ddd
    //越界
    //null


    //可变集合
    val list2: MutableList<String> = mutableListOf<String>(
        "aaa", "bbb",
        "ccc", "vvv"
    )
    list2.add("ddd")
    list2.remove("vvv")
    println(list2)//[aaa, bbb, ccc, ddd]
//    list.add("vvv") 不可变集合报错没有此功能

    //不可变集合 to 可变集合
    val list3 = list.toMutableList()
    list3.add("eee")
    println(list3)//[aaa, bbb, ccc, ddd, eee]

    //可变集合 to 不可变集合
    val list4 = list2.toList()
//    list4.add("eee")不可变集合报错没有此功能
    println(list4)//[aaa, bbb, ccc, ddd]

    //mutator 函数学习
    //mutator的特性 += -= 其实背后就是运算符重载而已
    list2 += "lll"
    list2 -= "aaa"
    println(list2)//[bbb, ccc, ddd, lll]

    list2.removeIf { true }
    println(list2)//[]
    //
    //removeIf
    val list5 = mutableListOf("aaa", "bbb", "ccc", "vvv")
    list5.removeIf {
        println(it)
        it.contains("aa")//如果是包含aa时返回true 就表示删除
    }//自动遍历整个可变集合,进行一个元素一个元素的输出
    println(list5)//这个只是输出list详情而已,这个不是遍历
    //打印
    //aaa
    //bbb
    //ccc
    //vvv
    //[bbb, ccc, vvv]

    //遍历list
    //第一种方式
    for (i in list5) {
        print("元素:$i ")
    }
    println()
    //第二种方式
    list5.forEach {
        print("元素:$it ")
    }
    println()

    //第三种方式 带下标
    list5.forEachIndexed { index, item ->
        println("下标是$index,数据为$item")
    }

    //解构语法过滤元素
    //集合配合解构语法

    val list6 = mutableListOf("aaa", "bbb", "ccc", "vvv")

    val (value1, value2, value3, value4) = list6
//    value1 = "jaha"报错 val 是只读的
    println("value1 = $value1, value2 = $value2, value3 = $value3, value4 = $value4,")
    //打印结果:value1 = aaa, value2 = bbb, value3 = ccc, value4 = vvv,

    var (value11, value22, value33, value44) = list6
    value11 = "ok"
    println("value11 = $value11, value22 = $value22, value33 = $value33, value44 = $value44,")
    //打印结果:value11 = ok, value22 = bbb, value33 = ccc, value44 = vvv,value11 = ok, value22 = bbb, value33 = ccc, value44 = vvv,

    //_不是变量,_表示屏蔽接收,不接收赋值给我,内部不会赋值,可以节约一点性能
    val (_, a1, _, a2) = list6//这里表示第一个和第三个值不接收
    println("a1=$a1, a2=$a2")
    //打印结果:a1=bbb, a2=vvv

    //todo KT Set创建与元素获取
    // set集合不会出现重复元素
    val set = setOf<String>("aaa", "sss", "ddd", "fff", "fff")
    println(set)//[aaa, sss, ddd, fff]
//    set[0]//报错,set没有这样[]的功能
    println(set.elementAt(0))
    println(set.elementAt(1))
    println(set.elementAt(2))
    println(set.elementAt(3))
//    println(set.elementAt(4))//崩溃,会越界

    //使用list 或set 集合取值时尽量使用这种方式,防止越界崩溃
    println(set.elementAtOrElse(3) { "越界了" })//fff
    println(set.elementAtOrElse(4) { "越界了" })//越界了
    println(set.elementAtOrNull(4))//null
    println(set.elementAtOrNull(4) ?: "你越界了")//你越界了

    val set2 = mutableSetOf<String>("aaa", "sss", "ddd", "fff", "fff")
    set2 += "ddd"
    set2 += "hhh"
    set2 -= "aaa"
    set2.add("bbbb")
    set2.remove("sss")
    println(set2)//[ddd, fff, hhh, bbbb]

    set2.removeIf {
        it.contains("dd")
    }
    println(set2)//[fff, hhh, bbbb]

    //list去除重复元素
    val list7 = listOf<String>("aaa", "sss", "ddd", "fff", "fff")
    println(list7)//[aaa, sss, ddd, fff, fff]
    val set3 = list7.toSet()
    println(set3)//[aaa, sss, ddd, fff]

    val list8 = list7.toSet().toList()
    println(list8)//[aaa, sss, ddd, fff]

    val list9 = list7.distinct()//源码实现其实就是 list7.toMutableSet().toList()
    println(list9)//[aaa, sss, ddd, fff]

    /**
     * kt 中各种数组类型 虽然说引用类型,背后可编译成Java的基本数据类型
     * IntArray     intArrayOf
     * DoubleArray  doubleArrayOf
     * FloatArray   floatArrayOf
     * LongArray    longArrayOf
     * ShortArray   shortArrayOf
     * CharArray    charArrayOf
     * ByteArray    byteArrayOf
     * BooleanArray booleanArrayOf
     * Array        arrayOf         对象数组
     */

    val intArray = intArrayOf(1, 2, 3, 4)
    println(intArray[0])//1
    println(intArray[1])//2
    println(intArray[2])//3
    println(intArray[3])//4
//    println(intArray[4])//崩溃,会越界
    println(intArray.elementAtOrElse(3) { -1 })//4
    println(intArray.elementAtOrElse(4) { -1 })//-1
    println(intArray.elementAtOrNull(4) ?: "越界了")//越界了
    val doubleArray = doubleArrayOf(2.0, 3.4, 5.3)
    println(doubleArray[0])//2.0
    println(doubleArray[1])//3.4
    println(doubleArray[2])//5.3

    val charArray = listOf('A', 'B', 'C', 'D').toCharArray()
    println(charArray)//ABCD

    arrayOf(Base02("haha"), Base02("ooo"), Base02("heihei"))

    //Map
    //这两种创建方式是等价的
    val map = mapOf("ss" to 12, "xiaoming" to 20, "zengzeng" to 30)
    val map2 = mapOf(Pair("ss", 12), Pair("xiaoming", 20), Pair("zengzeng", 30))

    //方式一 [] 背后对[]运算符重载了
    println(map["ss"])//12
    println(map["xxxx"])//不会崩溃会返回null
    //方式2 getOrDefault
    println(map.getOrDefault("xiaoming", -1))//20
    println(map.getOrDefault("xxxx", -1))//-1
    println(map.getOrDefault("xxxx", "没有这个key"))//没有这个key
    //方式3 getOrElse
    println(map.getOrElse("zengzeng"){"-1"})//30
    println(map.getOrElse("XXXXX"){-1})//-1
    println(map.getOrElse("XXXXX"){"没有这个key"})//没有这个key

    //遍历map
    //方式1
    map2.forEach{
        println("K:${it.key},V:${it.value}")
    }
    println()

    //方式2
    map2.forEach { key, value ->
        println("key:${key},value:${value}")

    }
    println()

    //方式3
    map2.forEach {(key, value)  ->
        println("key:${key},value:${value}")
    }
    println()

    //方式4
    for (entry in map2) {
        println("K:${entry.key},V:${entry.value}")
    }

    println()

    val map3 = mutableMapOf(Pair("ss", 12), Pair("xiaoming", 20), Pair("zengzeng", 30))
    map3 +=  Pair("susan", 20)
    map3 +=  "jerry" to 22
    map3 -= "ss"
    map3.put("CCC",999)
    map3["ddd"]=888 //put 和[] 是等价的

    //getOrPut
    // 如果整个map集合中没有key元素,我就帮你添加到几个集合中,然后再从map集合中取出
    // 如果整个map集合中有key元素,我就从map集合中取出,直接给你,相当于666这个备用值就失效了
    val jjj = map3.getOrPut("JJJ"){555}
    println(jjj)//555
    val ccc = map3.getOrPut("CCC"){666}
    println(ccc)//999

}
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成,浏览时请结合常识与多方信息审慎甄别。
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

相关阅读更多精彩内容

友情链接更多精彩内容