kotlin：数据类型

数字类型

1. 整数类型

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

   类型	大小（比特数）	最小值	最大值
   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. 浮点类型

   对于实数，Kotlin 提供了浮点类型 Float 与 Double 类型

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

   可以使用带小数部分的数字初始化 Double 与 Float 变量。 小数部分与整数部分之间用句点（.）分隔 对于以小数初始化的变量，编译器会推断为 Double 类型；如需将一个值显式指定为 Float 类型，请添加 f 或 F 后缀。 如果这样的值包含多于 6～7 位十进制数，那么会将多余小数部分舍入。

   val eFloat = 2.7182818284f // Float，实际值为 2.7182817
   

   Kotlin 中的数字没有隐式拓宽转换。 例如，具有 Double 参数的函数只能对 Double 值调用，而不能对 Float、 Int 或者其他数字值调用：

   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) // 错误：类型不匹配
   }
   

3. 显示数字转换

   较小的类型不能 隐式转换为较大的类型。 这意味着把 Byte 型值赋给一个 Int 变量必须显式转换

   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

4. 整数除法

   整数间的除法总是返回整数。会丢弃任何小数部分。

   fun main() {
       val x = 5 / 2
       //println(x == 2.5) // ERROR: Operator '==' cannot be applied to 'Int' and 'Double'
       println(x == 2)
   }
   

   如需返回浮点类型，请将其中的一个参数显式转换为浮点类型：

   fun main() {
   //sampleStart
       val x = 5 / 2.toDouble()
       println(x == 2.5)
   //sampleEnd
   }
   

布尔类型

​ 布尔值的内置运算有：

• ||——析取（逻辑或）
• &&——合取（逻辑与）
• !——否定（逻辑非）

字符类型

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

特殊字符可以以转义反斜杠 \ 开始。 支持这几个转义序列：

• \t——制表符
• \b——退格符
• \n——换行（LF）
• \r——回车（CR）
• \'——单引号
• \"——双引号
• \\——反斜杠
• \$——美元符

字符串类型

字符串用 String 类型表示

通常，字符串值是双引号（“ ”）中的字符序列：

val str = "abcd 123"

字符串的元素——字符可以使用索引运算符访问: s[i]。 可以使用 for 循环遍历这些字符：

fun main() {
    val str = "abcd"
    for (c in str) {
        println(c)
    }
}

字符串是不可变的。 一旦初始化了一个字符串，就不能改变它的值或者给它赋新值。 所有转换字符串的操作都以一个新的 String 对象来返回结果，而保持原始字符串不变：

fun main() {
    val str = "abcd"

    // 创建并输出一个新的 String 对象
    println(str.uppercase())
    // ABCD

    // 原始字符串保持不变
    println(str) 
    // abcd
}

如需连接字符串，可以用 + 操作符。这也适用于连接字符串与其他类型的值， 只要表达式中的第一个元素是字符串：

fun main() {
    val s = "abc" + 1
    println(s + "def")
    // abc1def    
}

多行字符串

多行字符串可以包含换行以及任意文本。 它使用三个引号（"""）分界符括起来，内部没有转义并且可以包含换行以及任何其他字符：

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(">")

数组类型

数组是一种保存固定数量相同类型或其子类型的值的数据结构。 Kotlin 中最常见的数组类型是对象类型数组，由 Array 类表示。

要在 Kotlin 中创建数组，您可以使用：

• 函数，例如 arrayOf（）、arrayOfNulls（） 或 emptyArray（）。
• 构造函数。Array

此示例使用 arrayOf（） 函数 并将项目值传递给它：

fun main() {
    // Creates an array with values [1, 2, 3]
    val simpleArray = arrayOf(1, 2, 3)
    println(simpleArray.joinToString())
    // 1, 2, 3
}

数组可以相互嵌套以创建多维数组：

fun main() {
    // Creates a two-dimensional array
    val twoDArray = Array(2) { Array<Int>(2) { 0 } }
    println(twoDArray.contentDeepToString())
    // [[0, 0], [0, 0]]

    // Creates a three-dimensional array
    val threeDArray = Array(3) { Array(3) { Array<Int>(3) { 0 } } }
    println(threeDArray.contentDeepToString())
    // [[[0, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]]
}

数组始终是可变的。要访问和修改数组中的元素，请使用索引访问运算符：[]

fun main() {
    val simpleArray = arrayOf(1, 2, 3)
    val twoDArray = Array(2) { Array<Int>(2) { 0 } }

    // Accesses the element and modifies it
    simpleArray[0] = 10
    twoDArray[0][0] = 2

    // Prints the modified element
    println(simpleArray[0].toString()) // 10
    println(twoDArray[0][0].toString()) // 2
}

向函数传入可变数量的实参

在 Kotlin 中，您可以通过 vararg 参数将可变数量的参数传递给函数。当您事先不知道参数的数量时，这很有用，例如在格式化消息或 创建 SQL 查询。

若要将包含可变数量参数的数组传递给函数，请使用 spread 运算符 ().spread 运算符将数组的每个元素作为单独的参数传递给所选函数：*

fun main() {
    val lettersArray = arrayOf("c", "d")
    printAllStrings("a", "b", *lettersArray)
    // abcd
}

fun printAllStrings(vararg strings: String) {
    for (string in strings) {
        print(string)
    }
}

比较数组

要比较两个数组是否具有相同顺序的相同元素，请使用 .contentEquals（） 和 .contentDeepEquals（） 函数

和

要返回数组中所有元素的总和，请使用 .sum（） 函数

洗牌

要随机洗牌数组中的元素，请使用 .shuffle（） 函数

将数组转换为集合

转换为 List 或 Set

要将数组转换为 List或者Set，请使用 .toList（） 和 .toSet（） 函数。

fun main() {
    val simpleArray = arrayOf("a", "b", "c", "c")

    // Converts to a Set
    println(simpleArray.toSet())
    // [a, b, c]

    // Converts to a List
    println(simpleArray.toList())
    // [a, b, c, c]
}

转换为 Map

要将数组转换为 ，请使用 .toMap（） 函数。

只有 Pair 数组可以转换为 . 实例的第一个值变为键，第二个值变为值。此示例使用中缀表示法调用 to 函数以创建以下元组：Map``Pair``Pair

fun main() {
    val pairArray = arrayOf("apple" to 120, "banana" to 150, "cherry" to 90, "apple" to 140)

    // Converts to a Map
    // The keys are fruits and the values are their number of calories
    // Note how keys must be unique, so the latest value of "apple"
    // overwrites the first
    println(pairArray.toMap())
    // {apple=140, banana=150, cherry=90}

}

类型检测与类型转换

is 与 !is 操作符

使用 操作符或其否定形式 在运行时检测对象是否符合给定类型：is``!is

if (obj is String) {
    print(obj.length)
}

if (obj !is String) { // 与 !(obj is String) 相同
    print("Not a String")
} else {
    print(obj.length)
}

智能转换

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

fun demo(x: Any) {
    if (x is String) {
        print(x.length) // x 自动转换为字符串
    }
}

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

if (x !is String) return

print(x.length) // x 自动转换为字符串

或者转换在 或 的右侧，而相应的（正常或否定）检测在左侧：&&``||

// `||` 右侧的 x 自动转换为 String
if (x !is String || x.length == 0) return

// `&&` 右侧的 x 自动转换为 String
if (x is String && x.length > 0) {
    print(x.length) // x 自动转换为 String
}

智能转换用于 when 表达式 和 while 循环 也一样：

when (x) {
    is Int -> print(x + 1)
    is String -> print(x.length + 1)
    is IntArray -> print(x.sum())
}

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

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

val x: String? = y as? String

请注意，尽管事实上 的右边是一个非空类型的 ，但是其转换的结果是可空的。

参考koltin中文文档，链接：https://book.kotlincn.net/