学习任何一门语言都离不开数据类型，数据类型是一门开发语言最基础的语法,最基本的组成部分，kotlin的数据类型和java基本相同
数值类型
| 类 型 | 类 型 | 宽 度 |
|---|---|---|
| Double | 双精度浮点型 | 64 |
| Float | 浮点型 | 32 |
| Long | 长整型 | 64 |
| Int | 整形 | 32 |
| Short | 短整型 | 16 |
| Byte | 字节 | 8 |
var a: Double = 2.0
//F/f表示单精度浮点型
var b: Float = 2F
//L表示长整型
var c: Long = 1L
var d: Int = 1
var e: Short = 1
var f: Byte = 5
数字类型 常量下划线
- 将数字进行分组，增加数字常量易读性
val a = 1_000_000
val b = 111_222_333_444_555L
val c = 11111_11111_11L
println("a => $a") //输出 a => 1000000
println("b => $b") //输出 b => 111222333444555
println("c => $c") //输出 c => 111111111111
装箱和拆箱
-
装箱: 自动将基本数据类型转换为包装器类型
-
拆箱：自动将包装器类型转换为基本数据类型
-
kotlin的原则是万物皆对象，所以并没有和java中一样的 int 和 Integer 这种数据类型和引用类型的分别，因此kotlin中只存在数字的装箱，并没有拆箱
val value: Int = 110
//装箱后数值无变化（Int? 只限数值类型）
val box: Int? = value
print("box=====$box") //输出结果为 110
数值比较
== 判断数值是否相等，=== 判断内存地址（数据类型数值范围）是否相等
class test5() {
val value: Int = 60
val box: Int? = value
init {
var result: Boolean
result = value == box
println("result==$result") //输出结果为true
result = value === box
/*
定义的变量是Int类型，大于127的内存地址不同，反之相同。这是`kotlin`的缓存策略导致的，
而缓存的范围是“ -128 ~ 127 ”，输出结果为true，如果定义的变量是小于-128或者大于127的值，
输出结果为false
*/
print("result===$result")
}
}
显式转换
| 类 型 | 类 型 | 举例：var a: Int = 100 | 输出结果 |
|---|---|---|---|
| 字节型 | toByte() | a.toByte() | 100 |
| 短整型 | toShort() | a.toShort() | 100 |
| 整型 | toInt() | a.toInt() | 100 |
| 长整型 | toLong() | a.toLong() | 100 |
| 浮点型 | toFloat() | a.toFloat() | 100.0 |
| 双精度浮点型 | toDouble() | a.toDouble() | 100.0 |
| 字符型 | toChar() | a.toChar() | d |
| 字符串型 | toString() | a.toString() | 100 |
隐式转换：算数运算被重载为适当的类型转换
//Long + Int = Long
val b = 10L + 20
println(b) //输出b 为30
位运算符
- and 如果对应位都是1，则结果为1，否则为0
- or 如果对应位都是0，则结果为0，否则为1
- xor 如果对应位值相同，则结果为0，否则为1
- inv 按位翻转操作数的每一位，即0变成1，1变成0
- shl 按位左移指定的位数，相当于乘以2的N次方。移掉的省略，右边缺失的位，用0补齐
- shr 按位右移指定的位数，相当于除以2的N次方，移掉的省略，左边缺失的位，如果是正数则补0，若为负数，可能补0或补1，这取决于所用的计算机系统
- ushr 按位右移指定的位数，移掉的省略，左边缺失的位，用0补齐
详情参靠：https://zhuanlan.zhihu.com/p/26546977
布尔类型
-
Boolean 表示布尔类型，和Java相同有true和false两个值
-
逻辑操作符
- ' || ' => 逻辑或（或者）
- ' && ' => 逻辑与（并且）
- ' ! ' => 逻辑非（取反）
class test8() {
var value: Boolean = false
var a: Boolean = false
var b: Boolean = true
var result = Boolean
init {
println("value==$value") //输出结果为 value==false
//输出结果为 a && b
if (a || !b) {
println("a==b")
}
if (!a && b) {
print("a && b")
}
}
}
字符型
- Char：字符型，单引号（‘ ’）表示字符变量，需要显式转换为数字不饿能直接作为数字
class test9() {
var a: Char = 'a'
init {
println(a)
var var1 = a.toByte()
var var2 = a.toInt()
var var3 = a.toString()
var var4 = a.toFloat()
var var5 = a.toShort()
println("var1 = $var1 ,var2 = $var2 , var3 = $var3 , var4 = $var4 , var5 = $var5")
//输出结果为 var1 = 97 ,var2 = 97 , var3 = a , var4 = 97.0 , var5 = 97
}
}
大小写转换
- 大写转换：toUpperCase()
- 小写转换：toLowerCase()
class test9() {
var a: Char = 'a'
init {
/*
当字符变量为英文字母时，大小写的转换，部位英文是转换失败
*/
// 转换为大写
a = a.toUpperCase()
println("$a----------") //输出结果为 A----------
// 转换为小写
a = a.toLowerCase()
println("$a++++++++++") //输出结果为 a++++++++++
}
}
转义符
| 类 型 | 转义符 |
|---|---|
| 制表符 | |
| 换行符 | |
| 退格键（Back建） | |
| Enter键 | |
| 反斜杠 | |
| 单引号 | ' |
| 双引号 | " |
| 美元符 | $ |
字符串类型
-
在Kotlin中， 字符串字面量有两种类型：
- 包含转义字符的字符串 转义包括（ 、 等）,不包含转义字符串的也同属此类型
- 包含任意字符的字符串 由三重引号（""" .... """）表示
class test11() {
val str: String = "kotlin"
init {
println("str => $str")
for (s in str) {
print(s)
print(" ")
}
val d = """ class test18(){
println("三重引号引用字符串，可以包含任意字符")
} """
println(d)
/*输出结果为
class test18(){
println("三重引号引用字符串，可以包含任意字符")
}
*/
}
}
字符串模板
class test11() {
val str: String = "kotlin"
init {
println("str => $str")
//迭代
for (s in str) {
print(s)
print(" ")
}
val a: String = "哈哈哈"
var b: String = "$a kotlin"
var c: String = "$b ${a.substring(1, 3)} ！！！！"
println(a) //输出结果 哈哈哈
println(b) //输出结果 哈哈哈 kotlin
println(c) //输出结果 哈哈哈 kotlin 哈哈 ！！！！
}
}
数组
-
Array: Array
表示数组 -
创建数组函数
- arrayOf()
- arrayOfNulls()
- Array() 工厂函数
1.arrayOf():创建数组的参数为一个可变的泛型对象
var arr = arrayOf(1,10,100,1000,10000)
for (v in arr){
print(v)
print(" ") //输出结果为 1 10 100 1000 10000
}
2.arrayOfNulls():创建指定类型指定元素数量 并且元素可以为空的数组
class test12() {
var arr = arrayOfNulls<Int>(3)
init {
arr[0] = 1
arr[1] = 2
arr[2] = 3
for (a in arr) {
print(a)
print(" ") //输出结果为 1 2 3
}
}
}
3.Array()工厂函数：使用数组大小和返回给定其索引的每个数组元素的初始值的函数， 第一个参数表示数组元素的个数，第二个参数为使用其元素下标组成的表达式
class test12() {
//工厂函数
var arr1 = Array(5) { index -> (index * 2).toString() }
init {
for (a in arr1){
print(a)
print(" ") //输出结果为 0 2 4 6 8
}
}
}
原始类型数组：Kotlin中不支持字符串类型的原始类型数组
| 类 型 | 转义符 |
|---|---|
| 字节型 | ByteArray |
| 短整型 | ShortArray |
| 整型 | IntArray |
| 长整型 | LongArray |
| 布尔型 | BooleanArray |
| 字符型 | CharArray |
| 浮点型 | FloatArray |
| 双精度浮点型 | DoubleArray |
class test10(){
var intArr: IntArray = intArrayOf(1,2,3,4,5)
var charArr: CharArray = charArrayOf('a','1','b','c','3','d')
var longArr: LongArray = longArrayOf(12L,1254L,123L,111L)
var shortArr: ShortArray = shortArrayOf(10,11,12,13)
var boolArr: BooleanArray = booleanArrayOf(false,true,true,false)
init {
for (number in intArr){
print(number)
print(" ") //输出结果为 1 2 3 4 5
}
println()
for (char in charArr){
print(char)
print(" ") //输出结果为 a 1 b c 3 d
}
println()
for (long in longArr){
print(long)
print(" ") //输出结果为 12 1254 123 111
}
println()
for (short in shortArr){
print(short)
print(" ") //输出结果为 10 11 12 13
}
println()
for (bool in boolArr){
print(bool)
print(" ") //输出结果为 false true true false
}
}
}