Code Kotlin学习笔记0x01

Kotlin学习笔记0x01

  1. 基本语法

函数

定义一个接受两个Int型的函数，返回值类型是Int

1
2
3
4
5
6
fun Sum(a :Int,b :Int) :Int {
    return a + b//返回a,b之和
}

println(Sum(1,2))
//输出结果3

定义一个无返回值的函数

1
2
3
4
5
6
7
8
9
10
fun Sum(a: Int,b:Int){
    println("sum of $a and $b is ${a+b}")
    //$表示使用值，{}表示执行一个语句，${}表示使用语句的值
}

func main(args: Array<String>):Uint{
    //Unit可以省略
    Sum(-1,2)
    //输出1
}

函数

局部变量

1
2
3
4
5
6
7
8
fun main(args: Array<String>){
    val a: Int = 1  //立即初始化
    val b = 2       //自动推导出b是Int类型
    val c : Int     //没有初始化的时候必须声明类型
    c = 3           //赋值
    println("a=$a,b=$b,c=$c")
    //输出结果a=1,b=2,c=3
}

属性和字段

注释

1
2
3
4
//单行注释
/*
多行注视
*/

字符串模版

1
2
3
4
5
6
7
8
fun main(args: Array<String>){
    var a = 1
    val s1 = "a is $a"
    a = 2
    val s2 = "&{s1.replace("is","was")},but now is $a"
    //replace返回一个String值,并不会修改其本身的值
    println(s2)
}

输出结果

1
a was 1,but now is 2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
fun parseInt(str: String): Int?{
    return str.toIntOrNull()
}

fuc printProduct(arg1: String,arg2: String){
    val x = parseInt(arg1)//将arg1转换成一个Int并返回
    val y = parseInt(arg2)//将arg2转换成一个Int并返回
    //对x,y进行检查，是否都转换成了Int
    if(x !=null && y !=null){
        println(x * y)
    }else{
        println("either '$arg1' or '$arg2' is not a
        number")
    }
}

fun main(args: Array<String>){
    printProduct("6","0")
    //将两个只有数字的字符串传入printProduct
    printProduct("a","1")
    //将1个是数字，一个是非数字的字符串传入printProduct
    printProduct("1a","6")
    //将1个是数字，一个是带有数字的字符串传入printProduct
    printProdyct("a","a")
    //将两个只有非数字的字符串传入printProduct
}

输出结果

1
2
3
4
0
either 'a' or '1' is not a number
either '1a' or '6' is not a number
either 'a' or 'a' is not a number

值检查并自动转换

1
2
3
4
5
6
7
8
9
10
11
12
13
fun getStringLength(obj: Any): Int?{
    if(obj is String){
        //obj将会自动被转换成String类型
        //所以可以放心的调用String的属性
        return obj.length
    }
    return null
}
fun main(args: Array<String>){
    println("result is ${getStringLength("abc")} ")
    println("result is ${getStringLength(123)}")
    println("result is ${getStringLength(listOf(Any()))}")
}

输出结果

1
2
3
result is 3 
result is null
result is null

循环

for循环

1
2
3
4
5
6
fun main(args: Array<String>){
    val items = listOf("apple","banana","kiwi")
    for(a in items){
        println(item)
    }
}

输出结果

1
2
3
apple
banana
kiwi

while循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
fun main(args: Array<String>){
    val items = listOf("apple","banana","kiwi")//注意这
    val
    var index = 0 //注意这里是var
    while(index < items.size){
        println("item at $index is ${items[index]}")
        index++
    }
}
/*
var和val的区别如下:
var 声明了一个变量 val 声明的是不可变量
val 相对于 final
*/

输出结果

1
2
3
item at 0 is apple
item at 1 is banana
item at 2 is kiwi

when表达式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
fun describe(obj: Any):String =
when(obj){
     1           -> "One"
    "Hello"     -> "Greeting"
    is Long     -> "Long"
    !is String  -> "Not a String"
    else        -> "Unknown"
}

fun main(args:Array<String>){
    println(describe(1))
    println(describe("Hello"))
    println(describe(1000L))
    println(describe(2))
    println(describe("other"))
}

输出结果

1
2
3
4
5
One
Greeting
Long
Not a String
Unknown

这个when 好像switch，但是也有不小区别

ranges

in操作检查数值是否在某个范围内

1
2
3
4
5
6
7
fun main(args:Array<String>){
    val x = 10
    val y = 9
    if(x in 1..y+1){
        println("fits in range")
    }
}

输出结果

1
fits in range

!in操作符检查是否在某个范围外

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
fun main(args:Array<String>){
    val list = listOf("a","b","c")
    if(-1 !in 0..list.lastIndex){
        println("-1 is out of range")
        println("list.lastIndex is ${list.lastIndex}")
    }
    if(list.size !in list.indices){
        println("list size is out of valid list indices range too")
        println("list.size is ${list.size}")
        println("list.indices is ${list.indices}")
    }
    if("a" in list){
        println("a is in list")
    }
}

输出结果

1
2
3
4
5
6
-1 is out of range
list.lastIndex is 2
list size is out of valid list indices range too
list.size is 3
list.indices is 0..2
a is in list

迭代

1
2
3
4
5
fun main(args: Array(String)){
    for(x in 1..5){
        print(x)
    }
}

输出结果

1
12345

步进

1
2
3
4
5
6
7
8
fun main(args: Array<String>){
    for(x in 1..10 step 2){
        print(x)
    }
    for(x in 9 downTo 0 step 3){
        print(x)
    }
}

输出结果

1
135799630

集合

使用in操作符检查集合中是否包含某个对象

1
2
3
4
5
6
7
fun main(args: Array<String>){
    val items = setOf("apple","banana","kiwi")//set中没有重复对象
    when{
        "orange" in items -> println("juicy")
        "apple" in items -> println("app is fine too")
    }
}

输出结果

1
apple is fine too

使用lambda表达式过滤和映射集合

1
2
3
4
5
6
7
8
fun main(args:Array<String>){
    val fruits = listOf("banana","avocado","apple","kiwi")
    fruits
        .filter{it.startsWith("a")}
        .sortedBy{it}
        .map{it.toUpperCase()}
        .forEach{println(it)}
}

输出结果

1
2
APPLE
AVOCADO

参考资料

在线Kotlin IDE

To Be Continue

阅读量: