Kotlin——数据类型（2）

在了解数据类型之前，我们先了解一下Kotlin中var和val的区别：
Kotlin中有两个关键字定义变量，这两个关键字外形看着差别很小就只差了一个字母，但实际差别很大的。
var是一个可变变量，这是一个可以通过重新分配来更改为另一个值的变量。这种声明变量的方式和java中声明变量的方式一样。
val是一个只读变量，这种声明变量的方式相当于java中的final变量。一个val创建的时候必须初始化，因为以后不能被改变。

1、Boolean类型

在Kotlin当中，Boolean类型大多数情况相当于java中基本类型boolean，只有在必要的时候才会装箱成java中装箱类型Boolean。那我们到底选择哪一个呢，其实都交给编译器去处理了，我们不需要去担心。

val tbool:Boolean = true
val fbool:Boolean = false

2、Number类型

主要包括整型和浮点型。

Number类型.png

//整形
val num1:Int = 8  //十进制 8
val num2:Int = 0XFF  //十六进制 255
val num3:Int = 0b00000011  //二进制 3
val maxInt:Int = Int.MAX_VALUE  //最大整型值
val minInt:Int = Int.MIN_VALUE  //最小整型值

//长整形
val along:Long = 123432424342324
println(18L)  //整型强转长整形
Long.MAX_VALUE  //最大长整型值
Long.MIN_VALUE  //最小长整型值

//短整形
val aShort:Short = 12345
Short.MAX_VALUE  //最大短整型值
Short.MIN_VALUE  //最小整型值

//字节
val aByte:Byte = 127
Byte.MAX_VALUE  //Byte最大值 127
Byte.MIN_VALUE  //Byte最小值 -128

//单精度
val aFloat:Float = 2.0F  //在Kotlin中2.0默认表示双精度，所以需要加f强转 2.0
val another:Float = 1E3f  //10的3次方 1000.0
Float.MAX_VALUE  //最大单精度
Float.MIN_VALUE  //最小单精度，但MIN_VALUE是最小的正数（负数的最大值），非0，加上-号。所以可用 -Float.MAX_VALUE去表示

//双精度
val aDouble:Double = 3.0
val anotherD:Double = 2.34354
Double.MAX_VALUE   //最大双精度
Double.MIN_VALUE  // //最小双精度，与Float.MIN_VALUE类似，也是一个正数

NaN，“not a number”一个不是数的数，
例如：

println(0.0F/0.0F) //输出结果 NaN
prinln(0.0F/0.0F ==Float.NaN)  //输出结果 false

说明NaN的结果和其他NaN的结果不是相等的，比较起来没有意义，也不要去尝试。

3、Char类型

字符对应java的Character
占两个字节，标示一个16位的Unicode字符
字符用单引号 ' 引起来，例如：'a', '6', '\n'

val aChar:Char = 'a'
val bChar:Char = '中'
val cChar:Char = '\u000f'  //Unicode字符

转义字符.png

4、基本类型的转换

不可隐士转换

val anInt:Int = 5
val aLong:Long = anInt.toLong()  //  这样才可以转换
val aShort:Short = 12345
val aD:Double = aShort.toDouble()//  这样才可以转换

5、字符串

val string:String = "hello"  //声明一个字符串
val fromChars:String = String(charArrayOf('h','e','l','l','l','o'))  //字符数组
println(string == fromChars)   //== 比较值
println(string === fromChars)   //=== 引用

输出结果：分别是true和false。
所以“a==”比较的是内容是否相同，即类似java的equals，“a===b”比较对象是否相同
字符串模板特性

val arg1: Int = 0
val arg2: Int = 1
println("" + arg1 + " + " + arg2 + " = " + (arg1 + arg2))
println("$arg1 + $arg2 = ${arg1 + arg2}")

输出结果.png

**原始字符串 """ **
原始字符串用三个"标示，内部字符串无法转义。

var rawStr:String = """\t\n\$666\t哈哈哈"""
println(rawStr.length)

"""原始字符，输出结果.png
字符串.length获取字符串长度

5、类与对象

与java中概念基本相同，只不过写法不同。
Any相当于java中的Object

class 妹子(性格: String, 长相: String, 声音: String): 人(性格, 长相, 声音)
class 帅哥(性格: String, 长相: String, 声音: String): 人(性格, 长相, 声音)

open class 人(var 性格: String, var 长相: String, var 声音: String){
    init {
        println("new 了一个${this.javaClass.simpleName}, ta性格:$性格, 长相:$长相, 声音:$声音")
    }
}

fun main(args: Array<String>) {
    val 我喜欢的妹子: 妹子 = 妹子("温柔", "甜美", "动人")
    val 我膜拜的帅哥: 帅哥 = 帅哥("彪悍", "帅气", "浑厚")
    println(我喜欢的妹子 is 人)  //判断是属于某个类
}

6、空类型和智能类型转换

7、包

8、区间

一个数学上的概念，表示范围
ClosedRange的子类，InteRange最常用
基本写法：

0..100表示 [0,100]
0 until 100表示 [0,100)
(0..100).contains(i) 和 i in 0..100 均判断i是否在区间[0,100]中

9、数组

1、基本写法：

val array:Array<T> = arrayOf(...)

2、基本操作

print array[i] 输出第i个成员
array[i] = "Hello" 给第i个成员赋值
array.length 数组的长度

为了避免不必要的装箱和拆箱，基本类型的数组是定制的

Java	Kotlin
int[]	IntArray
short[]	ShortArrary
long[]	LongArrary
float[]	FloatArrary
double[]	DoubleArrary
char[]	CharArrary

3、创建数组

（1）创建空数组，只读

val arrayEmpty = emptyArray<String>()

（2）创建指定长度的可空数组

val array1 = arrayOfNulls<Int>(5)
for (i in 0..4) {
    array1[i] = i
}

（3）创建指定长度数组

val array4 = Array(5, {0})

初始化长度为5，元素均为0的数组

val array5 : Array<String> = Array(5, {""})
for (i in 0..2) {
    array5[i] = i.toString()
}

初始化长度为5，元素均为""的数组，并为数组前3个元素赋值，"0", "1", "2", "", ""

（4）使用闭包创建数组

val array = Array(4, { i -> i * i })  //0,1,4,9,16

（5）使用Kotlin封装方法创建数组

val array1 = arrayOf(1, 2, 3, 4)
val array2 = intArrayOf(1, 2, 3, 4)

3、遍历数组

 var arr:IntArray = intArrayOf(1,2,3,4,5,6,7,8,9,10,11)
// 迭代器遍历数组1
val it = arr.iterator()
for (item in it.iterator()) {
    println(item)
}
// 迭代器遍历数组2
val it1 = arr.iterator()
it1.forEach {
    println(it)
}
// forEach遍历数组
arr.forEach {
    println(it)
}
for((index,value) in arr.withIndex()){
     print("$index -> $value,")
}

for(indexValue in arr.withIndex()){
     print("${indexValue.index} -> ${indexValue.value},")
}
// 等等...