基础类型

在Kotlin中，一切皆是对象，因此我们可以在任何变量上调用成员函数和属性。一些类型可以有特殊的内部表示，如:数字、字符和布尔值可以在运行时表示为原生类型值。本节中，我们描述Kotlin中使用的基本类型:数字、字符、布尔值、数组与字符串。

数字

Kotlin处理数字在某种程度上接近Java，但是并不完全相同。例如，对于数字没有隐式拓展转换，另外有些情况的字面值略有不同。
Kotlin提供了如下的内置类型来表示数字(与Java很相近)

类型	位宽度
Double	64
Float	32
Long	64
Int	32
Short	16
Byte	8

注意在Kotlin中字符不是数字

字面常量/文字常量

数值常量字面有以下几种:

• 整数:123
• 长整数由大写L标记:123L
• 十进制:123
• 十六进制:0x0f
• 二进制:0000111
  不支持八进制

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

表示方式

在Java平台数字是物理储存为JVM的原生类型，除非我们需要一个可空的引用（如：Int？）或泛型。后者情况下会把数字装箱。

注意，装箱数字不一定保留同一性

val a: Int = 10000

print(a === a) // 输出“true”

val boxedA: Int? = a

val anotherBoxedA: Int? = a

print(boxedA === anotherBoxedA) // !!! 输出“fales” ！！！

另一方面，保留了相等性

val a: Int = 10000

print(a == a) // 输出“true”

val boxedA: Int? = a

val anotherBoxedA: Int? = a

print(boxedA == anotherBoxedA) // 输出“true”

显示转换

由于不同的表示方式，较小类型并不是较大类型的子类型。如果它们是的话，就会出现下述问题：

// 假想的代码，实际上并不能编译：

val a: Int? = 1 // 一个装箱的 Int （java.lang.Integer）

val b: Long? = a // 隐式转换产生一个装箱的 Long（java.lang.Long）

print(a == b) // 这将输出“false” 鉴于Long的equals() 检测其他部分也是Long

所以同一性还有相等性都会在所有地方悄无声息地失去。

因此较小的类型不能隐式转换为较大的类型。这意味着在不进行显式转换的情况下我们不能把Byte型值赋给一个Int变量。

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

val i：Int = b // 错误

可以显式转换来拓宽数字

val i: Int = b.toInt() //OK: 显式拓宽

每个数字类型支持如下的转换：

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

缺乏隐式类型转换并不显著，因为类型会从上下文推断出来，而算术运算会有重载做适当转换，例如：

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

运算

Kotlin支持数字运算的标准集，运算被定义为相应的类成员（但编译器会将函数调用优化为相应的指令）

对于位运算，没有特殊字符来表示，而只可用中缀方式调用命名函数，例如：

val x = (1 shl 2) and 0x000FF000

完整的位运算列表（只用于Int和Long）：

• shl（bits）— 有符号左移（Java的<<）
• shr(bits) — 有符号右移 （Java的>>）
• ushr(bits) — 无符号右移 （Java的>>）
• and(bits) — 位与
• or(bits) — 位或
• xor(bits) — 位异或
• inv() — 位非

浮点数比较

浮点数操作如下：

• 相等性检测： 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 或者它们对应的可空类型（声明为该类型，或者推断为该类型，或者智能类型转换的结果是该类型），两数字所形成的操作或者区间，遵循IEEE754浮点运算标准。

然而，为了支持泛型场景并提供全序支持，当这些操作符并非静态类型为浮点数（例如是Any、Comparable<......>、类型参数）时，这些操作使用为 Float 与 Double 实现的不符合标准的equels 与 compareTo ,这会出现：

• 认为 NaN 与其自身相等
• 认为 NaN 比包括正无穷大（POSITIVE_INFINITY）在内的任何其他元素都大
• 认为 -0.0 小于 0.0

字符

字符用 char 类型表示。它们不能直接当作数字

fun check(c: Char){
    if (c == 1){  // 错误：类型不兼容
    // ....
    }
}

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

还可将一个显式字符转换为 Int 类型数字：

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

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

布尔

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

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

内置的布尔运算有：

• || 短路逻辑或(懒分离)
• && 短路逻辑与(懒结合)
• ！ 逻辑非(否定)

数组

数组在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<T>
    // ......
}

可以使用库函数 arrayOf() 来创建一个数组并传递元素值给它， 这样 arrayOf(1, 2, 3) 创建了 array[1, 2, 3]。 或者， 库函数 arrayOfNulls() 可以用于创建一个指定大小的、所有元素都为空的数组。

另一个选项是用接受数组大小和一个函数参数的 Array 构造函数， 用作参数的函数能够返回给定索引的每个元素初始值：

// 创建一个 Array<String> 初始化为 ["0", "1", "4", "9", "16"]
val asc = Array(5, {i -> (i * i).toString()})

如上所述，[ ]操作代表调用成员函数 get() 和 set()

注意： 与Java不同， Kotlin中数组是不型变的（invariant）。这就意味着Kotlin不让我们把 Array<String>

赋值给 Array<Any> , 以防止可能的运行时失败（但是，可以使用 Array<outAny> ）

Kotlin 也有无装箱开销的专门的类来表示原生类型数组：ByteArray ShorArray IntArray 等等。 这些类和 Array 并没有继承关系， 但是它们有同样的方法属性集。它们也都有相应的工厂方法：

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

字符串

字符串用 String 类型表示。 字符串是不可变的。 字符串的元素——字符可以使用索引运算符访问：s[i]。

可以使用 for 循环迭代字符串：

for (c in str){
    println(c)
}

字符串字面值

Kotlin 有两种类型的字符串字面值：转义字符串可以有转义字符，以及原生字符串可以包含换行和任意文本。转义字符串很像Java字符串：

val s = "Hello, world!\n"

转义采用传统的反斜杠方式。（参见转义序列）。

原生字符串，使用三个引号（"""）分界符号括起来，内部没有转义并且可以包含换行和任何其他字符：

val text = """
    for (c in "foo")
    print(c)
"""

可以通过 trimMargin() 函数去除前导空格：

val text = """
    |Tell me and I forget.
    |Teach me and I remember.
    |Involve me and I learn.
    |(Benjamin Franklin)
    """.trimMargin()

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

字符串模板

字符串可以包含模板表达式，即一些小段代码，会求值并把结果合并到字符串中。模板表达式以美元( $ )开头，由一个简单的名字构成：

val i = 10
val s = "i = $i"  // 求值结果为"i = 10"

或者用花括号括起来的任意表达式：

val s = "abc"
val str = "$s.length is ${s.length}"  // 求值结果为"abc.length is 3"

原生字符串和转义字符串内部都支持模板。如果你需要在原生字符串中表示字面值 $ 字符（不支持反斜杠转义）， 可以用下列语法J:

val price = """
${'$'}9.99
"""