Kotlin基础之基本类型

在Kotlin中,一切都是一个对象,我们可以在任何变量上调用成员函数和属性。一些类型是内置的,因为它们的实现被优化。对于用户而言,它们看起来像普通类。本节我们将描述大多数类型:数字,字符,布尔和数组。

数字

Kotlin以接近Java的方式处理数字,但不完全相同。 例如,数字没有隐含的扩展转换,在某些情况下,字面值也有些许不同。

Kotlin提供了以下代表数字的内置类型(类似于Java):

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

注意:字符类型(char)在Kotlin中不代表数字。

字面量

基本存在以下几种字面常量:

  1. 小数(Decimals),整形:123
  2. 以大写L为标记的Long型:123L
  3. 十六进制:0x0F
  4. 二进制:0b00001011

注意:不支持八进制

Kotlin也支持一个常规的浮点数符号:

  1. 默认的Double类型:123.5,123.5e10
  2. 以f或F标记的Float类型:123.5F

数字下划线(1.1引入)

为了增加数字常量的可读性,可以引入下划线:

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) // Prints 'true'
val boxedA: Int? = a
val anotherBoxedA: Int? = a
print(boxedA === anotherBoxedA) // !!!Prints 'false'!!!

另一方面,它们又保持相等:

val a: Int = 10000
print(a == a) // Prints 'true'
val boxedA: Int? = a
val anotherBoxedA: Int? = a
print(boxedA == anotherBoxedA) // Prints 'true'

显式转换

由于不同的表示,较小的类型不是较大的类型。 如果他们是,我们会有以下的麻烦:

// Hypothetical code, does not actually compile:
val a: Int? = 1 // A boxed Int (java.lang.Integer)
val b: Long? = a // implicit conversion yields a boxed Long (java.lang.Long)
print(a == b) // Surprise! This prints "false" as Long's equals() check for other part to be Long as well

所以不仅恒等,而且相等的情况也不再存在。因此,较小的类型不会被隐式转换为更大的类型。这意味着我们不能在没有显式转换的情况下将Byte类型的值赋给Int变量。

val b: Byte = 1 // OK, literals are checked statically
val i: Int = b // ERROR

我们可以使用显式转换将数字放宽:

val i: Int = b.toInt() // OK: explicitly widened

每一个数字类型都支持以下转换:

  1. toByte(): Byte
  2. toShort(): Short
  3. toInt(): Int
  4. toLong(): Long
  5. toFloat(): Float
  6. toDouble(): Double
  7. toChar(): Char

隐式转换的缺失很少被注意,因为类型是从上下文推断出来的,而算术运算则被重载为适当的转换,例如:

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

操作(Operations)

Kotlin提供了针对数字进行算术运算的标准集合,它们被声明为适当类的成员(但编译器将调用优化为相应的指令)。

对于按位操作,没有为它们指定特殊的字符,只能调用以中缀形式命名的函数,例如:

val x = (1 shl 2) and 0x000FF000

以下是按位操作的完整列表(仅适用于Int和Long):

  1. shl(bits) – signed shift left (Java's <<)
  2. shr(bits) – signed shift right (Java's >>)
  3. ushr(bits) – unsigned shift right (Java's >>>)
  4. and(bits) – bitwise and
  5. or(bits) – bitwise or
  6. xor(bits) – bitwise xor
  7. inv() – bitwise inversion

字符

字符类型以Char表示,它们不能以数字类型对待。如:

fun check(c: Char) {
    if (c == 1) { // ERROR: incompatible types
        // ...
    }
}

字符类型字面值用单引号表示:'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() // Explicit conversions to numbers
}

和数字一样,当需要一个可null的Char引用的时候被自动装箱。装箱操作不保留恒等。

布尔

Boolean代表布尔类型,该类型的变量有两个可选值:true和false。如果需要可null的引用,该类型被自动装箱。布尔类型的内置操作有:

  1. || 短路或
  2. && 短路与
  3. ! 非

数组

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)将创建一个数组[1,2,3]。除此之外,arrayOfNulls()库函数也可以用于创建一个填充有空元素的给定大小的数组。

另一个选择是使用一个工厂函数,它使用数组大小和可以返回给定其索引的每个数组元素的初始值的函数:

// Creates an Array<String> with values ["0", "1", "4", "9", "16"]
val asc = Array(5, { i -> (i * i).toString() })

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

注意:与Java不同,Kotlin中的数组是不可变的。 这意味着Kotlin不允许我们将Array<String>分配给Array<Any>,这样可以防止运行时异常(但是可以使用Array<out Any>)。

Kotlin也有专门的类来表示原始类型的数组:ByteArray,ShortArray,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(“>”)

字符串模板(String Templates)

字符串可以包含模板表达式,即被估值计算的代码片段,并且其结果会被连接到字符串中。 模板表达式以美元符号($)开头,并含有简单名称组成:

val i = 10
val s = "i = $i" // evaluates to "i = 10"

或大括号中的任意表达式:

val s = "abc"
val str = "$s.length is ${s.length}" // evaluates to "abc.length is 3"

原始字符串和转义字符串内部都支持模板。 如果您需要在原始字符串(不支持反斜杠转义)中表示一个文字$字符,则可以使用以下语法:

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

推荐阅读更多精彩内容