Android--kotlin基础（三）

最新推荐文章于 2022-06-19 18:15:47 发布

&岁月不待人&

最新推荐文章于 2022-06-19 18:15:47 发布

阅读量253

点赞数

分类专栏： kotlin 文章标签： kotlin android

本文链接：https://blog.csdn.net/LoveFHM/article/details/113730223

版权

kotlin 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

第一章 Android基础--kotlin（一）

第二章 Android基础--Kotlin（二）

7.区间

区间表达式由具有操作符形式 .. 的 rangeTo 函数辅以 in 和 !in 形成。

区间是为任何可比较类型定义的，但对于整型原生类型，它有一个优化的实现。以下是使用区间的一些示例:

举个栗子：

fun main(args: Array<String>) {
    print("循环输出：")
    for (i in 1..4) print(i) // 输出“1234”
    println("\n----------------")

    print("设置步长：")
    for (i in 1..4 step 2) print(i) // 输出“13”
    println("\n----------------")

    print("使用 downTo step：")
    for (i in 4 downTo 1 step 2) print(i) // 输出“42”
    println("\n----------------")

    print("使用 downTo：")
    for (i in 4 downTo 1 ) print(i) // 输出“4321”
    println("\n----------------")

    print("使用 until：")
    // 使用 until 函数排除结束元素
    for (i in 1 until 4) {   // i in [1, 4) 排除了 4
        print(i)
    }
    println("\n----------------")
}

8.基本数据类型

Kotlin 的基本数值类型包括 Byte、Short、Int、Long、Float、Double 等。不同于 Java 的是，字符不属于数值类型，是一个独立的数据类型。

8.1 字面常量

下面是所有类型的字面常量：

十进制：123
长整型以大写的 L 结尾：123L
16 进制以 0x 开头：0x0F
2 进制以 0b 开头：0b00001011
注意：8进制不支持

Kotlin 同时也支持传统符号表示的浮点数值：

Doubles 默认写法: 123.5, 123.5e10
Floats 使用 f 或者 F 后缀：123.5f

你可以使用下划线使数字常量更易读：

val oneMillion = 1_000_000
val creditCardNumber = 1234_5678_9012_3456L
val socialSecurityNumber = 999_99_9999L
val hexBytes = 0xFF_EC_DE_5E
val bytes = 0b11010010_01101001_10010100_10010010

8.2 比较两个数字

Kotlin 中没有基础数据类型，只有封装的数字类型，你每定义的一个变量，其实 Kotlin 帮你封装了一个对象，这样可以保证不会出现空指针。数字类型也一样，所以在比较两个数字的时候，就有比较数据大小和比较两个对象是否相同的区别了。

在 Kotlin 中，三个等号 === 表示比较对象地址，两个 == 表示比较两个值大小。

知识点三：java 中 “==” 和 equals 的区别

举个栗子：

fun main(args: Array<String>) {

  println("\n-----------test1-----")
    val a1: Int = 10000
    println(a1 === a1) // true，值相等，对象地址相等
    //经过了装箱，创建了两个不同的对象
    val boxedA: Int? = a1
    val anotherBoxedA: Int? = a1
    //虽然经过了装箱，但是值是相等的，都是10000
    println(boxedA === anotherBoxedA) //  false，值相等，对象地址不一样
    println(boxedA == anotherBoxedA) // true，值相等

    println("\n-----------test2-----")
    val str1 = "lx"
    println(str1 === str1) // true，值相等，对象地址相等
    //经过了装箱，创建了两个不同的对象
    val str2: String? = str1
    val str3: String? = str1
    //虽然经过了装箱，但是值是相等的，都是10000
    println(str2 === str3) //  true，值相等，对象地址一样（都让str1和str3指向了str1指向的对象，那么得到的结果毫无疑问是true。）
    println(str2 == str3) // true，值相等
}

8.3 类型转换

忘了没？忘了没？还记得清楚隐式转换和显示转换不？！？！？哈哈哈，具体的我也整不清楚了。

1.隐式转换与显示转换的区别概念理解

2.JAVA中显式类型转换和隐式类型转换

3.Java基础——隐式转换vs强制转换

由于不同的表示方式，较小类型并不是较大类型的子类型，较小的类型不能隐式转换为较大的类型。这意味着在不进行显式转换的情况下我们不能把 Byte 型值赋给一个 Int 变量。

val b: Byte = 1 // OK, 字面值是静态检测的
val i: Int = b // 错误

//我们可以代用其toInt()方法
val b: Byte = 1 // OK, 字面值是静态检测的
val i: Int = b.toInt() // OK

栗子：

    val b1: Byte = 1 // OK, 字面值是静态检测的
    val i: Int = b1.toInt() // OK
    println(i) //1

    var c1:Float= 5.1F
    var c2=c1.toInt()
    println(c2)//5

    var c3=5
    var  c4:Float=c3.toFloat();
    println(c4)//5.0

每种数据类型都有下面的这些方法，可以转化为其它的类型：

toByte(): Byte
toShort(): Short
toInt(): Int
toLong(): Long
toFloat(): Float
toDouble(): Double
toChar(): Char

有些情况下也是可以使用自动类型转化的，前提是可以根据上下文环境推断出正确的数据类型而且数学操作符会做相应的重载。例如下面是正确的：

val x = 1L + 3 // Long + Int => Long

8.4 位操作符

对于Int和Long类型，还有一系列的位操作符可以使用，分别是：关于与运算，或运算，异或运算

shl(bits) – 左移位 (Java’s <<)
shr(bits) – 右移位 (Java’s >>)
ushr(bits) – 无符号右移位 (Java’s >>>)
and(bits) – 与
or(bits) – 或
xor(bits) – 异或
inv() – 反向

8.5 字符

和 Java 不一样，Kotlin 中的 Char 不能直接和数字操作，Char 必需是单引号 ' 包含起来的。比如普通字符 '0'，'a'。

字符字面值用单引号括起来: '1'。特殊字符可以用反斜杠转义。支持这几个转义序列：\t、 \b、\n、\r、\'、\"、\\ 和 \$。编码其他字符要用 Unicode 转义序列语法：'\uFF00'。

我们可以显式把字符转换为 Int 数字：

fun decimalDigitValue(c: Char): Int {
    if (c !in '0'..'9')
        throw IllegalArgumentException("Out of range")
    return c.toInt() - '0'.toInt() // 显式转换为数字
}

当需要可空引用时，像数字、字符会被装箱。装箱操作不会保留同一性。

8.6 布尔

布尔用 Boolean 类型表示，它有两个值：true 和 false。

若需要可空引用布尔会被装箱。

内置的布尔运算有：

|| – 短路逻辑或
&& – 短路逻辑与
! - 逻辑非

8.7 数组

数组用类 Array 实现，并且还有一个 size 属性及 get 和 set 方法，由于使用 [ ] 重载了 get 和 set 方法，所以我们可以通过下标很方便的获取或者设置数组对应位置的值。

数组的创建两种方式：一种是使用函数arrayOf()；另外一种是使用工厂函数。如下所示，我们分别是两种方式创建了两个数组：

fun main(args: Array<String>) {
   //[1,2,3]
    val a5 = arrayOf(1, 2, 3)
    val b5 = Array(8, { y-> (y + 2) })//2 3 4 5 6 7 8 9 10

    //读取数组内容
    println(a5[0])    // 输出结果：1
    println(b5[5])    // 输出结果：8

注意: 与 Java 不同的是，Kotlin 中数组是不协变的（invariant）。

除了类Array，还有ByteArray, ShortArray, IntArray，用来表示各个类型的数组，省去了装箱操作，因此效率更高，其用法同Array一样：

val x: IntArray = intArrayOf(1, 2, 3)
x[0] = x[1] + x[2]

8.8 字符串

和 Java 一样，String 是不可变的。方括号 [ ] 语法可以很方便的获取字符串中的某个字符，也可以通过 for 循环来遍历

   val str4="ILU"
    for (c5:Char in str4) {
        println(c5)
    }

输出：

Kotlin 支持三个引号 """ 扩起来的字符串，支持多行字符串，比如：

fun main(args: Array<String>) {
    val text = """
    多行字符串
    多行字符串
    """
    println(text)   // 输出有一些前置空格
}

String 可以通过 trimMargin() 方法来删除多余的空白。

fun main(args: Array<String>) {
    val text = """
    |多行字符串
    |kotlin基础
    |多行字符串
    |Runoob
    """.trimMargin()
    println(text)    // 前置空格删除了
}

默认 | 用作边界前缀，但你可以选择其他字符并作为参数传入，比如 trimMargin(">")。

9 Kotlin 条件控制

9.1 IF 表达式

一个 if 语句包含一个布尔表达式和一条或多条语句。

// 传统用法
var max = a 
if (a < b) max = b
// 使用 else 
var max: Int
if (a > b) {
    max = a
} else {
    max = b
}
// 作为表达式
val max = if (a > b) a else b

我们也可以把 IF 表达式的结果赋值给一个变量。

   println("------------------9.表达式-----------------")
    val a6=8
    val b6=7
    val max = if (a6 > b6) {
        print("Choose a6")
        a6
    } else {
        print("Choose b6")
        b6
    }

这也说明我也不需要像Java那种有一个三元操作符，因为我们可以使用它来简单实现：

举个栗子：

//java
int a = 10;  int b = 20;
int c = (a == b) ? 10 : 20;
//kotlin
val c = if (a === b) 10 else 20

配合区间

使用 in 运算符来检测某个数字是否在指定区间内，区间格式为 x..y ：

fun main(args: Array<String>) {
    val x = 5
    val y = 9
    if (x in 1..8) {
        println("x 在区间内")
    }
}

9.2 When 表达式

when 将它的参数和所有的分支条件顺序比较，直到某个分支满足条件。

when 既可以被当做表达式使用也可以被当做语句使用。如果它被当做表达式，符合条件的分支的值就是整个表达式的值，如果当做语句使用，则忽略个别分支的值。

1.when 类似其他语言的 switch 操作符。其最简单的形式如下：

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> { // 注意这个块
        print("x 不是 1 ，也不是 2")
    }
}

2.在 when 中，else 同 switch 的 default。如果其他分支都不满足条件将会求值 else 分支。

如果很多分支需要用相同的方式处理，则可以把多个分支条件放在一起，用逗号分隔：

when (x) {
    0, 1 -> print("x == 0 or x == 1")
    else -> print("otherwise")
}

3.我们也可以检测一个值在（in）或者不在（!in）一个区间或者集合中：

when (x) {
    in 1..10 -> print("x is in the range")
    in validNumbers -> print("x is valid")
    !in 10..20 -> print("x is outside the range")
    else -> print("none of the above")
}

4.另一种可能性是检测一个值是（is）或者不是（!is）一个特定类型的值。注意：由于智能转换，你可以访问该类型的方法和属性而无需任何额外的检测。

fun hasPrefix(x: Any) = when(x) {
    is String -> x.startsWith("prefix")
    else -> false
}

5.when 也可以用来取代 if-else if链。如果不提供参数，所有的分支条件都是简单的布尔表达式，而当一个分支的条件为真时则执行该分支：

fun main(args: Array<String>) {
    var x = 0
    when (x) {
        0, 1 -> println("x == 0 or x == 1")
        else -> println("otherwise")
    }

    when (x) {
        1 -> println("x == 1")
        2 -> println("x == 2")
        else -> { // 注意这个块
            println("x 不是 1 ，也不是 2")
        }
    }

    when (x) {
        in 0..10 -> println("x 在该区间范围内")
        else -> println("x 不在该区间范围内")
    }
}
//输出
//x == 0 or x == 1
//x 不是 1 ，也不是 2
//x 在该区间范围内

6.when 中使用 in 运算符来判断集合内是否包含某实例：

fun main(args: Array<String>) {
    val items = setOf("apple", "banana", "kiwi")
    when {
        "orange" in items -> println("juicy")
        "apple" in items -> println("apple is fine too")
    }
}

内容很基础，就当复习复习java吧！

&岁月不待人&

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Android--kotlin基础（三）

7.区间区间表达式由具有操作符形式..的 rangeTo 函数辅以 in 和 !in 形成。区间是为任何可比较类型定义的，但对于整型原生类型，它有一个优化的实现。以下是使用区间的一些示例:举个栗子：fun main(args: Array<String>) { print("循环输出：") for (i in 1..4) print(i) // 输出“1234” println("\n----------------") print("设置..
复制链接

扫一扫