Kotlin 2.1.0 入门教程（四）

基本类型

从某种意义上说，一切都是对象，因为您可以在任何变量上调用成员函数和属性。

虽然某些类型在运行时具有优化的内部表示形式（如数字、字符、布尔值等），但它们看起来和行为都像普通类。

即使基本类型（如 Int、Char、Boolean 等）在运行时被优化为原始值，但它们在代码中仍然表现为对象，可以调用成员函数和属性。

fun main() {
    val number = 42
    number.toDouble() // 调用 Int 的成员函数。

    val isTrue = true
    isTrue.toString() // 调用 Boolean 的成员函数。
}

整型

对于整数，有四种类型，它们具有不同的大小，因此值范围也不同。

整数类型包括 Byte、Short、Int 和 Long，它们分别具有不同的存储大小和值范围。

fun main() {
    val byte: Byte = 127 // 8 位，范围：-128 到 127。
    val short: Short = 32767 // 16 位，范围：-32768 到 32767。
    val int: Int = 2147483647 // 32 位，范围：-2^31 到 2^31 - 1。
    val long: Long = 9223372036854775807 // 64 位，范围：-2^63 到 2^63 - 1。
}

当初始化变量而没有显式指定类型时，编译器会自动推断出足以表示该值的最小范围类型，从 Int 开始。如果值不超过 Int 的范围，则类型为 Int。如果超过，则类型为 Long。

要显式指定 Long 值，请在值后附加后缀 L。

显式类型指定会触发编译器检查值是否超出指定类型的范围。

val one = 1 // Int
val threeBillion = 3000000000 // Long
val oneLong = 1L // Long
val oneByte: Byte = 1 // Byte

浮点型

Float 和 Double 分别具有不同的存储大小和精度。

fun main() {
    val floatValue: Float = 3.14f // 32 位，单精度。
    val doubleValue: Double = 3.14 // 64 位，双精度。
}

如果使用小数初始化变量，编译器会默认推断为 Double 类型。

fun main() {
    val pi = 3.14 // Double
    // val one: Double = 1 // error
    val oneDouble = 1.0 // Double
}

要显式指定值为 Float 类型，请添加后缀 f 或 F。

如果该值包含超过 6-7 位小数，则会被四舍五入。

fun main() {
    val e = 2.7182818284 // Double
    val eFloat = 2.7182818284f // Float
    println(e) // 2.7182818284
    println(eFloat) // 2.7182817
}

与其他语言不同，Kotlin 中没有数字的隐式拓宽转换。

例如，具有 Double 参数的函数只能在 Double 值上调用，而不能在 Float、Int 或其他数值上调用。

必须显式进行类型转换才能将一种数字类型传递给另一种类型的参数。

fun printDouble(d: Double) {
    println(d)
}

fun main() {
    val intValue = 42
    val floatValue = 3.14f

    // printDouble(intValue) // 错误：类型不匹配。
    // printDouble(floatValue) // 错误：类型不匹配。

    printDouble(intValue.toDouble()) // 正确：显式转换为 Double 类型。
    printDouble(floatValue.toDouble()) // 正确：显式转换为 Double 类型。
}

数字的字面常量

整数值有以下几种字面常量：

• 十进制：123

• 十六进制：0x0F

• 二进制：0b00001011

• 不支持八进制

• Long 类型用大写 L 标记：123L

浮点数值有以下几种字面常量：

• 默认是 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

JVM 上的数字表示

在 JVM 平台上，数字存储为原始类型：int、double 等。

例外情况是，当创建可空数字引用（如 Int?、Double? 等）或使用泛型时。数字会被装箱为 Java 类 Integer、Double 等。

对相同数字的可空引用可能指向不同的对象。

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
}

由于 JVM 对 -128 到 127 之间的 Integer 应用了内存优化，所有对 a 的可空引用实际上是同一个对象。

这种优化不适用于 b 引用，b 指向不同的对象（因为 10000 超出缓存范围）。

另一方面，它们仍然是相等的。

fun main() {
    val b: Int = 10000
    println(b == b) // true
    
    val boxedB: Int? = b
    val anotherBoxedB: Int? = b
    println(boxedB == anotherBoxedB) // true
}

显式数字转换

由于表示方式不同，较小的类型不是较大类型的子类型。如果它们是，我们可能会遇到以下问题。

// 假设的代码，实际上无法编译。
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
    val i: Int = b.toInt() // ok
    // val j: Int = b // error
}

所有数字类型都支持转换为其他类型：

• toByte(): Byte

• toShort(): Short

• toInt(): Int

• toLong(): Long

• toFloat(): Float

• toDouble(): Double

在许多情况下，不需要显式转换，因为类型可以从上下文中推断出来，并且算术操作已重载以进行适当的转换。

fun main() {
    val b: Int = 10000
val c: Long = b + 1L // ok
    // val d: Long = b // error
}

运算

整数之间的除法总是返回一个整数。任何小数部分都会被丢弃。

fun main() {
    println(1 + 2) // 3
    
    println(2_500_000_000L - 1L) // 2499999999
    
    println(3.14 * 2.71) // 8.5094
    println(3.14 * 2) // 6.28
    println(3 * 2) // 6
    println(3.14.toInt() * 2) // 6
    
    println(10.0 / 3) // 3.3333333333333335
    println(10 / 3) // 3
    println(10 / 3.toDouble()) // 3.3333333333333335
    println((10 / 3).toDouble()) // 3.0
    
    val x = 5L / 2
    println(x == 2L) // true
    
    println(5 % 2) // 1
}

位操作

提供了一组对整数进行位操作的函数。它们直接在二进制级别上操作数字的位表示。

位操作由可以以中缀形式调用的函数表示。它们只能应用于 Int 和 Long 类型。

以下是位操作的完整列表：

• shl(bits) —— 有符号左移

• shr(bits) —— 有符号右移

• ushr(bits) —— 无符号右移

• and(bits) —— 按位与

• or(bits) —— 按位或

• xor(bits) —— 按位异或

• inv() —— 按位取反

val x = (1 shl 2) and 0x00_0F_F0_00

浮点数比较

浮点数操作包括：

• 相等性检查：a == b 和 a != b

• 比较操作符：a < b、a > b、a <= b、a >= b

• 范围实例化和范围检查：a .. b、x in a .. b、x !in a .. b

fun main() {
    val a = 0.6 / 2
    
    println(a == 0.3) // true
    println(a != 0.31) // true
    
    if (a < 0.31) println("a < 0.31") // a < 0.31
    if (a <= 0.3) println("a <= 0.3") // a <= 0.3
    if (a > 0.2999999) println("a > 0.2999999") // a > 0.2999999
    if (a >= 0.300000) println("a >= 0.300000") // a >= 0.300000
}

fun main() {
    val a = 0.6 / 2
    
    if (a in 0.299 .. 0.301) println("a in 0.299 .. 0.301") // a in 0.299 .. 0.301
    if (a !in 0.399 .. 0.401) println("a !in 0.399 .. 0.401") // a !in 0.399 .. 0.401
}

然而，为了支持通用用例并提供全序关系，对于未静态类型化为浮点数的操作数，行为会有所不同。例如，Any、Comparable<...> 或 Collection<T> 类型。在这种情况下，操作使用 Float 和 Double 的 equals 和 compareTo 实现。因此：

• NaN 被认为等于自身

• NaN 被认为大于任何其他元素，包括 POSITIVE_INFINITY

• -0.0 被认为小于 0.0

以下展示了静态类型化为浮点数的操作数（Double.NaN）和未静态类型化为浮点数的操作数（listOf(T)）之间的行为差异。

fun main() {
    // 静态类型化为浮点数的操作数。
    println(Double.NaN == Double.NaN) // false
    
    // 操作数未静态类型化为浮点数，因此 NaN 等于自身。
    println(listOf(Double.NaN) == listOf(Double.NaN)) // true

    // 静态类型化为浮点数的操作数。
    println(0.0 == -0.0) // true
    
    // 操作数未静态类型化为浮点数，因此 -0.0 小于 0.0。
    println(listOf(0.0) == listOf(-0.0)) // false

    // [-0.0, 0.0, Infinity, NaN]
    println(listOf(Double.NaN, Double.POSITIVE_INFINITY, 0.0, -0.0).sorted())
}

原文地址：https://blog.csdn.net/qq_19661207/article/details/145229732

免责声明：本站文章内容转载自网络资源，如侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！