二,Kotlin-内置类型

1,Boolean 类型

Boolean 类型的值只有true和false ,相当于java中的boolean和Boolean

var aBoolean: Boolean = true
var bBoolean: Boolean = false

2,Number类型

/**
 * Byte类型
 */

var abByte: Byte = 123
var bbByte: Byte = Byte.MAX_VALUE
var cbByte: Byte = Byte.MIN_VALUE


/**
 * Short类型
 */

var aShort: Short = 123
var bShort: Short = Short.MAX_VALUE
var cShort: Short = Short.MIN_VALUE


/**
 * Int类型数据写法
 */
var anInt: Int = 100
//16进制写法
var bInt: Int = 0xff
//二进制
var bbInt: Int = 0b00000001
var cInt: Int = Int.MAX_VALUE
var dInt: Int = Int.MIN_VALUE

/**
 * Long类型数据写法
 */
var aLong: Long = 100
var bLong: Long = 178784932941798
var cLong: Long = Long.MAX_VALUE
var dLong: Long = Long.MIN_VALUE
//未定义整数默认是Int类型,若要使用Long类型则需要在数字后加L或l
fun main() {
    print(100L)
}

/**
 * Float类型
 */
var aFloat: Float = 1.2F
//1乘10的3次方
var bFloat: Float = 1E3f
var cFloat: Float = Float.MAX_VALUE
//Float的最小负数
var ccFloat: Float = -Float.MAX_VALUE
//Float中最小的非0正数
var dFloat: Float = Float.MIN_VALUE
//Float的最大负数
var ddFloat: Float = Float.MIN_VALUE
//不是数字的数字例如  0/0  NaN跟任何不是数的数  都不相等  因为这样比较无意义
var eFloat: Float = Float.NaN


/**
 * Double类型
 */
var aDouble: Double = 1.0
var bDouble: Double = Double.MAX_VALUE
var cDouble: Double = Double.MIN_VALUE

Kotlin中的Int类型是Java中int和Integer的集合体,编译器会在需要时进行装箱和拆箱

---

基本数据类型的转换,不可隐式转换;较低位数不能直接赋值给较高位数的变量,必须通过显示转换才行

var ttInt: Int = 1
var ttLong: Long = ttInt.toLong();

3,Char类型

• Char类型对应Java中的Character类型
• 占两个字节,标示一个16位的 Unicode字符
• 字符用' '(单引号)引起来

var aChar: Char = 'a'
var bChar: Char = '中'
//Unicode编码形式
var cChar: Char = '\u000f'

转义字符

4,字符串类型

• 字符串是一串Char
• 用""引起来
• 字符串比较内容使用==
• 字符串比较对象是否相同使用===

/**
 * 字符串;类型
 */
var aString: String = "ABC"
var bString: String = String(charArrayOf('A', 'B', 'C'))
fun main(args: Array<String>) {
    //相当于java中eques
    println(aString == bString)
    //判断这两个是不是同一个对象
    println(aString === bString)
}
//原始字符串
var cString: String = """  
     \n
     \t
     \\""
   1
     2
     3
"""

这里需要注意的是-判断对象的引用使用"===";判断对象的值使用"=="(相当于Java中的equels)

5，区间(Range)

• 数学上的概念,表示范围
• CloseRange 的子类 最常用的是IntRange

//离散型区间
val rangeA: IntRange = 0..10//[0,100]闭区间
val rangeB: IntRange = 0 until 10//[0,99)半开区间
var rangeC: IntProgression = 10 downTo 0//倒序闭区间和..的值顺序相反
var rangeD = 1..10 step 2//步长,相当于隔多少值再取1,3,5
var rangeE = 'a'..'z' step 3

//连续性区间
var rangeF = 1.0f..2.0f
//var rangeG = 1.0f until 2.0f  不可半开区间
//var rangeK = 1.0f..2.0f step 0.2   不可加步长,没有意义

//无符号区间
var rangeH = 1U..10U

fun main(args: Array<String>) {
    //判断包含关系
    println(rangeA.contains(50))
    println(50 in rangeA)
    println(rangeB.contains(100))
    println(100 in rangeB)
    //遍历区间A
    for (i in rangeA) {
        print("$i,")
    }
    println(rangeA.joinToString())
    //遍历区间B
    rangeB.forEach {
        print("$it")
    }
    println()
    for (i in rangeC) {
        print("$i,")
    }
    println()
    for (i in rangeD) {
        print("$i,")
    }
    println()
    rangeD.forEach {
        print("$it")
    }

}

区间的应用

• 遍历数组时获取当前位置的索引

var arrint = intArrayOf(1, 2, 3, 4)

    //区间的应用,获取数组的索引
    //方式一
    for (i in 0 until arrint.size) {
        print(arrint[i])
    }
    //方式二
    for (i in arrint.indices) {
        print(arrint[i])
    }

6,数组

• 对应英文单词Array
• 跟数没有关系,数列只是数组的一个特性形式
• 是一系列对象

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

//获取数组的长度
    println(arrayOfAny.size)
    //遍历数组
    for (i in arrayOfInt) {
        println(i)
    }
    arrayOfString.forEach { ele ->
        print(ele)
    }
    //和上面等效
    arrayOfString.forEach {
        println(it)
    }
    //判断字符串是否在该数组中
    if ("中国" in arrayOfString) {
        println("中国在字符串中")
    }


    //数组取值并替换
    arrayOfChar[0] = 'X'
    println(arrayOfChar[0])
    //字符数组连接
    println(arrayOfChar.joinToString(""))
    //数组切片即取出数组中一个范围内的值
    println(arrayOfString.slice(0..1))
    println(arrayOfString.slice(0 until 2))

7,Kotlin的集合框架

• 增加了 "不可变"集合框架接口
• 没有另起炉灶,复用Java Api 的所有实现形式
• 提供了丰富易用的方法

//不可变list,里面元素不能增加和减少
var listA = listOf<String>("A", "b", "c")
//可变list同Java中的list相同可增删
var ListB: MutableList<String> = mutableListOf<String>("A")
//和java中的经典写法儿相同
val listC = ArrayList<String>()
//map创建方式
val mapA = mapOf<String, Any>("name" to "wjf", "age" to 25)
var mapB = mutableMapOf<String, Any>("name" to "wjf", "age" to 25)
var mapC = mutableMapOf<String, Any>(Pair("name", "wjf"), Pair("age", 25))

fun main(args: Array<String>) {
    //正常的add添加
    for (i in 1..10) {
        listC.add("$i")
    }
    //kotlin中可以使用+=的方式来添加元素,但是listC定义的时候应该用val不能
    //使用var要不会有编译的错误
    for (i in 1..10) {
        listC += "$i"
    }
    //普通遍历
    for (s in listC) {
        print(s)
    }
    //利用区间获取带索引的遍历
    for (s in listC.indices) {
        print(listC[s])
    }
    //forEach形式
    listC.forEach {
        print(it)
    }
    //普通的移除方法
    for (i in 1..10) {
        listC.remove("$i")
    }
    for (s in listC) {
        print(s)
    }
    //-=形式移除元素
    for (i in 1..10) {
        listC -= "$i"
    }
    for (s in listC) {
        print(s)
    }
    //获取map中的元素并赋值
    mapB["name"] = "WJF"
    //map遍历方式1
    for (entry in mapA) {
        val key = entry.key
        val value = entry.value
        println("key is ${key}; value is $value")
    }
    //map遍历方式2
    val asIterable = mapB.asIterable()
    for (entry in asIterable) {
        val key = entry.key
        val value = entry.value
        println("key is ${key}; value is $value")
    }
    //map遍历方式3
    val keys = mapB.keys
    for (key in keys) {
        val value = mapB[key]
        println("key is ${key}; value is $value")
    }
    //map遍历方式4
    for (entry in mapB.entries) {
        val key = entry.key
        val value = entry.value
        println("key is ${key}; value is $value")
    }
}

另外的一个kotlin的独有类

• Pair

• Triple

8,函数(function)

<1>基本定义

• 函数:以特定功能组织起来的代码块
• 函数可以有自己的类型,所以是"一等公民"
• 可以赋值,传递并在合适的条件下调用

函数的定义

fun [函数名] (参数列表):[返回值类型]{[函数体]}
fun [函数名](参数列表)=[表达式]
//匿名函数,需要使用变量或常量进行接收
var|val [变量名]=fun([参数列表]):返回值类型{[函数体]}

• 如果函数的返回值为Unit(Unit相当于Java中的void)时可以省略,编译器会智能的类型推导

fun main(args: Array<String>) {
    val arg1 = 1
    val arg2 = 2
    println(sum(arg1, arg2))
    println(sumSimple(arg1, arg2))
    println(sumDate)
    println(sumDate(arg1, arg2))
}
fun sum(arg1: Int, arg2: Int): Int {
    return arg1 + arg2
}
fun sumSimple(arg1: Int, arg2: Int) = arg1 + arg2
val sumDate = fun(arg1: Int, arg2: Int): Int {
    return arg1 + arg2
}

<2>方法和函数

• 方法可以认为是函数的一种特殊形式
• 简单的理解就是定义在类中的函数就是方法

class Food {
    //方法
    fun eat() {}
}
//函数
fun eat() {}

<3>函数的类型

个人见解:当定义完一个函数后,函数的类型也就确定了,函数的类型和基本类型如Int,String等都一样可以是参数,也可以赋值,理解的时候就把函数的类型理解为跟String一样就行,就是写法儿有点儿特殊

class Food {
    //方法
    fun eat() {}
}

//String  是参数类型
fun eat(arg: String) {}

//() -> Unit是参数类型:空参数并且返回值为Unit类型的函数类型
fun eat(arg: () -> Unit) {}

//Food.() -> Unit是参数类型:receiver为Food中参数并且返回值为Unit类型的函数类型
fun eat(arg: Food.() -> Unit) {}

//receiver可以当成函数的第一个参数
fun eats(arg: (Food) -> Unit) {}//跟上个等效所以函数名不能相同

<4>函数的引用

当定义完一个函数之后,就有了一个函数的具体实现,就相当于实例化了一个字符串对象,这个时候就可以拿这个函数给变量进行赋值

引用方式

• 对于一个在一个类中的函数使用 <类名>::<方法名>
• 对于普通的函数使用 ::<方法名>

fun eat(arg: String) {}
var a: (String) -> Unit = ::eat//eat函数的引用
//() -> Unit是参数类型:空参数并且返回值为Unit类型的函数类型
fun eatb(arg: () -> Unit) {}
var b: (() -> Unit) -> Unit = ::eatb//eatb函数的引用
//Food.() -> Unit是参数类型:receiver为Food中参数并且返回值为Unit类型的函数类型
fun eatc(arg: Food.() -> Unit) {}
var c: ((Food) -> Unit) -> Unit = ::eatc//eatc函数的引用

class Food {
    fun eat() {} //方法
}
//String  是参数类型
fun eat(arg: String) {}
fun eatU() {}
//() -> Unit是参数类型:空参数并且返回值为Unit类型的函数类型
fun eatb(arg: () -> Unit) {}
//Food.() -> Unit是参数类型:receiver为Food中参数并且返回值为Unit类型的函数类型
fun eatc(arg: Food.() -> Unit) {}
//receiver可以当成函数的第一个参数
fun eats(arg: (Food) -> Unit) {}//跟上个等效所以函数名不能相同

fun main(args: Array<String>) {
     //普通函数调用
    eat("ABC")
    //函数引用调用
    val test: () -> Unit = ::eatU
    eatb { test }
    val test2: (Food) -> Unit = Food::eat
    eatc { test2 }
    eats(test2)
    //实例化对象后函数调用
    val food:Food=Food()
    val test3=food::eat
    eatb(test3)
}

需要注意的是当实例化一个对象后,此实例化的对象对函数的引用,不再是(对象,函数参数)->返回值类型 的形式,而是(函数参数)->返回值类型

<5>变长参数

• 函数调用时候参数的个数才能确定的函数
• 使用vararg 修饰

fun multiParameters(vararg arg1: Int){
    print(arg1.joinToString("_"))
}

multiParameters(1,2,3,4,5)

<6>多返回值

• 其实Kotlin中是"伪"的多返回值的,是通过Pair和Triple进行组装实现的

fun multiReturn(): Triple<Long, String, Int> {
    return Triple(1L, "WJF", 25)
}

val tt: Triple<Long, String, Int> = multiReturn()
//解构
val (a, b, c) = multiReturn()

<7>函数的默认参数

• 当一个函数调用时,其中一个参数大多数场景下为一个值时,可以为其定一个默认值
• 需要注意的是一般默认参数要放在最后

fun defaultParameter(name:String,age:Int,sex:String="男"){}
defaultParameter("WJF",25)

<8>编写函数的注意事项

• 功能要单一
• 函数名要做到顾名思义
• 参数个数不要太多(在某些机器上会影响执行效率)

<9>四则运算计算器实例

通过在运行窗口输入内容获得简单的四则运行结果

fun main(vararg args: String) {
    //当输入的字符少3个时提示用户
    if (args.size < 3) {
        return help()
    }
    //利用函数的引用对应操作符
    val opres = mapOf<String, (Int, Int) -> Int>(
        "+" to ::plus,
        "-" to ::jian,
        "*" to ::time,
        "/" to ::div
    )
    //从map中获取当前操作符对应的函数
    val nowOp = opres[args[1]] ?: return help()
    //打印输入内容
    println("你输入了:${args.joinToString(" ")}")
    //结算结果
    println("结果:${args[0]}${args[1]}${args[2]}=${nowOp(args[0].toInt(), args[2].toInt())}")
}

fun plus(arg1: Int, arg2: Int): Int {
    return arg1 + arg2
}

fun jian(arg1: Int, arg2: Int): Int {
    return arg1 - arg2
}

fun time(arg1: Int, arg2: Int): Int {
    return arg1 * arg2
}

fun div(arg1: Int, arg2: Int): Int {
    return arg1 / arg2
}

fun help() {
    println(
        """
            这是一个四则运算的小程序
            请输入: 3*4
            得到结果:12
            """
    )
}

输入 3 * 5
得到结果

你输入了:3 * 5
结果:3*5=15