1-3、Kotlin基本类型

1、基本类型

• Java中存在基本类型，这些类型并不是对象，但是Kotlin中一切皆对象
• Kotlin编译器会智能地判断是否可以将代码中的基本类型映射到JVM的原始类型（原始类型可以提升程序的运行效率）

2、Boolean

• Boolean

    val a:Boolean = true
    val b:Boolean = false

    println(a) //true
    println(b)  //false
    println(a && b)  //false
    println(a || b)  //true

3、Number

3-1、Number种类

• 浮点型
  • Double：64位
  • Float：32位
• 整型
  • Long：64位
  • Int：32位
  • Short：16位
  • Byte：8位

    /**
     * Int类型 4
     */
    val a:Int = 12
    val b:Int = 0xff //255
    val c:Int = 0b00000011
    val e:Int = 123_456 //下划线纯粹是为了分割数字,方便易读

    val maxInt:Int = Int.MAX_VALUE //2.147483647E9
    val minInt:Int = Int.MIN_VALUE //-2.147483648E9
    println(Math.pow(2.0,31.0)-1) //2.147483647E9
    println(-Math.pow(2.0,31.0)) //-2.147483648E9

    /**
     * Long类型 8
     */
    val d:Long = 123L
    val maxLong:Long = Long.MAX_VALUE
    val minLong:Long = Long.MIN_VALUE

    /**
     * Float类型 4
     */
    val f1:Float = 2.0f
    val f2:Float = 4.3e3f //表示4.3*10^3
    val fMax:Float = Float.MAX_VALUE
    val fMin:Float = Float.MIN_VALUE

    /**
     * Double类型 8
     */
    val d1:Double = 3.0 //小数默认为Double

    /**
     * Byte 1
     */
    var b1:Byte = Byte.MAX_VALUE //127
    var b2:Byte = Byte.MIN_VALUE //-128

• NaN 不是数字

    var a = 0/0.0
    // NaN
    println(a)

• 整数默认为Int，小数默认为double

var a = 12
var b = 12.0

println(a.javaClass) // int
println(b.javaClass) // double

3-2、Number类型转换

• Number子类型都有转换成其他Number子类型的方法

public abstract class Number {

    public abstract fun toDouble(): Double

    public abstract fun toFloat(): Float

    public abstract fun toLong(): Long

    public abstract fun toInt(): Int

    public abstract fun toChar(): Char

    public abstract fun toShort(): Short

    public abstract fun toByte(): Byte
}

• Number类型的转换，长短字节Number之间不可隐式转换

    val a:Int = 123
    //编译错误 4字节的Int类型a不能赋值给8字节的Long类型b
//    val b:Long = a
    val b:Long = a.toLong()
    println(b)

    val c:Long = 123333
    //编译错误 8字节的Long类型c不能赋值给4字节的Int类型d
//    val d:Int = c
    val d:Int = c.toInt()
    println(d)

• 虽然Kotlin中缺乏隐式转换，但在表达式中可以自动转换

    val a: Byte = 1
    val b: Short = 2
    val c = 1.0
    val total = a + b
// javaClass属性来自Any类型，是Kotlin所有类型但根父类
    println(total.javaClass) // int
    val total2 = a.toLong() + b.toByte()
    println(total2.javaClass) // long
    val total3 = a + b + c
    println(total3.javaClass) // double

3-3、按位运算符

    var a = 1 shl 2 // 左移 4
    var b = 8 shr 2 // 右移 2
    var c = 8 ushr 2 // 无符号右移2
    var d = 1 and 2 // 按位与0
    var e = 1 or 2 // 按位或3
    var f = 1 xor 2 // 按位异或3
    var g = 1.inv() // 按位非 -2

4、Char

• Kotlin不支持Char类型和Int类型直接比较（Java支持）
• 16位

val a = 'a'

// Operator '==' cannot be applied to 'Char' and 'Int'
// println(a == 97)

println(a.toInt() == 97)

// Char两个字节
print(Char.SIZE_BYTES)

• Kotlin中Char型虽然不能当成整数进行算术运算
• 但是可以Char型值加、减一个整数值，也可以两个Char相减，但不能相加

val a = 'a'
val b = 'b'
println(a + 2) // c
println(b + 2) // d
println(b - a) // 1
// 报错 
// println(a + b)

5、String

• ==
• ===
• $a
• “”" “”"

val str:String = "HelloWorld"
val fromChars:String = String(charArrayOf('H','e','l','l','o','W','o','r','l','d'))
println(str == fromChars) //true    == 判断字符串是否一样
println(str === fromChars) //false  ===判断引用是否一样

println("输出"+str) //输出HelloWorld
val a:Int = 5
val b:Int = 6
println("$a + $b = ${a+b}")//字符串模板 5 + 6 = 11
println("\$$a") //$5
println("$$a") //$5

val rawString:String = """
    \t
    \n
    $a
"""
println(rawString) //原来格式输出
println(rawString.length) //字符串长度

6、Range

• 区间

    // 1 2 3 4 5 6 7 8 9
    var a = 1..9
    for(i in a){
        print("$i ")
    }
    println()

    // 1 3 5 7 9
    var b = 1..9 step 2
    for(i in b){
        print("$i ")
    }
    println()

    // 1 2 3 4 5 6 7 8
    var c = 1 until 9
    for(i in c){
        print("$i ")
    }
    println()

    // 9 8 7 6 5 4 3 2 1
    var d = 9 downTo 1
    for (i in d){
        print("$i ")
    }
    println()

    // 9 6 3
    var e = 9 downTo 1 step 3
    for (i in e){
        print("$i ")
    }

• 整型区间有IntRange、LongRange、CharRange

// 闭区间[0,1024]
var aa:IntRange = 0..1024

println(aa.contains(12)) // true
println(22 in aa) // true
println(aa.isEmpty()) // false

7、Array

7-1、Array声明

// ["a","b"]
var a:Array<String> = arrayOf("a","b")
// [0,2,4] 定义一个长度3，每个位置的值是索引的两倍
var b:Array<Int> = Array(3,{i->(i*2)})

// 基本类型的数据
var c:IntArray = intArrayOf(1,2,3)
var d:BooleanArray = booleanArrayOf(true,false,true)
var e:ShortArray = shortArrayOf(1,2,3)

// 数组中保存不同的类型
var f = arrayOf("a",12,true)

• 数组中可以是不同类型的元素
• 基本数据类型的数组是定制的，省去类似Java的装箱操作：IntArray、ShortArray、FloatArray、DoubleAray、CharArray

7-2、常用属性方法

var arr = arrayOf(1,"hello",true)

// 长度
println(arr.size)

// 取值
println(arr[0])
println(arr.get(0))

// 设值
arr.set(0,100)
println(arr[0])

// 遍历
for (a in arr){
    println(a)
}