Kotlin基础语法 一、数据类型

学习Kotlin 中使用的基本类型：数字、字符、布尔值、数组与字符串。

1. 整形和浮点型

1.1 ）Kotlin 提供了一组表示数字的内置类型。 对于整数，有四种不同大小的类型，因此值的范围也不同。

注意：所有以未超出 Int 最大值的整型值初始化的变量都会推断为 Int 类型。如果初始值超过了其最大值，那么推断为 Long 类型。 如需显式指定 Long 型值，请在该值后追加 L 后缀。

示例：
val oneByte: Byte = 1
val one = 1 // 自动推断为Int
val threeBillion = 3000000000 //超过int型最大值，推断为Long
val oneLong = 1L // Long，使用L后缀显示指定为Long型

1.2 ）对于浮点数，Kotlin 提供了 Float 与 Double 类型，两种浮点类型的十进制位数（即可以存储多少位十进制数）不同。 Float 反映了 IEEE 754 单精度，而 Double 提供了双精度。

注意：对于以小数初始化的变量，编译器会推断为 Double 类型。 如需将一个值显式指定为 Float 类型，请添加 f 或 F 后缀。 如果这样的值包含多于 6～7 位十进制数，那么会将其舍入。

示例：
val pi = 3.14 //自动推断为 Double
val e = 2.7182818284 // Double
val eFloat = 2.7182818284f // Float，实际值为 2.7182817

1.3. ）两个数值的比较
判断两个数值是否相等使用 == ,判断两个数值在内存中的地址是否相等使用 ===

1.4 ）装箱问题

1. kotlin中一切都是对象。 在这个意义上讲我们可以在任何变量上调用成员函数与属性。 一些类型可以有特殊的内部表示——例如，数字、字符以及布尔值可以在运行时表示为原生类型值，但是对于用户来说，它们看起来就像普通的类。
2. Kotlin 的整型与 Java 的整形不同， Kotlin 的整型不是基本类型，而是引用类型（可以理解为Java的包装类）， Byte、Short、 Int、Long 都继承了 Number 类型，因此它们都可调用方法、访问属性。
3. Kotlin 是 null 安全的语言，因此 Byte 、Short、 Int 、Long 型变量都不能接受 null 值，如果要存储 null 值，则应该使用Byte？、 Short？、 Int？、 Long？类型 。
4. 整数类型添加“?”后缀与不加后缀还有一个很大的区别一一不带“?”后缀的的整型变量将会映射成 Java 的基本类型；带“?”后缀的整型变量将会映射成基本类型的包装类。例如： Int类型会映射为java中的基本类型int，而Int?会映射为java中的Integer
   我们用kotlin官方示例来看这个问题：

val a: Int = 100
val boxedA: Int? = a
val anotherBoxedA: Int? = a

val b: Int = 10000
val boxedB: Int? = b
val anotherBoxedB: Int? = b

println(boxedA === anotherBoxedA) // true
println(boxedB === anotherBoxedB) // false

val a: Int = 10000
val boxedA: Int? = a
val anotherBoxedA: Int? = a
println(boxedA == anotherBoxedA) // 输出“true”

按照前面的介绍， Int类型会映射为java中的基本类型int，而Int?会映射为java中的Integer，如果我们将上述kotlin代码编译成Java代码后，如下所示：

Short a =100
Integer boxedA = Integer.valueOf(a); 
Integer anotherBoxedA = Integer.valueOf(a);

Short b =100
Integer boxedB = Integer.valueOf(b); 
Integer anotherBoxedB = Integer.valueOf(b);

按照我们上面的介绍，boxedA === anotherBoxedA 是比较两个对象的内存地址是否相同，为什么还会返回true呢，而boxedB === anotherBoxedB 也是比较两个对象的内存地址，为啥返回了false呢？
其实是：关于 Integer 类型，在其源码中其实定义了一个数组，范围为 -128~127，如果我们传递的值在这个范围内，那么就会从这个数组中取值，而不会再在内存中开辟一个新地址存放我们的值，所以，才出现上面的情况。

1.5 ）数值字面常量
数值常量字面值有以下几种:
十进制: 123
Long 类型用大写 L 标记: 123L
十六进制: 0x0F
二进制: 0b00001011
注意: 不支持八进制
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

1.6） 显示类型转换
请注意，与一些其他语言不同，Kotlin 中的数字没有隐式数据类型转换。 例如，具有 Double 参数的函数只能对 Double 值调用，而不能对 Float、 Int 或者其他数字值调用。
因为装箱的原因：较小的类型不能隐式转换为较大的类型，这意味着在不进行显式转换的情况下我们不能把 Byte 型值赋给一个 Int 变量。

// 假想的代码，实际上并不能编译：
val a: Int? = 1 // 一个装箱的 Int (java.lang.Integer)
val b: Long? = a // 隐式转换产生一个装箱的 Long (java.lang.Long)
print(b == a) 

所以kotlin提供了显示的转换：
toByte() => 转换为字节型
toShort() => 转换为短整型
toInt() => 转换为整型
toLong() => 转换为长整型
toFloat() => 转换为浮点型
toDouble() => 转换为双精度浮点型
toChar() => 转换为字符型
toString() => 转换为字符串型

1.7 ）整数除法
类似于Java
Kotlin支持数字运算的标准集（+ - * / %），运算被定义为相应的类成员（但编译器会将函数调用优化为相应的指令）。
请注意，整数间的除法总是返回整数。会丢弃任何小数部分。例如

val x = 5 / 2
//println(x == 2.5) // ERROR: Operator '==' cannot be applied to 'Int' and 'Double'
println(x == 2)
对于任何两个整数类型之间的除法来说都是如此。
val x = 5L / 2
println(x == 2L)

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

val x = 5 / 2.toDouble()
println(x == 2.5)

2、布尔类型（Boolean）

Boolean关键字表示布尔类型，并且其值有true和false.
逻辑操作符（与Java相同）
’ || ’ => 逻辑或（或者）
’ && ’ => 逻辑与（并且）
’ ! ’ => 逻辑非（取反）

3. 字符型（Char）

Char为表示字符型，字符变量用单引号（‘ ’）表示。
并且不能直接视为数字，不过可以显式转换为数字。

1. 字符型可以显示转换为其他类型
   字符型的变量不仅可以转换为数字，同时也可转换为其他类型
   var var1 = char1.toByte()
   var var2 = char1.toInt()
   var var3 = char1.toString()
   var var4 = char1.toFloat()
   var var5 = char1.toShort()
2. 当变量为英文字母时还支持大小写转换。

var charA: Char = 'a'
var charB: Char = 'B'
var charNum: Char = '1'
var result: Char
// 转换为大写 result = charA.toUpperCase() 
// 转换为小写 result = charB.toLowerCase()
//当字符变量不为英文字母时，转换无效 result = charNum.toLowerCase() 

3. 字符转义
   同Java一样，使用某些特殊的字符时，要使用转义。下列是支持的转义序列：
   t => 表示制表符
   n => 表示换行符
   b => 表示退格键（键盘上的Back建）
   r => 表示键盘上的Enter键
   => 表示反斜杠
   ’ => 表示单引号
   " => 表示双引号
   $ => 表示美元符号，如果不转义在kotlin中就表示变量的引用了
   其他的任何字符请使用Unicode转义序列语法。例：’uFF00’

4、字符串类型（String）

String表示字符串类型。其是不可变的。所以字符串的元素可以通过索引操作的字符：str[index]来访问。可以使用for循环迭代字符串：
其中str[index]中的str为要目标字符串，index为索引

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

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

val s = "abc" + 1
println(s + "def")

请注意，在大多数情况下，优先使用字符串模板或原始字符串而不是字符串连接。

字符串字面值
Kotlin 有两种类型的字符串字面值: 转义字符串可以有转义字符， 以及原始字符串可以包含换行以及任意文本

转义字符串示例：val s = "Hello, world!n"

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

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

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

val i = 10
println("i = $i") // 输出“i = 10”

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

val s = "abc"
println("$s.length is ${s.length}") // 输出“abc.length is 3”

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

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

5.数组型（Array）

Kotlin中数组由Array表示，如下：

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>
    // ……
}

创建数组的4个方法：

1. ）arrayOf()
   创建一个数组，参数是一个可变参数的泛型对象
   即 arrayOf(1, 2, 3) 创建了 array [1, 2, 3]
2. ）arrayOfNulls()
   用于创建一个指定数据类型且可以为空元素的给定元素个数的数组
3. ）工厂函数（Array()）
   使用一个工厂函数Array()，它使用数组大小和返回给定其索引的每个数组元素的初始值的函数。
   Array() => 第一个参数表示数组元素的个数，第二个参数则为使用其元素下标组成的表达式
   示例：
   // 创建一个 Array 初始化为 [“0”, “1”, “4”, “9”, “16”]
   val asc = Array(5) { i -> (i * i).toString() }
   asc.forEach { println(it) }
4. ）原始类型数组
   Kotlin还有专门的类来表示原始类型的数组，它们分别是：
   ByteArray => 表示字节型数组
   ShortArray => 表示短整型数组
   IntArray => 表示整型数组
   LongArray => 表示长整型数组
   BooleanArray => 表示布尔型数组
   CharArray => 表示字符型数组
   FloatArray => 表示浮点型数组
   DoubleArray => 表示双精度浮点型数组
   PS: Kotlin中不支持字符串类型这种原始类型数组，可以看源码Arrays.kt这个类中并没有字符串数组的声明。而源码中StringArray.kt这个类并不是声明字符串型数组的。

最后

以上就是漂亮小霸王为你收集整理的Kotlin基础语法 一、数据类型的全部内容，希望文章能够帮你解决Kotlin基础语法 一、数据类型所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。