【Kotlin基础系列】第4章类型

【Kotlin基础系列】第4章类型
1 基本类型

在 Kotlin 中，所有东西都是对象，在这个意义上讲我们可以在任何变量上调用成员函数与属性。一些类型可以有特殊的内部表示——例如，数字、字符以及布尔可以在运行时表示为原生类型值，但是对于用户来说，它们看起来就像普通的类。在本节中，我们会描述 Kotlin 中使用的基本类型：数字、布尔、字符、数组与字符串。

1.1 数字

1.1.1 整数类型

整型基本同Java，分别是Byte，Short，Int，Long四种类型。

未超出 Int 最大值的整型值初始化的变量都会默认推断为 Int 类型。如果初始值超过了其最大值，那么推断为 Long 类型，如需显式指定 Long 型值，请在该值后追加 L 后缀。
```
val one = 1 // Int
val threeBillion = 3000000000 // Long
val oneLong = 1L // Long
val oneByte: Byte = 1
```
1.1.2 浮点类型

Kotlin浮点类型也基本同Java，单精度浮点型Float，双精度浮点型Double。

可以使用带小数部分的数字初始化 Double 与 Float 变量。小数部分与整数部分之间用句点（.）分隔对于以小数初始化的变量，编译器会默认推断为 Double 类型，如需将一个值显式指定为 Float 类型，请添加 f 或 F 后缀。如果这样的值包含多于 6～7 位十进制数，那么会将其舍入。
```
val pi = 3.14 // Double
// val one: Double = 1 // 错误：类型不匹配
val oneDouble = 1.0 // Double
val eFloat = 2.7182818284f // Float，实际值为 2.7182817
```
请注意，与一些其他语言不同，Kotlin 中的数字没有隐式拓宽转换。例如，具有 Double 参数的函数只能对 Double 值调用，而不能对 Float、 Int 或者其他数字值调用。如要调用需要使用显示转换toDouble()。
```
fun main() {
    fun printDouble(d: Double) { print(d) }
 
    val i = 1    
    val d = 1.0
    val f = 1.0f 
 
    printDouble(d)
//    printDouble(i) // 错误：类型不匹配
//    printDouble(f) // 错误：类型不匹配
}
```
1.1.3 字面常量

数值常量字面值有以下几种:
- 十进制: 123
  - Long 类型用大写 L 标记: 123L
- 十六进制: 0x0F
- 二进制: 0b00001011
- 八进制：不支持
Kotlin 同样支持浮点数的常规表示方法:
- 默认 double：123.5、123.5e10
- Float 用 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
```
1.1.4 JVM 平台的数字表示

JVM 平台数字存储为原生类型 int、 double 等。例外情况是当创建可空数字引用如 Int? 或者使用泛型时。在这些场景中，数字会装箱为 Java 类 Integer、 Double 等。

请注意，对相同数字的可为空引用可能是不同的对象，由于 JVM 对 -128 到 127 的整数（Integer）应用了内存优化，因此，a 的所有可空引用实际上都是同一对象。但是没有对 b 应用内存优化，所以它们是不同对象，但值相同。
```
fun main() {
    val a: Int = 100
    val boxedA: Int? = a
    val anotherBoxedA: Int? = a
 
    val b: Int = 10000
    val boxedB: Int? = b
    val anotherBoxedB: Int? = b
 
    println(boxedA === anotherBoxedA) // true
    println(boxedB === anotherBoxedB) // false
    println(boxedA == anotherBoxedA)  // true
    println(boxedB == anotherBoxedB)  // true
}
```
1.1.5 显式转换

由于不同的表示方式，较小类型并不是较大类型的子类型。如果它们是的话，就会出现下述问题：
```
// 假想的代码，实际上并不能编译：
val a: Int? = 1 // 一个装箱的 Int (java.lang.Integer)
val b: Long? = a // 隐式转换产生一个装箱的 Long (java.lang.Long)
print(b == a) // 惊！这将输出“false”鉴于 Long 的 equals() 会检测另一个是否也为 Long
```
所以会悄无声息地失去相等性，更别说同一性了。

因此较小的类型不能隐式转换为较大的类型。这意味着把 Byte 型值赋给一个 Int 变量必须显式转换。
```
fun main() {
    val b: Byte = 1 // OK, 字面值会静态检测
    // val i: Int = b // 错误
    val i1: Int = b.toInt()
}
```
所有数字类型都支持转换为其他类型：
- toByte(): Byte
- toShort(): Short
- toInt(): Int
- toLong(): Long
- toFloat(): Float
- toDouble(): Double
- toChar(): Char
很多情况都不需要显式类型转换，因为类型会从上下文推断出来，而算术运算会有重载做适当转换，例如：
```
val l = 1L + 3 // Long + Int => Long
```
1.1.6 运算

Kotlin支持数字运算的标准集：+、 -、 *、 /、 %。它们已定义为相应的类成员。
```
fun main() {
    println(1 + 2)
    println(2_500_000_000L - 1L)
    println(3.14 * 2.71)
    println(10.0 / 3)
}
```
1.整数除法

整数间的除法总是返回整数。会丢弃任何小数部分。如需返回浮点类型，请将其中的一个参数显式转换为浮点类型。
```
fun main() {
    val a = 5 / 2
    println(x == 2)         // true
 
    val b = 5L / 2
    println(b == 2L)        // true
 
    val c = 5 / 2.toDouble()
    println(c == 2.5)       // true
}
```
2.位运算

Kotlin 对整数提供了一组位运算。它们直接使用数字的比特表示在二进制级别进行操作。位运算有可以通过中缀形式调用的函数表示。只能应用于 Int 与 Long。
```
val x = (1 shl 2) and 0x000FF000
```
这是完整的位运算列表：
- shl(bits) – 有符号左移
- shr(bits) – 有符号右移
- ushr(bits) – 无符号右移
- and(bits) – 位与
- or(bits) – 位或
- xor(bits) – 位异或
- inv() – 位非
1.1.7 浮点数比较

浮点数操作如下：
- 相等性检测：a == b 与 a != b
- 比较操作符：a < b、 a > b、 a <= b、 a >= b
- 区间实例以及区间检测：a..b、 x in a..b、 x !in a..b
当其中的操作数 a 与 b 都是静态已知的 Float 或 Double 或者它们对应的可空类型（声明为该类型，或者推断为该类型，或者智能类型转换的结果是该类型），两数字所形成的操作或者区间遵循 IEEE 754 浮点运算标准。

然而，为了支持泛型场景并提供全序支持，当这些操作数并非静态类型为浮点数（例如是 Any、 Comparable<……>、类型参数）时，这些操作使用为 Float 与 Double 实现的不符合标准的 equals 与 compareTo，这会出现：
- 认为 NaN 与其自身相等
- 认为 NaN 比包括正无穷大（POSITIVE_INFINITY）在内的任何其他元素都大
- 认为 -0.0 小于 0.0
1.1.8 无符号整型

除了整数类型，对于无符号整数，Kotlin 还提供了以下类型：
- UByte: 无符号 8 比特整数，范围是 0 到 255
- UShort: 无符号 16 比特整数，范围是 0 到 65535
- UInt: 无符号 32 比特整数，范围是 0 到 2^32 - 1
- ULong: 无符号 64 比特整数，范围是 0 到 2^64 - 1
无符号类型支持其对应有符号类型的大多数操作。

1.无符号数组与区间

与原生类型相同，每个无符号类型都有表示相应类型数组的类型：
- UByteArray: 无符号字节数组
- UShortArray: 无符号短整型数组
- UIntArray: 无符号整型数组
- ULongArray: 无符号长整型数组
与有符号整型数组一样，它们提供了类似于 Array 类的 API 而没有装箱开销。

区间与数列也支持 UInt 与 ULong（通过这些类 UIntRange、 UIntProgression、 ULongRange、 ULongProgression）。

2.字面值

为使无符号整型更易于使用，Kotlin 提供了用后缀标记整型字面值来表示指定无符号类型（类似于 Float 或 Long）：u与U将字面值标记为无符号，uL与UL显示将字面值标记为无符号长整型。
```
val b: UByte = 1u  // UByte，已提供预期类型
val s: UShort = 1u // UShort，已提供预期类型
val l: ULong = 1u  // ULong，已提供预期类型
 
val a1 = 42u // UInt：未提供预期类型，常量适于 UInt
val a2 = 0xFFFF_FFFF_FFFFu // ULong：未提供预期类型，常量不适于 UInt
 
val a = 1UL // ULong，即使未提供预期类型并且常量适于 UInt
```
1.2 布尔

类型Boolean表示可以有两个值的布尔对象：true和false。Boolean有一个可为null的对应项Boolean？也有空值。布尔对象的可空引用与数字类似地被装箱。
```
fun main() {
    val myTrue: Boolean = true
    val myFalse: Boolean = false
    val boolNull: Boolean? = null
 
    println(myTrue || myFalse)
    println(myTrue && myFalse)
    println(!myTrue)
}
```
1.3 字符

字符用 Char 类型表示。字符字面值用单引号括起来: '1'。

特殊字符可以以转义反斜杠 \ 开始。支持这几个转义序列：\t、 \b、\n、\r、\'、\"、\\ 与 \$。

编码其他字符要用 Unicode 转义序列语法：'\uFF00'。

如果字符变量的值是数字，可以使用digitToInt（）函数将其显式转换为Int数，与数字一样，当需要可为空的引用时，字符也会被装箱，装箱操作不保留标识。
```
fun main() {
    val aChar: Char = 'a'
 
    println(aChar)
    println('\n') //prints an extra newline character
    println('\uFF00')
}
```
1.4 字符串

Kotlin 中字符串用 String 类型表示。通常，字符串值是双引号中的字符序列("")。

1.字符串的元素——字符可以使用索引运算符访问，可以使用for循环迭代这些字符。

2.字符串是不可变的，一旦初始化字符串，就无法更改其值或为其分配新值。所有转换字符串的操作都会在新的String对象中返回结果，而原始字符串保持不变。

3.如需连接字符串，可以用 + 操作符。这也适用于连接字符串与其他类型的值，只要表达式中的第一个元素是字符串。
```
fun main() {
    val str = "abcd"
    for (c in str) {
        println(c)
    }
 
    val str = "abcd"
    println(str.uppercase()) // Create and print a new String object
    println(str) // the original string remains the same
 
    val s = "abc" + 1
    println(s + "def")
}
```
1.4.1 字符串字面值

Kotlin 有两种类型的字符串字面值:
- 转义字符串可以包含转义字符
- 原始字符串可以包含换行以及任意文本
```
// 转义采用传统的反斜杠（\）方式
val s = "Hello, world!\n"
 
// 原始字符串 使用三个引号（"""）分界符括起来
// 内部没有转义并且可以包含换行以及任何其他字符
val text = """
    for (c in "foo")
        print(c)
"""
```
- 要从原始字符串中删除前导空格，请使用trimMargin（）函数，默认 | 用作边界前缀，但你可以选择其他字符并作为参数传入，比如 trimMargin(">")。
```
val text = """
|Tell me and I forget.
|Teach me and I remember.
|Involve me and I learn.
|(Benjamin Franklin)
    """.trimMargin()
```
1.4.2 字符串模板

字符串字面值可以包含模板表达式——一些小段代码，会求值并把结果合并到字符串中。模板表达式以美元符（$）开头，要么由一个的名称构成，要么是用花括号括起来的表达式。
```
fun main() {
    val i = 10
    println("i = $i") // 输出“i = 10”
 
    val s = "abc"
    println("$s.length is ${s.length}") // 输出“abc.length is 3”
}
```
可以在原始字符串和转义字符串中使用模板。要将原始字符串中的$字符（不支持反斜杠转义）插入任何符号之前（允许将其作为标识符的开头），请使用以下语法：
```
val price = """
${'$'}_9.99
"""
```
1.5 数组

数组在 Kotlin 中使用 Array 类来表示。它定义了 get 与 set 函数（按照运算符重载约定这会转变为 []）与 size 属性及其他有用的成员函数：
```
class Array<T> private constructor() {
    val size: Int
    operator fun get(index: Int): T
    operator fun set(index: Int, value: T): Unit
 
    operator fun iterator(): Iterator
    // ……
}
```
可以使用函数 arrayOf() 来创建一个数组并传递元素值给它，这样 arrayOf(1, 2, 3) 创建了 array [1, 2, 3]。或者，函数 arrayOfNulls() 可以用于创建一个指定大小的、所有元素都为空的数组。

另一个选项是用接受数组大小以及一个函数参数的 Array 构造函数，用作参数的函数能够返回给定索引的元素：
```
fun main() {
    // 创建一个 Array 初始化为 ["0", "1", "4", "9", "16"]
    val asc = Array(5) { i -> (i * i).toString() }
    asc.forEach { println(it) }
}
```
如上所述，[] 运算符代表调用成员函数 get() 与 set()。

Kotlin 中数组是不型变的（invariant）。这意味着 Kotlin 不让我们把 Array 赋值给 Array，以防止可能的运行时失败（但是你可以使用 Array, 参见类型投影）。

1.5.1 原生类型数组

Kotlin 也有无装箱开销的类来表示原生类型数组: ByteArray、 ShortArray、IntArray 等等。这些类与 Array 并没有继承关系，但是它们有同样的方法属性集。它们也都有相应的工厂方法:
```
val x: IntArray = intArrayOf(1, 2, 3)
x[0] = x[1] + x[2]
 
// 大小为 5、值为 [0, 0, 0, 0, 0] 的整型数组
val arr = IntArray(5)
 
// 例如：用常量初始化数组中的值
// 大小为 5、值为 [42, 42, 42, 42, 42] 的整型数组
val arr = IntArray(5) { 42 }
 
// 例如：使用 lambda 表达式初始化数组中的值
// 大小为 5、值为 [0, 1, 2, 3, 4] 的整型数组（值初始化为其索引值）
var arr = IntArray(5) { it * 1 }
```
2. 类型检测与类型转换

2.1 is 与 !is 操作符
```
if (obj is String) {
    print(obj.length)
}
 
if (obj !is String) { // 与 !(obj is String) 相同
    print("Not a String")
} else {
    print(obj.length)
}
```
2.2 智能转换

1.大多数场景都不需要在 Kotlin 中使用显式转换操作符，因为编译器跟踪不可变值的 is-检测以及显式转换，并在必要时自动插入（安全的）转换

2.编译器足够聪明，能够知道如果反向检测导致返回那么该转换是安全的。

3.或者在 && 或 || 的右侧正确的检查（常规或阴性）在左侧

4.智能转换用于 when 表达式和 while 循环也一样
```
fun demo(x: Any) {
    if (x is String) {
        // x 自动转换为字符串
        print(x.length) 
    }
 
    if (x !is String) return
    // x 自动转换为字符串
    print(x.length) 
 
    // `||` 右侧的 x 自动转换为 String
    if (x !is String || x.length == 0) return
    // `&&` 右侧的 x 自动转换为 String
    if (x is String && x.length > 0) {
        // x 自动转换为 String
        print(x.length) 
    }
 
    when (x) {
        is Int -> print(x + 1)
        is String -> print(x.length + 1)
        is IntArray -> print(x.sum())
    }
}
```
请注意，当编译器能保证变量在检测和使用之间不可改变时，智能转换才有效。更具体地，智能转换适用于以下情形
- val 局部变量——总是可以，局部委托属性除外。
- val 属性——如果属性是 private 或 internal，或者该检测在声明属性的同一模块中执行。智能转换不能用于 open 的属性或者具有自定义 getter 的属性。
- var 局部变量——如果变量在检测和使用之间没有修改、没有在会修改它的 lambda 中捕获、并且不是局部委托属性。
- var 属性——决不可能（因为该变量可以随时被其他代码修改）。
2.3 “不安全的”转换操作符

通常，如果转换是不可能的，转换操作符会抛出一个异常。因此，称为不安全的。 Kotlin 中的不安全转换使用中缀操作符 as。
```
// 如果y为null会报错
val x: String = y as String
// 正确写法如下：
val x: String? = y as String
```
2.4 “安全的”（可空）转换操作符

为了避免异常，可以使用安全转换操作符 as?，它可以在失败时返回 null

请注意，尽管事实上 as? 的右边是一个非空类型的 String，但是其转换的结果是可空的。
```
val x: String? = y as? String
```
2.5 类型擦除与泛型检测

Kotlin 在编译时确保涉及泛型操作的类型安全性，而在运行时，泛型类型的实例并未带有关于它们实际类型参数的信息。例如， List 会被擦除为 List<*>。通常，在运行时无法检测一个实例是否属于带有某个类型参数的泛型类型。

因此，编译器会禁止由于类型擦除而无法执行的 is 检测，例如 ints is List 或者 list is T（类型参数）。当然，你可以对一个实例检测星投影的类型：
```
if (something is List<*>) {
    // 这些项的类型都是 `Any?`
    something.forEach { println(it) } 
}
```
类似地，当已经让一个实例的类型参数（在编译期）静态检测，就可以对涉及非泛型部分做 is 检测或者类型转换。请注意，在这种情况下，会省略尖括号：
```
fun handleStrings(list: List<String>) {
    if (list is ArrayList) {
        // `list` 会智能转换为 `ArrayList`
    }
}
```
省略类型参数的这种语法可用于不考虑类型参数的类型转换：list as ArrayList。

带有具体化的类型参数的内联函数使其类型实参在每个调用处内联。这就能够对类型参数进行 arg is T 检测，但是如果 arg 自身是一个泛型实例，其类型参数还是会被擦除。
```
inline fun <reified A, reified B> Pair<*, *>.asPairOf(): Pair? {
    if (first !is A || second !is B) return null
    return first as A to second as B
}
 
val somePair: Pair = "items" to listOf(1, 2, 3)
 
 
val stringToSomething = somePair.asPairOf()
val stringToInt = somePair.asPairOfInt>()
val stringToList = somePair.asPairOf>()
val stringToStringList = somePair.asPairOf>() // Compiles but breaks type safety!
// Expand the sample for more details
 
 
fun main() {
    println("stringToSomething = " + stringToSomething)
    println("stringToInt = " + stringToInt)
    println("stringToList = " + stringToList)
    println("stringToStringList = " + stringToStringList)
    //println(stringToStringList?.second?.forEach() {it.length}) // This will throw ClassCastException as list items are not String
}
```
2.6 非受检类型转换

如上所述，类型擦除使运行时不可能对泛型类型实例的类型实参进行检测。另外代码中的泛型可能相互连接不够紧密，以致于编译器无法确保类型安全。

即便如此，有时候我们有高级的程序逻辑来暗示类型安全。例如：
```
fun readDictionary(file: File): Map = file.inputStream().use {
   TODO("Read a mapping of strings to arbitrary elements.")
}
 
// 我们已将存有一些 `Int` 的映射保存到这个文件
val intsFile = File("ints.dictionary")
 
// Warning: Unchecked cast: `Map` to `Map`
val intsDictionary: MapInt> = readDictionary(intsFile) as MapInt>
```
最后一行的类型转换会出现一个警告。编译器无法在运行时完全检测该类型转换，并且不能保证映射中的值是“Int”。

为避免未受检类型转换，可以重新设计程序结构。在上例中，可以使用具有类型安全实现的不同接口 DictionaryReader 与 DictionaryWriter。可以引入合理的抽象，将未受检的类型转换从调用处移动到实现细节中。正确使用泛型型变也有帮助。

对于泛型函数，使用具体化的类型参数可以使形如 arg as T 这样的类型转换受检，除非 arg 对应类型的自身类型参数已被擦除。

可以通过在产生警告的语句或声明上用注解 @Suppress("UNCHECKED_CAST") 标注来禁止未受检类型转换警告：
```
inline fun <reified T> List<*>.asListOfType(): List? =
    if (all { it is T })
        @Suppress("UNCHECKED_CAST")
        this as List else
        null
```
对于 JVM 平台：数组类型（Array）会保留关于其元素被擦除类型的信息，并且类型转换为一个数组类型可以部分受检：元素类型的可空性与类型实参仍然会被擦除。例如，如果 foo 是一个保存了任何 List<*>（无论可不可空）的数组的话，类型转换 foo as Array?> 都会成功。
相关阅读:
学生个人网页设计作品：旅游网页设计与实现——成都旅游网站4个页HTML+CSS web前端网页设计期末课程大作业学生DW静态网页设计学生个人网页设计作品
 nuitka 打包成exe文件怎么样打包可以不需要安装python环境运行
 流水线的实现
 2020最新Java常见面试题及答案
 现代循环神经网络 - 机器翻译与数据集
 文件或者文件夹的忽略
 意大利法院认可GPL开源协议的法律效力
 QT专栏2 -Qt for Android
单片机器件元器件选型
 Lru-k在Rust中的实现及源码解析
原文地址：https://blog.csdn.net/u010687761/article/details/127039884

【Kotlin基础系列】第4章 类型

1 基本类型

1.1 数字

1.1.1 整数类型

1.1.2 浮点类型

1.1.3 字面常量

1.1.4 JVM 平台的数字表示

1.1.5 显式转换

1.1.6 运算

1.1.7 浮点数比较

1.1.8 无符号整型

1.2 布尔

1.3 字符

1.4 字符串

1.4.1 字符串字面值

1.4.2 字符串模板

1.5 数组

1.5.1 原生类型数组

2. 类型检测与类型转换

2.1 is 与 !is 操作符

2.2 智能转换

2.3 “不安全的”转换操作符

2.4 “安全的”（可空）转换操作符

2.5 类型擦除与泛型检测

2.6 非受检类型转换