kotlin 中的数字

以下均来自官方文档：

一、整数类型

1、kotlin中内置的整数类型，有四种不同大小的类型：

类型	存储大小（比特数）	最小值	最大值
Byte	8	-128	127
Short	16	-32768	32767
Int	32	-2,147,483,648 (-231)	2,147,483,647 (231 - 1)
Long	64	-9,223,372,036,854,775,808 (-263)	9,223,372,036,854,775,807 (263 - 1)

注：

当初始化一个没有显示指定类型的变量时，编译器会自动推断为自Int起足以表示该值的最小类型。意思是：如果不超过Int范围，那么类型为Int，如果超过了，那么类型是Long。如果指定值类型为Long类型，请给该值追加后缀L。如果显示的指定类型，会触发编译器检测该值是否超过指定类型的范围。

2、代码演示

// val或var来定义a = 1，打印类型，默认为java的int类型
fun main() {val a = 1// Kotlin的类型信息在运行时是基于JVM的，所以可以利用Java的反射API来获取类型信息println("类型为: ${a.javaClass.simpleName}") // 类型为: int
}

输出结果： 

 

// 下边打印输出类型为long类型，因为类型推断超出Int类型，所以输出long类型
fun main() {val a = 10000000000000println("类型为: ${a.javaClass.simpleName}") // 类型为: long
}

输出结果： 

显示指定Long类型

// 值后边加上L，来显示指定Long类型，或者 定义Long类型
fun main() {val a = 100Lval b: Long = 100println("类型为: ${a.javaClass.simpleName}") // 类型为: longprintln("类型为: ${b.javaClass.simpleName}") // 类型为: long
}

二、浮点类型

1、kotlin中内置的浮点类型：单精度Float与双精度Double类型

这两个类型的大小不同，并为两种不同精度的浮点数提供存储：

类型	大小（比特数）	有效数字比特数	指数比特数	十进制位数
Float	32	24	8	6-7
Double	64	53	11	15-16

可以使用带小数部分的数字初始化Double与Float变量。小数部分与整数部分之间用点 .  分割，对于以小数初始化的变量，编译器会自动推断为Double类型：

fun main() {val a = 100.1println("类型为: ${a.javaClass.simpleName}") // 类型为: double
}

如果需要将一个值显式指定为Float类型，请添加 f 或 F 后缀。如果值包含多于6到7位十进制数，那么会将其四舍五入：

// 实际测试Float类型多于4到5位十进制数，都会四舍五入，不知为啥！
fun main() {val a = 100.31415966 // 默认推断Double类型val b = 100.3141596f // 指定Float类型println("a为: ${a}") // a为: 100.31415966println("b为: ${b}") // b为: 100.31416
}

三、数字的装箱拆箱

1、在jvm平台，数字的存储为原生类型 int、double等。有例外的情况是：当创建可空数字引用如：泛型、Int? ···。在这些场景中，数字会装箱为JAVA类 Integer、Double等。

解释一下：在java世界里，有两种存放数字的方式：
（1）直接存储数字（原生类型）：
        就像你在口袋里直接放了几块糖，你知道那是几块，可以直接用。在Java中，int、double这些就是这种类型的糖，它们直接存数字，速度快，效率高。比如，你有个int num = 5;，这里的num就像你口袋里的5块糖，很直接。
（2）把数字放进盒子中，在存储（装箱类型）：
        有时候，你可能想要更灵活一点，比如说，你的糖可能会没有（因为没买或者吃完了），这时候你就需要一个盒子来帮助你表示“有糖”或“没糖”。在Java中，如果你用Integer、Double这样的类型，就像是给糖准备了个盒子。当你写Integer num = null;或用在泛型、可空类型如Int?时，就相当于，这个盒子里可能有糖（具体的数字），也可能什么都没有（null）。
装箱就是把简单直接的糖（原生类型）包装进一个盒子（变成对象，如Integer），这样可以做更多事情，比如表示“无糖状态”，但相对的，操作起来比直接拿糖要麻烦一点，因为每次要用糖时，都要从盒子里拿出来（拆箱）。
原生类型（如int、double）直接存储数值，效率高；而像Integer、Double这样的装箱类型，则是把数值包装成对象，可以表示额外的“无值”状态，但在使用时涉及到自动装箱和拆箱，稍微复杂一些。

2、代码演示

fun main() {val a: Int = 100// 装箱，赋值为可空的bval b: Int? = a// 装箱，赋值为可空的cval c: Int? = aval d: Int = 10000// 装箱，赋值为可空的eval e: Int? = d// 装箱，赋值为可空的fval f: Int? = dprintln(b === c) // trueprintln(e === f) // false
}

解释：

上边代码演示了装箱（boxing）和常量池（constant pool）的概念，这是理解打印结果差异的关键。
在Kotlin中，当一个原始类型（如Int）被赋值给一个可空类型（如Int?），这个过程被称为装箱，即原始类型值被封装成一个对象。但是，为了优化性能，Kotlin（以及Java）会对特定范围内的Int值（通常是-128到127）使用缓存，这意味着在这个范围内的值在装箱时会复用同一个对象。这就是所谓的享元模式（Flyweight Pattern），可以减少内存使用并提高效率。
分析代码：

• 对于变量a，它的值是100，处于上述的缓存范围（-128到127）内。所以，当a被装箱赋值给b和c时，这两个变量实际上引用的是同一个缓存中的Integer对象。因此，b === c比较的是两个对象的引用是否相同，结果为true，表示它们确实是同一个对象。

• 变量d的值是10000，超出了常量池的缓存范围。因此，当d被装箱为e和f时，会为每个变量创建一个新的Integer对象，即使它们的值相同。这意味着e和f是两个不同的对象，即使它们的数值相等。因此，e=== f比较的是不同对象的引用，结果为false。

总结：

打印结果的不同是因为值为100的Int对象在装箱时被缓存并复用，而值为10000的Int对象由于超出缓存范围，每次装箱都会创建新的对象实例。这就解释了为什么第一个比较结果为true而第二个为false。

再来看一段代码：

fun main() {val a: Int = 10000// 装箱，赋值为可空的bval b: Int? = a// 装箱，赋值为可空的cval c: Int? = aprintln(b == c) // true
}

为什么上边代码打印结果为true？

解释：

b == c打印出true的原因在于这里使用的是==操作符来进行比较，而不是===。在Kotlin中，==用于比较两个对象的内容（值）是否相等，而===用于比较两个引用是否指向同一个对象（即它们是否完全相同）。

分析代码：

当比较的是两个装箱的Int?类型变量（b和c）时，==操作符会触发自动拆箱（unboxing），并将它们的原始Int值进行比较。在这个例子中，b和c虽然是两个不同的对象（因为它们是分别装箱得到的），但它们的内部整数值都是10000，所以b == c的结果为true。

总结：

b == c是比较的两个变量的值是否相等，而不是它们是否是同一个对象，所以结果是true。

四、类型转换

1、数字类型的互转

• toByte(): 转Byte类型 
• toShort(): 转Short类型
• toInt(): 转Int类型
• toLong(): 转Long类型
• toFloat(): 转Float类型
• toDouble(): 转Double类型

fun main() {val a = 1 // 默认会推断为Int类型println(a.toByte()) // 1println(a.toInt()) // 1println(a.toFloat()) // 1.0println(a.toDouble()) // 1.0println(a.toLong()) // 1println(a.toShort()) // 1
}

五、大小比较及区间检测

1、kotlin中大小比较跟java一样

• 相等性检测：a == b 与 a != b
• 比较操作符：a < b、 a > b、 a <= b、 a >= b
• 区间实例以及区间检测：a..b、 x in a..b、 x !in a..b

代码演示（.. 区间）：

// a..b 表示从a到b这个区间
fun main() {for (i in 1..100){println(i) // 会打印1-100 的数字}
}