学习kotlin第13天_具体化的类型参数、内联属性、解构声明、集合

妖狐艹你老母 2022-06-14 07:36 76阅读 0赞

继续之前的坑，我原本不打算继续看文档了，直接上手个小项目，但是项目中遇见个小问题，list似乎和java中的有区别。。。一查文档发现在后面。。。所以继续踩坑。

坑1、有时候我们需要类型作为参数传给函数，可以使用reified修饰符来限定类型参数，这样就可以直接在函数内部访问它了。此外，调用时可以直接传入该类型参数。

inline fun <reified T> TreeNode.findParentOfType(): T? {
        var p = parent
        while (p != null && p !is T) {
            p = p.parent
        }
        return p as T?//如果没有被标记为reified的话需要添加@Suppress("UNCHECKED_CAST")注解
    }
    fun main(args: Array<String>) {
        val treeNode: TreeNode = MyTreeNode()//MyTreeNode类实现了TreeNode接口
        treeNode.findParentOfType<MyTreeNode>()
    }

坑2、如果需要，可以对一个具体化的类型参数使用反射。

inline fun <  reified T> membersOf() = T::class.members
    
    fun main(s: Array<String>) {
        println(membersOf<StringBuilder>().joinToString("\n"))
    }

坑3、inline可用于没有幕后字段的属性的访问器，即可以单独标注访问器也可以标注整个属性。

val foo: Foo
        get() = Foo()
    
    var bar: Bar
        get() =......
        inline set(v) {......}
    
    inline var bar2: Bar
        get() = ......
        set(v) {......}

坑4、kotlin中使用协程挂起替代先从阻塞，在kotlin1.1中是实验性的。suspend函数用于标记挂起函数。

。。。。。。看不懂，跳过。

坑5、之前讲数据类的时候提到过数据类根据参数自动创建对应的component函数，可以把一个对象解构成多个变量。只要可以对它调用所需数量的component 函数，任何表达式都可以出现在解构声明的右侧。其中，component函数必须用operator标记。解构声明也可以用在for循环中。

class User(var name: String = "", var age: Int = 0) {
        operator fun component1(): String {
            return name
        }
    
        operator fun component2(): Int {
            return age
        }
    
        override fun toString(): String {
            return "User(name='$name', age=$age)"
        }
    
    }
    
    fun main(args: Array<String>) {
        val u: User = User()
        val (name, age) = u
        println(name)
        println(age)
    
        val p = listOf(User("Door", 22 ), User("Green", 30 ), User("Dark", 23 ) )
        for ((name, age) in p) {
            println("name: $name, age: $age")
        }
    }

坑6、解构声明使用示例。

（1）函数返回一个数据类对象。

data class Result(val result: Int, val status: Status)
    fun function(……): Result {
    // 各种计算
        return Result(result, status)
    }
    // 现在，使用该函数：
    val (result, status) = function(……)

（2）因为标准库中映射具有entryset函数和component函数，所以可以直接遍历一个映射（map）,如果“value”不是用的数据类，记得重写component函数和toString函数。

class User(var name: String = "", var age: Int = 0) {
        operator fun component1(): String {
            return name
        }
    
        operator fun component2(): Int {
            return age
        }
    
        override fun toString(): String {
            return "User(name='$name', age=$age)"
        }
    }
    
    fun main(args: Array<String>) {
        val map = HashMap<String, User>()
        map.put("1", User("Door", 22))
        map.put("2", User("Green", 30))
        map.put("3", User("Dark", 23))
        map.put("4", User("Tool", 26))
        map.put("5", User("Mark", 24))
        for ((key, value) in map) {
            println("key: $key, value: $value")
        }
    }

坑7、下划线不仅可以在lambda表达式中标记没有用到的参数，也可以在解构声明中标记未用到的变量。

坑8、在lambda表达式中解构。未使用的替换为下划线，也可以为解构参数指定类型。

data class User(var name: String = "", var age: Int = 0) {
    }
    
    fun main(args: Array<String>) {
        val map = HashMap<String, User>()
        map.put("a", User("Door", 22))
        map.put("b", User("Green", 30))
        map.put("c", User("Dark", 23))
        map.put("d", User("Tool", 26))
        map.put("e", User("Mark", 24))
        map.forEach {
            println(map.mapValues { entry -> "${
       entry.value} " })
            println(map.mapValues { (_, v: User) -> "$v " })
        }
    }

坑9、kotlin中的list集合是只读的，如果需要写入，则使用MutableList。如果将MutableList类型对象赋值给List对象，则该List对象随着MutableList对象的值的改变而改变。如果需要List只读，则试用版listOf创建。

fun main(args: Array<String>) {
        val numbers: MutableList<Int> = mutableListOf(1, 2, 3)
        val readOnlyView: List<Int> = numbers
        println(numbers) // 输出 "[1, 2, 3]"
        numbers.add(4)
        println(readOnlyView) // 输出 "[1, 2, 3, 4]"
    }

坑10、你可以把一个 List<Rectangle> 赋值给 List<Shape> 假定 Rectangle 继承自 Shape。对于可变集合类型这是不允许的，因为这将导致运行时故障。（没懂。。。）

坑11、toList 扩展方法只是复制列表项，因此返回的 list 保证永远不会改变

fun main(args: Array<String>) {
        private val _items = mutableListOf<String>()
        val i: List<String>   = _items.toList()
    }

坑12、list、set、map常见的扩展方法。马上下班了，就不一一验证了。。。

fun main(args: Array<String>) {
        val items = listOf(1, 2, 3, 4)
        items.first() == 1
        items.last() == 4
        items.filter { it % 2 == 0 } // 返回 [2, 4]
        val rwList = mutableListOf(1, 2, 3)
        rwList.requireNoNulls() // 返回 [1, 2, 3]
        if (rwList.none { it > 6 }) println("No items above 6") // 输出“No items above 6”
        val item = rwList.firstOrNull()
    //sort、zip、fold、reduce...
        val readWriteMap = hashMapOf("foo" to 1, "bar" to 2)
        println(readWriteMap["foo"]) // 输出“1”
        val snapshot: Map<String, Int> = HashMap(readWriteMap)
    }

好了，我在android中遇到的list问题也成功解决，可变与不可变。

感谢阅读，写得太low，欢迎指正。