Kotlin学习之路--基础篇

Kotlin程序执行入口

跟Java代码一样，Kotlin的函数入口也是一个main函数

fun mian(args:Array<String>){
    println("Hello World")
}

args：变量名称
Array： 变量类型

Kotlin常见的数据类型

Kotlin有7种常用的数据类型：

数据类型	存储范围	备注
Byte	-128 ~ 127	8bit
Short	-32768 ~ 32767	16bit
Int	-2147483648 ~ 2147483747	32bit
Long	-9223372036854775807 ~ 9223372036854775807	64bit
Float	小数，可以精确到6位小数点
Double	小数，可以精确到16位小数点
String	字符串	“”里面的值

Kotlin类型倒推

Kotlin和JS一样通过var定义变量，数据类型会根据变量的值倒推得到

var i = 66  //int类型
var lng = 666666666666 //Long类型
var s = "hello world"  //String 类型

Kotlin显示类型声明

Kotlin也可以显性的定义变量类型

var i:Int = 66  //int类型
var lng:Long = 666666666666 //Long类型
var s:String = "hello world"  //String 类型

Kotlin常量声明

val:定义常量类型

val i:Int = 666

等价于Java代码

final int i = 666

Int类型也可以通过二进制方式赋值

var i = 0b0101  //通过0b开头进行二进制赋值 i = 5

函数

Kotlin中函数的定义形式：

  fun 函数名(参数名:参数类型,...):返回值类型{
      ...
  }

我们在文章初的HelloWorld函数中稍微改一下：

fun main(args:Array<String>):Unit{
    println("Hello World")
}

其实这个函数跟文章初的HelloWorld函数是一样的，这里只是多了一个Unit返回值；

Unit：代表没有返回值，当无返回值时可以忽略

占位符

Kotlin的占位符使用”${}”

var count = 10 ;
var name = "nace" 

fun main(args:Array<String>):Unit{
    println("Hello ${name} count is ${name}")
}

打印结果：
Hello nace count is 10

字符串

• 首先我们来复习一下java中的两种比较符：

1、”==”:判断字符串的内存地址是否相同；
2、equals：判断内容值是否相同；

Kotlin中：“==”和equals都是判断内容中值是否相同；

• 字符串转int

var str = "54"
var i = 54
i = str.toString() //把字符串转Int
str = i.toInt() //把int转字符串

when函数

when是Kotlin的一个函数，相当于java总的switch

when(view.id){
     R.id.home -> toast("click home")
     R.id.btn -> toast("click btn")
}

list集合

• Kotlin中list集合分两类：
  
  1. 可变集合类（Mutable）

使用listOf函数来构建一个不可变的List:

val mList: List<Int> = listOf(1, 2, 3, 4, 5)
println(mList)

1. 不可变集合类（Immutable）

使用mutableListOf函数来构建一个可变的List

val mList = mutableListOf(1, 2, 3, 4, 5)
mList.add(3, 0) // 在下标为3的地方添加一个0元素

• 把不可变函数转换成可变函数：

val mList: List<Int> = listOf(1, 3, 5, 7, 9)
val mMutableList = mList.toMutableList()
mMutableList.add(11)

• 变量List集合
  
  1. 使用forEach遍历List元素

val mList: List<Int> = listOf(0, 1, 2, 3, 4, 5)
mList.forEach {
    ...
}

1. 使用函数withIndex()遍历List元素

val mList: List<Int> = listOf(0, 1, 2, 3, 4, 5)
for ((index, value) in mList.withIndex()) {
    ...
}

1. 使用Iterator迭代器遍历List元素

val mList: List<Int> = listOf(0, 1, 2, 3, 4, 5)
val mIndex = mList.iterator()
while (mIndex.hasNext()) {
    ...
}

1. 使用for循环遍历List元素

val mList: List<Int> = listOf(0, 1, 2, 3, 4, 5)
for (i in mList.indices){
    println(mList[i])
}

递归

递归的基本原理：

１　每一次函数调用都会有一次返回．当程序流执行到某一级递归的结尾处时，它会转移到前一级递归继续执行．

２　递归函数中，位于递归调用前的语句和各级被调函数具有相同的顺序．如打印语句 #1位于递归调用语句前，它按照递归调用的顺序被执行了 4 次．

３　每一级的函数调用都有自己的私有变量．

４　递归函数中，位于递归调用语句后的语句的执行顺序和各个被调用函数的顺序相反．

５　虽然每一级递归有自己的变量，但是函数代码并不会得到复制．

６　递归函数中必须包含可以终止递归调用的语句．

Kotlin中的递归使用：

fun recu(num:Int):Int{
    if(num==1){
        return 1
    }else{
        return num*recu(num-1)
    }
}

Kotlin的尾递归优化–tailrec

在上面的递归函数中，也有一定的缺点，假如说求10000的阶乘，如果是在Java中实现，会出现OOM的问题，因为在函数执行中，每调用一个函数都会把当前函数的调用位置和内部变量保存在栈里面，由于栈的空间不是无限大，假如说调用层数过多，就是出现OOM的情况，但是在Kotlin中增加了尾递归优化机制–tailrec,现在将上面的函数改一改：

tailrec fun recu(num:Int):Int{
    if(num==1){
        return 1
    }else{
        return num*recu(num-1)
    }
}

这样就可以算出10000的阶乘了

总结：上面我们将的是一些Kotlin的基础部分，学过编程基础的人都不难看懂，后面我们还会进一步学习Kotlin的相关知识；

上一篇:Kotlin学习之路–Kotlin简述

下一篇:Kotlin学习之路–面向对象