Kotlin数据类型概述

Kotlin 基本数据类型

Kotlin 是一种现代的编程语言，它支持多种数据类型。理解这些数据类型是编写高效、可靠 Kotlin 代码的基础。首先我们来看看 Kotlin 的基本数据类型。

数值类型

1. 整数类型
   • Byte：Byte 类型表示 8 位有符号整数，取值范围是 -128 到 127。在内存中占用 1 个字节。例如，在一些对内存要求苛刻且数值范围较小的场景，如网络协议中的一些标志位，可以使用 Byte 类型。

   val byteValue: Byte = 100
   println(byteValue)
   

   • Short：Short 类型表示 16 位有符号整数，取值范围是 -32768 到 32767。它在内存中占用 2 个字节。当我们需要处理一些相对较小的整数值，且不想占用过多内存时，Short 类型可能是一个不错的选择，比如一些简单的图形处理中表示较小的坐标值。

   val shortValue: Short = 10000
   println(shortValue)
   

   • Int：Int 类型是 Kotlin 中最常用的整数类型，表示 32 位有符号整数，取值范围是 -2147483648 到 2147483647。在内存中占用 4 个字节。在大多数情况下，当我们处理整数，没有特殊的内存或数值范围要求时，Int 是默认的选择。例如，统计文件中的行数，计算数组的长度等。

   val intValue: Int = 1000000
   println(intValue)
   

   • Long：Long 类型表示 64 位有符号整数，取值范围非常大。当我们需要处理超出 Int 类型范围的整数值时，就需要使用 Long 类型，比如处理时间戳（以毫秒为单位），一些大型计算中的数值等。在 Kotlin 中，声明 Long 类型的常量时，需要在数字后面加上 L 后缀。

   val longValue: Long = 1000000000000L
   println(longValue)
   

2. 浮点类型
   • Float：Float 类型表示 32 位单精度浮点数。它在内存中占用 4 个字节。Float 类型适用于对精度要求不是特别高，且希望节省内存空间的场景，比如一些简单的游戏开发中表示物体的位置等。在 Kotlin 中，声明 Float 类型的常量时，需要在数字后面加上 f 或 F 后缀。

   val floatValue: Float = 3.14159f
   println(floatValue)
   

   • Double：Double 类型表示 64 位双精度浮点数，是 Kotlin 中默认的浮点类型。它在内存中占用 8 个字节，精度比 Float 更高。在大多数需要处理小数的场景中，Double 是常用的选择，比如科学计算、金融计算等。

   val doubleValue: Double = 3.141592653589793
   println(doubleValue)
   

字符类型

字符类型 Char 用于表示单个字符。在 Kotlin 中，字符用单引号括起来。Char 类型在内存中占用 2 个字节，它实际上是一个 16 位无符号整数，对应于 Unicode 码点。

val charValue: Char = 'A'
println(charValue)

我们可以对字符进行一些操作，比如获取其 Unicode 码点：

val charValue: Char = 'A'
val codePoint = charValue.code
println(codePoint) // 输出 65

布尔类型

布尔类型 Boolean 只有两个值：true 和 false。它用于表示逻辑判断的结果，比如在条件语句（if - else、when 等）和循环控制（while、do - while 中的条件判断）中经常使用。

val isTrue: Boolean = true
val isFalse: Boolean = false
println(isTrue)
println(isFalse)

Kotlin 复合数据类型

数组类型

数组在 Kotlin 中是一种重要的复合数据类型，用于存储固定大小的同类型元素。

1. 创建数组
   • 使用 arrayOf() 函数可以创建一个数组。例如，创建一个包含整数的数组：

   val intArray = arrayOf(1, 2, 3, 4, 5)
   for (element in intArray) {
       println(element)
   }
   

   • 如果需要创建一个指定大小且初始值相同的数组，可以使用 Array 构造函数。例如，创建一个大小为 5，初始值都为 0 的整数数组：

   val zeroArray = Array(5) { 0 }
   for (element in zeroArray) {
       println(element)
   }
   

2. 访问数组元素 可以通过索引来访问数组中的元素，索引从 0 开始。例如：

   val intArray = arrayOf(1, 2, 3, 4, 5)
   println(intArray[2]) // 输出 3
   

3. 数组的类型特定变体
   • ByteArray：用于存储字节类型的数组，在处理文件 I/O、网络数据传输等场景中经常使用，因为这些场景中数据往往以字节流的形式存在。

   val byteArray = ByteArray(5) { it.toByte() }
   for (element in byteArray) {
       println(element)
   }
   

   • ShortArray、IntArray、LongArray、FloatArray、DoubleArray：分别用于存储对应类型的数组。这些类型特定的数组在性能上比通用的 Array 更优，因为它们避免了装箱和拆箱的开销。例如，IntArray 在处理大量整数数据时会比 Array<Int> 更高效。

   val intArray = IntArray(5) { it * 2 }
   for (element in intArray) {
       println(element)
   }
   

字符串类型

字符串在 Kotlin 中是 String 类型，用于表示文本数据。

1. 创建字符串
   • 可以直接使用双引号创建字符串：

   val simpleString = "Hello, Kotlin!"
   println(simpleString)
   

   • Kotlin 支持字符串模板，这使得在字符串中嵌入表达式非常方便。例如：

   val name = "Alice"
   val greeting = "Hello, $name!"
   println(greeting)
   

   如果表达式比较复杂，需要用花括号括起来：

   val num1 = 10
   val num2 = 20
   val resultString = "The sum of $num1 and $num2 is ${num1 + num2}"
   println(resultString)
   

2. 字符串操作
   • 获取长度：可以使用 length 属性获取字符串的长度。

   val stringValue = "Kotlin"
   val length = stringValue.length
   println(length) // 输出 6
   

   • 字符访问：可以通过索引访问字符串中的单个字符，就像访问数组元素一样。

   val stringValue = "Kotlin"
   val firstChar = stringValue[0]
   println(firstChar) // 输出 K
   

   • 字符串拼接：除了使用 + 运算符进行字符串拼接外，还可以使用 plus() 方法。

   val part1 = "Hello"
   val part2 = "World"
   val combined1 = part1 + " " + part2
   val combined2 = part1.plus(" ").plus(part2)
   println(combined1)
   println(combined2)
   

   • 字符串比较：Kotlin 中比较字符串是否相等使用 == 运算符，它比较的是字符串的内容。如果要比较字符串的引用，可以使用 === 运算符。

   val str1 = "Kotlin"
   val str2 = "Kotlin"
   val str3 = String(charArrayOf('K', 'o', 't', 'l', 'i', 'n'))
   println(str1 == str2) // true
   println(str1 === str2) // true
   println(str1 == str3) // true
   println(str1 === str3) // false
   

集合类型

Kotlin 提供了丰富的集合类型，主要分为可变集合和不可变集合。

1. 列表（List）
   • 不可变列表：使用 listOf() 函数创建一个不可变列表。不可变列表一旦创建，其内容不能被修改。例如：

   val immutableList = listOf(1, 2, 3)
   // immutableList.add(4) // 这行代码会报错，因为不可变列表不能修改
   

   • 可变列表：使用 mutableListOf() 函数创建一个可变列表。可变列表可以添加、删除和修改元素。

   val mutableList = mutableListOf(1, 2, 3)
   mutableList.add(4)
   println(mutableList) // 输出 [1, 2, 3, 4]
   

   • 访问列表元素：和数组类似，可以通过索引访问列表中的元素。

   val list = listOf(1, 2, 3)
   println(list[1]) // 输出 2
   

2. 集合（Set）
   • 不可变集合：使用 setOf() 函数创建一个不可变集合。集合中的元素是唯一的，不允许重复。

   val immutableSet = setOf(1, 2, 2, 3)
   println(immutableSet) // 输出 [1, 2, 3]
   

   • 可变集合：使用 mutableSetOf() 函数创建一个可变集合。可变集合可以添加和删除元素。

   val mutableSet = mutableSetOf(1, 2, 3)
   mutableSet.add(4)
   println(mutableSet) // 输出 [1, 2, 3, 4]
   

3. 映射（Map）
   • 不可变映射：使用 mapOf() 函数创建一个不可变映射。映射是一种键值对的集合，每个键在映射中是唯一的。

   val immutableMap = mapOf("one" to 1, "two" to 2)
   // immutableMap.put("three", 3) // 这行代码会报错，因为不可变映射不能修改
   

   • 可变映射：使用 mutableMapOf() 函数创建一个可变映射。可变映射可以添加、删除和修改键值对。

   val mutableMap = mutableMapOf("one" to 1, "two" to 2)
   mutableMap.put("three", 3)
   println(mutableMap) // 输出 {one=1, two=2, three=3}
   

   • 访问映射中的值：可以通过键来获取映射中的值。

   val map = mapOf("one" to 1, "two" to 2)
   val value = map["one"]
   println(value) // 输出 1
   

Kotlin 可空数据类型

在 Kotlin 中，可空类型是一个重要的概念，它有助于避免空指针异常（NullPointerException）。

1. 声明可空类型
   • 在类型后面加上 ? 表示该类型是可空的。例如，声明一个可空的字符串类型：

   var nullableString: String? = "Hello"
   nullableString = null
   

2. 安全调用操作符（?.） 当我们调用可空类型对象的方法或访问其属性时，可以使用安全调用操作符 ?.。如果对象为 null，则不会执行后续的方法调用或属性访问，而是返回 null。

   var nullableString: String? = null
   val length = nullableString?.length
   println(length) // 输出 null
   

3. 非空断言操作符（!!） 非空断言操作符 !! 用于将可空类型转换为非空类型。如果对象实际上为 null，会抛出 NullPointerException。所以使用时要非常小心。

   var nullableString: String? = null
   // val length = nullableString!!.length // 这行代码会抛出 NullPointerException
   

4. Elvis 操作符（?:） Elvis 操作符 ?: 用于在对象可能为 null 时提供一个默认值。例如：

   var nullableString: String? = null
   val result = nullableString?: "default value"
   println(result) // 输出 default value
   

Kotlin 自定义数据类型

除了基本数据类型和标准库提供的复合数据类型外，Kotlin 允许开发者自定义数据类型。

类

类是 Kotlin 中定义自定义数据类型的基本方式。一个类可以包含属性和方法。

1. 定义类

   class Person {
       var name: String = ""
       var age: Int = 0
   
       fun introduce() {
           println("Hi, my name is $name and I'm $age years old.")
       }
   }
   

2. 创建类的实例

   val person = Person()
   person.name = "Bob"
   person.age = 30
   person.introduce()
   

3. 构造函数
   • 主构造函数：类可以有一个主构造函数，用于初始化对象的属性。主构造函数在类头中声明。

   class Person(val name: String, val age: Int) {
       fun introduce() {
           println("Hi, my name is $name and I'm $age years old.")
       }
   }
   val person = Person("Alice", 25)
   person.introduce()
   

   • 次构造函数：类还可以有多个次构造函数，用于提供不同的初始化方式。次构造函数需要调用主构造函数（直接或间接）。

   class Person(val name: String, val age: Int) {
       constructor(name: String) : this(name, 0)
       fun introduce() {
           println("Hi, my name is $name and I'm $age years old.")
       }
   }
   val person1 = Person("Charlie")
   person1.introduce()
   

数据类

数据类是 Kotlin 中一种特殊的类，主要用于存储数据。Kotlin 会自动为数据类生成一些有用的方法，如 equals()、hashCode()、toString() 等。

1. 定义数据类

   data class Point(val x: Int, val y: Int)
   

2. 使用数据类

   val point1 = Point(10, 20)
   val point2 = Point(10, 20)
   println(point1 == point2) // 输出 true，因为数据类自动生成了 equals 方法
   println(point1) // 输出 Point(x = 10, y = 20)，因为数据类自动生成了 toString 方法
   

枚举类

枚举类用于定义一组命名常量。

1. 定义枚举类

   enum class Color {
       RED, GREEN, BLUE
   }
   

2. 使用枚举类

   val color: Color = Color.GREEN
   when (color) {
       Color.RED -> println("It's red.")
       Color.GREEN -> println("It's green.")
       Color.BLUE -> println("It's blue.")
   }
   

通过对 Kotlin 各种数据类型的深入了解，开发者能够更好地根据具体的需求选择合适的数据类型，从而编写出更高效、更健壮的代码。在实际的项目开发中，合理运用不同的数据类型是优化程序性能和提高代码可读性的关键之一。例如，在内存受限的移动设备应用开发中，选择合适的数值类型（如 Byte 或 Short）可以有效减少内存占用；在处理复杂业务逻辑时，使用自定义数据类型（如类和数据类）可以更好地组织和管理数据。同时，理解可空类型和集合类型的特性，能帮助我们避免空指针异常和高效地处理数据集合。