Kotlin 进阶之路3 控制流与函数

1.控制流

/**
 *用来检查和运算各种条件和逻辑的组合，控制App的运行流向
 * 循环：for，while 及循环控制
 * if：二元判断
 * when：细致化判断
 * */
fun main(args: Array<String>) {
    println("----------------依次操作一个序列(如集合类型)中的每一项----------------")
    //for：1.依次操作一个序列(如集合类型)中的每一项，执行次数是可预测的
    val numbers = arrayOf(1, 2, 3, 4)
    for (number in numbers) {
        println(number)
    }

    println("----------------重复执行----------------")
    // 2.重复执行：for(a in 1..10){//操作}
    for (n in 1..3) {
        println(n)
    }

    println("----------------while:循环执行----------------")
    //while:循环执行一系列操作，直到条件不成立，适合执行次数未知的场合
    var number = 1
    while (number < 5) {
        number++
        println("hello")
    }

    //循环中的控制：continue 结束本次循环 ，break 结束整个循环
    println("----------------结束本次循环：continue----------------")
    val numbers2 = arrayOf(1, 2, 3, 4)
    for (number in numbers2) {
        if (number == 2) {
            break
        }
        println(number)
    }

    println("----------------结束整个循环：break----------------")
    var number2 = 1
    while (number2 < 5) {
        number2++
        if (number2 == 3) {
            break
        }
        println("hello")
    }
    //if:条件判断语句，整合语句本身是一个表达式
    println("----------------条件判断语句：if----------------")
    val a = 3
    val b = 5
    val result = if (a > b) "a大于b" else "a小于b"
    println(result)

    //when:可对某个变量的大小/范围/值表达式/类型等进行判断
    println("----------------条件判断语句：if----------------")
    val c = 11
    when (c) {

        in 0..10 -> {
            println("在0到10之间")
        }
        11,13,15 -> {
            println("属于11,13,15中的值")
        }
        is Int -> {
            println("c属于整数")
        }
        else -> {
            println("c属于String类型")
        }
    }

}

----------------依次操作一个序列(如集合类型)中的每一项----------------
1
2
3
4
----------------重复执行----------------
1
2
3
----------------while:循环执行----------------
hello
hello
hello
hello
----------------结束本次循环：continue----------------
1
----------------结束整个循环：break----------------
hello
----------------条件判断语句：if----------------
a小于b
----------------条件判断语句：if----------------
属于11,13,15中的值

2.函数

/**
 * 函数是有名字的一段代码
 * 包含参数和返回值(可选),参数可以默认值
 */

fun main(args: Array<String>) {
    //F1函数名看文档
    //调用时可打参数名，可读性更好(但调用Java函数无效)

    println("----------------类似于C++ 给参数一个默认值----------------")
    val a = add(3)
    println(a)

    println("----------------正常调用----------------")
    val b = add(3, 5)
    println(b)

    println("----------------可变参数 传递元素----------------")
    println(sum(1,2,3,4,20))

    println("----------------可变参数 传递数组*Array----------------")
    val c = intArrayOf(1,2,3,4,20)
    println(sum(*c))
}



/**
 * Any 任意类型
 * Int 整型
 * : Int 意味着返回整型
 */
fun add(x: Int, y: Int = 1): Int {
    return x + y
}

//可变参数修饰符vararg
fun sum(vararg x: Int): Int {
    var total = 0

    for (i in x) {
        total += i
    }
    return total
}

----------------类似于C++ 给参数一个默认值----------------
4
----------------正常调用----------------
8
----------------可变参数 传递元素----------------
30
----------------可变参数 传递数组*Array----------------
30

3.初识lambda与高阶函数

/**
 * 高阶函数：1参数或返回值的类型是函数型
 * 函数型：(参数) -> 返回值
 * lambda：一种无名函数的简写 { (参数) -> 函数执行语句}
 *        其它语言称闭包，即有能力访问其自身范围外的变量
 */

fun main(args: Array<String>) {
    //高阶函数：描述任务的结果，而不是使用循环详细的推算

    println("----------------map：常用与对集合类型的元素类型整体转变----------------")
    //map：常用与对集合类型的元素类型整体转变
    //其lambda中参数的约定称为it
    val a = arrayOf(1,2,3,4,5,6,7,8)

    val b = a.map { "变为1$it" }

    for (s in b){
        println(s)
    }
    println("----------------filter:对集合类型进行筛选----------------")
    //filter:对集合类型进行筛选

    val c = a.filter { it %2 ==0 }
    for (i in c) {
        println(i)
    }
    println("----------------filter使用：对筛选数求和----------------")
    var sum = 0
    a.filter { it %2 ==0 }.forEach{
        sum+=it
        println(it)
    }
    println("求和:$sum")
}

----------------map：常用与对集合类型的元素类型整体转变----------------
变为11
变为12
变为13
变为14
变为15
变为16
变为17
变为18
----------------filter:对集合类型进行筛选----------------
2
4
6
8
----------------filter使用：对筛选数求和----------------
2
4
6
8
求和:20