学习kotlin第14天_区间、类型检查与转换、this表达式、相等性

àì夳堔傛蜴生んèń 2022-06-14 09:37 82阅读 0赞

继续跟着官方文档踩坑。

坑1、区间其实在之前学习循环的时候已经见过。区间表达式rangeTo函数使用操作符“..”实现，并以“in”、“!in”配合使用。区间原本是为可比较类型定义的，对于Int类型，它有一个优化的实现。（在我第二篇博客中，说错了一句话，“..”两边的值是不能调换的，前面的应该比后面的小），例子很简单，前面也提到过，就不多说了。

rray<String>) {
        val x = 5
        if (x in 1..10) {
      // 等同于 1 <= x && x <= 10
            print("$x 在1..10之间")
        }
        println()
        for (i in 1..4) print(i) // 输出“1234”
        println()
        for (i in 4..1) print(i) // 什么都不输出
        println()
        for (i in 4 downTo 1) print(i) // 输出“4321”
        println()
        for (i in 1..4 step 2) print(i) // 输出“13”
        println()
        for (i in 4 downTo 1 step 2) print(i) // 输出“42”
        println()
        for (i in 1 until 10) { // i in [1, 10) 排除了 10
            print(i)
        }
    }

坑2、区间实现了CloseRange<T>接口，通过文档，可以清楚地看见区间具有start和endInclusive两个端点值，contains函数（通常使用的是in/!in），以及isEmpty函数检查区间前面的值是否大于后面的值。

/**
     * Represents a range of values (for example, numbers or characters).
     * See the [Kotlin language documentation](http://kotlinlang.org/docs/reference/ranges.html) for more information.
     */
    public interface ClosedRange<T: Comparable<T>> {
        /**
         * The minimum value in the range.
         */
        public val start: T
    
        /**
         * The maximum value in the range (inclusive).
         */
        public val endInclusive: T
    
        /**
         * Checks whether the specified [value] belongs to the range.
         */
        public operator fun contains(value: T): Boolean = value >= start && value <= endInclusive
    
        /**
         * Checks whether the range is empty.
         */
        public fun isEmpty(): Boolean = start > endInclusive
    }

坑3、整型数列是Iterable<N>的子类型，其中N分别为Int 、Long 或者Char，所以可以用于for循环以及map、filter等函数中。数列由在其伴生对象中定义的fromClosedRange 函数构造：

fun main(args: Array<String>) {
        IntProgression.fromClosedRange(1, 4, 2).filter { it > 2 }.forEach { print(it) }
    }

坑4、对于整形类型，“..”操作符创建一个同时实现ClosedRange<T> 和 \*Progression的对象。

坑5、数列的 last 元素这样计算：对于正的 step 找到不大于 end 值的最大值、或者对于负的step 找到不小于 end 值的最小值，使得 (last - first) % increment == 0。搞不懂，step哪来的负值？源码中明明白白地检查是否小于0，小于就抛出异常。

/**
     * Returns a progression that goes over the same range with the given step.
     */
    public infix fun IntProgression.step(step: Int): IntProgression {
        checkStepIsPositive(step > 0, step)
        return IntProgression.fromClosedRange(first, last, if (this.step > 0) step else -step)
    }

internal fun checkStepIsPositive(isPositive: Boolean, step: Number) {
        if (!isPositive) throw IllegalArgumentException("Step must be positive, was: $step.")
    }

坑6、整型类型的rangeTo()操作符只是调用\*Range的构造函数。而浮点数未定义rangeTo操作符，而使用Comparable泛型类型的操作符。downTo()、reversed()、step()都很简单，直接上demo。

fun main(args: Array<String>) {
        if (5 in 1.6.rangeTo(10.3)) {
            println("5 in 1.6.rangeTo(10.3)")
        }// rangeTo函数用于浮点数时不能用于迭代
        IntProgression.fromClosedRange(1, 4, 2).reversed().forEach { print(it) }  //“13”反转输出“31”
        println()
        for (i in 12 downTo 1 step 3) {
            print("$i ")
        }// 值为 [12, 9, 6, 3] 的数列
        println()
        for (i in 1.rangeTo(12) step 3) {
            print("$i ")
        }// 值为 [1, 4, 7, 10] 的数列
    }

坑7、is和!is操作符在学习kotlin第二天的时候就已经见到过了，用来进行类型检查，，已经检测出来的val类型的变量不需要显示转换。!is运算符和is运算符类似，但是是else里面内容为真。Demo就不弄了，前面有，而且文档上也有。

![Center][]

坑8、如果转行是不安全的，会抛出一个异常，不安全转换由as关键字完成。为了匹配 Java 转换语义，我们必须在转换右边有可空类型。为了避免抛出异常，可以使用安全转换操作符 as? ，它可以在失败时返回 null。

fun main(args: Array<String>) {
        val y: String? =null
        val x: String  = y as String
        val x1: String? = y as String?//定义为可空
        val x2: String? = y as? String//使用安全转换
        println(x)//ClassCastException
        println(x1)//null
        println(x2)//null
    }

坑9、this表达式在类中表示当前类对象，在扩展函数或者带接收者的函数字面值中， this 表示在点左侧传递的接收者参数。在this后可以使用@标签指定this对象。

class A { // 隐式标签 @A
        inner class B { // 隐式标签 @B
            fun Int.foo() { // 隐式标签 @foo
                val a = this@A // A 的 this
                val b = this@B // B 的 this
                val c = this // foo() 的接收者，一个 Int
                val c1 = this@foo // foo() 的接收者，一个 Int
                val funLit = lambda@ fun String.() {
                    val d = this // funLit 的接收者
                }
                val funLit2 = { s: String ->
                    // foo() 的接收者，因为它包含的 lambda 表达式
                    // 没有任何接收者
                    val d1 = this
                }
            }
        }
    }

坑10、引用相等由“===”判断。结构相等由 == （以及其否定形式 != ）操作判断。按照惯例，像 a == b 这样的表达式会翻译成

a?.equals(b) ?: (b === null)

也就是说如果 a 不是 null  则调用 equals(Any?) 函数，否则（即 a 是 null ）检查 b是否与 null 引用相等。

当与 null 显式比较时, a == null 会被自动转换为a=== null 。

[Center]: /images/20220614/7b6a3805397c497e8cdc8048a297bab0.png