前言

开发工具

• android sutdio
• IntelliJ IDEA 2018.3.3 x64

基础部分使用Intellij IDEA

资料

image

kotlin官网教程

官方语法

image

[菜鸟课程](http://www.runoob.com/kotlin/kotlin-basic-syntax.html]

github地址

视频教程

资料

基础示例

// 类的定义(构造方法的参数)
class Greeter(val name: String) {
    // 函数的定义
    fun greet() {
        println("Greeter Hello,$name")
    }
}

//包级的可见函数，接受一个字符串数组作为参数
fun main(args: Array<String>) {
    println("Hello World!")
    // 对象的创建，不需要使用new关键字
    Greeter("World!").greet()
}

函数

//包级可见函数 test
fun test() {
    println("main.test method run ...")
}

// 包级可见对象 Runnob
class Runnob {
    fun tech(name: String) {
        println("上课,学习 $name")
    }
}


/* -------------- 函数定义 -------------- */
// fun(参数:参数类型):返回值类型
fun sum(a: Int, b: Int): Int {
    return a + b
}

// 表达式作为函数体:返回类型自动判断
fun add(a: Int, b: Int) = a + b

// public 方法必须写出返回类型
public fun update(a: Int, b: Int): Int = a + b

// public 方法必须写出返回类型，不写不会报错，可以正常运行
public fun update2(a: Int, b: Int) = a + b

//无返回值的函数(类似java的void)
fun printSum(a: Int, b: Int): Unit {
    println("result = ${a + b}")
}

// 如果返回的是Unit类型，则可以省略(对于public也可以这样)
public fun printSum2(a: Int, b: Int) {
    println("result2 = ${a + b}")
}

/* -------------- 函数定义 -------------- */

/* -------------- 可变长度函数 -------------- */
//函数的可变长度使用vararg进行标识
fun fetch_add(vararg v: Int) {
    val sb = StringBuilder()
    sb.append("[ ")
    v.forEach {
        sb.append(it).append(",")
    }

    // 删除所在位置的字符串
    sb.deleteCharAt(sb.length - 1)

    sb.append(" ]")

    println("参数: ${sb.toString()}")
}

/* -------------- 可变长度函数 -------------- */

/* -------------- lambda(匿名函数) -------------- */
fun m_lambda(x: Int, y: Int): Int {
    // 定义lambda函数
    val sumLambda: (Int, Int) -> Int = { m, n -> m + n }
    // 使用
    return sumLambda(x, y)
}

/* -------------- lambda(匿名函数) -------------- */
fun main(args: Array<String>) {
    println("hello sample01")

    test()

    Runnob().tech("英文")
    Runnob().tech("数学")
    Runnob().tech("化学")

    // 表达式: $val 引用变量
    // 表达式: ${} 引用函数或其它公式
    println("求合: ${sum(12, 55)}")
    println("表达式使用${12 + 15 * 3}")
    println("求合: ${add(100, 110)}")

    printSum(12, 35)
    printSum2(100, 199)

    // 可变长度函数
    fetch_add(1, 2, 3, 4, 5)

    println("lambda(匿名函数): ${m_lambda(175, 33)}")

}

变量和常量

/* -------------- 变量和常量 -------------- */
/*
可变变量: var 关键字
     var 标识符:类型 = 初始化值

不可变变量:val(相当于java中的final修饰的变量)
    val 标识符:类型 = 初始化值

常量与变量都可以没有初始化值，但是在引用前必须初始化
*/
/* -------------- 变量和常量 -------------- */

/* -------------- 注释 -------------- */
// 单行注释
/* 多行注释 */
/* -------------- 注释 -------------- */
/* -------------- 字符串模板 -------------- */
/*
* $ 表示一个变量名或变量值
* $ varName 表示变量值
* $varName.fun() 表示变量的方法返回值
*/
/* -------------- 字符串模板 -------------- */
fun str_templete() {
    var a = 1
    // 模板中的简单名称
    val s1 = "a is $a"
    println("s1 is $s1")

    a = 2
    // 模板中的任意表达式
    val s2 = "${s1.replace("is", "was")},but now is $a"
    println("s2 is $s2")
}
/* -------------- 字符串模板 -------------- */

/* -------------- NULL检查机制 -------------- */
/*
 * kotlin的空安全设计对于声明可为空的参数，在使用时要进行空判断处理，有两种处理方式
 *  字段!! 像java一样抛出空异常
 *  字段? 可不做处理返回值为null或配合?:做空判断处理
 */

// 空检查机制
fun nul_check_mechanism() {
    // 表示ageStr可以为空
    var ageStr: String? = "23"
    println("ageStr = $ageStr")
    ageStr = null
    println("ageStr = $ageStr")
    // 不做处理时，这里会抛出空指针的异常
    val ageI = ageStr!!.toInt()
    println("ageI = $ageI")
    // Exception in thread "main" kotlin.KotlinNullPointerException
    //  at Sample03_常量与变量Kt.nul_check_mechanism(sample03-常量与变量.kt:51)
    //  at Sample03_常量与变量Kt.main(sample03-常量与变量.kt:87)

    val ageI2 = ageStr?.toInt()
    println("ageI2 = $ageI2")
    // 判断ageStr是否为空如果为空则返回-1
    val ageI3 = ageStr?.toInt() ?: -1
    println("ageI3 = $ageI3")

    var addStr: String? = null
    var addStr2: String? = null

    println("addStr = $addStr , addrStr2 = $addStr2")
}

// 当str中的字符串不是一个整数时，则返回null
fun parseInt(str: String): Int? {
//    return Integer.parseInt(str)
    return str.toInt()
}

// Exception in thread "main" java.lang.NumberFormatException: For input string: "单价135"
//fun parseInt2(str: String): Int? = Integer.parseInt(str)
fun parseInt2(str: String): Int? {
    try {
//        return Integer.parseInt(str)
        return str.toInt()
    } catch (e: Exception) {
        return -1
    }
}

/* -------------- NULL检查机制 -------------- */

/* -------------- 类型检测及自动类型转换 -------------- */
// 可以使用is运算符判断一个表达式是否是某类型的一个实例(类似于java的instanceof)
fun getStrLength(obj: Any): Int? {
    if (obj is String) {
        // 做过类型判以后，obj会被系统自动转换为String类型
        return obj.length
    }

    // 这里的obj仍然是Any类型的引用
    return null
}

fun getStrLength_2(obj: Any): Int? {
    if (obj !is String) {
        return null
    }

    // 在这里个分支，obj的类型自动转换为String
    return obj.length
}

fun getStrLength_3(obj: Any): Int? {
    // && 运算符的右侧,obj的类型会被自动转换为String
    if (obj is String && obj.length > 0) {
        return obj.length
    }

    return null
}
/* -------------- 类型检测及自动类型转换 -------------- */

/* -------------- 区间 -------------- */
/*
* 区间表达式由具有操作符形式..的rangeTo函数以in和!in形成
* 区间是为任何可比较类型定义的，但对于整形原生类型，它有一个优化的实现
*/
fun t_range_t_01() {
    // 只能正向遍历不能反向遍历
    for (i in 1..4)
        print(i)
    println()

    // 不会有任何输出
    for (j in 4..1)
        print(" $j , ")

    var k = 5
    if (k in 1..10) {
        println(k)
    }

    // step指定步长值
    // 正向操作
    for (l in 1..4 step 2) {
        // 从1开始输出，跳过2个。所以输出的是1,+2 = 3
        println(l)
    }

    // 反向操作
    for (m in 4 downTo 1 step 2) {
        // 从4开始输出，跳过2个。所以输出的是4,-2 = 2
        println(" $m , ")
    }

    // 使用until函数排除结束元素
    for (n in 1 until 10) {
        // 排除10
        print(" $n , ")
    }
}

/* -------------- 区间 -------------- */
fun main(args: Array<String>) {
    // 变量与常量
    val a: Int = 1

    // 系统自动判断变量类型为Int
    val b = 1
    //如果不在声明时初始化则必须提供变量类型
    val c: Int
    // 明确赋值
    c = 5
    println("常量 a = $a, b = $b, c = $c")

    var x = 5
    // 系统自动判断变量类型为Int
    x += 1

    // Val cannot be reassigned
//    c+=2

//    var z: Int

    // Error:(33, 30) Kotlin: Variable 'z' must be initialized
//    z = 10

    // 变量声明必须要初始化，不初始化会报错
    var z = 10
    println("变量 x = $x, z = $z")

    // 字符串模板
    str_templete()

//    nul_check_mechanism()

    println("类型转换: ${parseInt("135")}")
    println("类型转换: ${parseInt2("单价135")}")

    println("getStrLength -> ${getStrLength("www.baidu.com")}")
    println("getStrLength_2 -> ${getStrLength_2(123)}")
    println("getStrLength_3 -> ${getStrLength_3('a')}")

    t_range_t_01()
}

基本数据类型

/* -------------- 基本数值类型 -------------- */
/*
基本数值类型包括Byte,Short,Int,Long,Float,Double
字符不属于数值类型，是一个独立的数据类型
 类型                  位宽度
Double                  64
Float                   32
Long                    64
Int                     32
Short                   16
Byte                    8

字面常量:

十进制:123
长整型以大写的L结尾:123L
十六进制:以0x开头:0x0F
二进制:以0b开头:0b00001011
不支持八进制
Double:123.5 123.50
FLoat: f或F结尾:123.5f
 */
fun basic_data_type() {
    var age: Int = 23
    var phoneNum: Long = 13244105539L
    var unit_price: Float = 31.5f
    var quantity: Double = 15000.5
    var start_num: Short = 80
    var mac_notebook: Byte = 0b00001011

    println("age = $age")
    println("phoneNum = $phoneNum")
    println("unit_price = $unit_price")
    println("quantity = $quantity")
    println("start_num = $start_num")
    println("mac_notebook = $mac_notebook")

    var hexBytes = 0xFF_EC_DE_5E
    println("hexBytes = $hexBytes")
    // 十六进制
    println("十六进制: 0X${Integer.toHexString(128)}")
    // 二进制
    println("二进制: 0B${Integer.toBinaryString(128)}")
    // 8进制
    println("八进制: 0${Integer.toOctalString(128)}")
}

/* -------------- 基本数值类型 -------------- */

/* -------------- 比较两个数字 -------------- */
// === 比较对象地址,==比较两个值大小
fun comare_num() {
    val a: Int = 10000
    // 判断值是否相等，对象地址是否相等
    println(a === a)

    val b: Int = 10000
    println(a === b)

    // 装箱，创建两个不同的对象,基本数据转换为引用类型
    // 值相等，地址不一样
    val boxedA: Int? = a
    val boxedB: Int? = b

    // 两个对象的地址不一样
    // boxedA:@633 boxedB:@634
    println(boxedA === boxedB)
    println(boxedA == boxedB)
}
/* -------------- 比较两个数字 -------------- */

/* -------------- 类型转换 -------------- */
/*较小类型并不是较大类型的子类型，较小的类型不能隐式转换为较大的类型。
这意味着不进行显示转换的情况下，我们不能把一个Byte型值赋值给一个Int变量*/
//fun cast_type_00() {
//    val b: Byte = 1
//    val i: Int = b
//}

fun cast_type_01() {
    val b: Byte = 1
    val i: Int = b.toInt()
}

/*
每种数据类型都有下面转换为其它类型的方法
toByte():Byte
toShort():Short
toInt():Int
toLong():Long
toFloat():Float
toDouble():Double
toChar():Char
*/
// 自动类型转换，前提是可以根据上下文环境推断出正确的数据类型而且数学操作符会做相应的重载。
//例：
val l = 1L + 3

/* -------------- 类型转换 -------------- */

/* -------------- 位操作符 -------------- */
// 对于Int和Long类型，位操作符可以使用
/*
shl(bits) - 左移位(<<)
shr(bits) - 右移位(>>)
ushr(bits) - 无符号右移位(>>>)
and(bits) - 与
or(bits) - 或
xor(bits) - 非
inv() - 反向
*/
fun bit_opt() {
    println("4 左移 ${4.shl(1)}")
    println("4 右移 ${4.shr(1)}")
    println("-4 无符号右移位 ${-4.ushr(1)}")
    println("-4 反向 ${-4.inv()}")
    println("4 反向 ${4.inv()}")
}
/* -------------- 位操作符 -------------- */

/* -------------- 字符 -------------- */
/*kotlin中的char不能直接和数字操作，Char必须是''包含起来的
字符字面值用''括起来
特殊字符可以使用转义，支持\t,\b,\n,\r,\',\",\\,\$
编码其它字符要用Unicode转义 \uFF0
*/
fun decimalDigitValue(c: Char): Int {
    if (c !in '0'..'9')
        throw IllegalArgumentException("Out of range")

    // 显示转换为数字
    return c.toInt() - '0'.toInt()
}

/* -------------- 字符 -------------- */

/* -------------- 布尔 -------------- */
/*
布尔用 Boolean 类型表示，它有两个值：true 和 false。
若需要可空引用布尔会被装箱。
&&（与） ||（或） !（非)
*/
fun t_bool() {
    var a: Int = 100
    var b: Int = 35
    println("${(a > 50) && (b < 100)}")
    a = -1
    b = 10
    println("${(a > 10) || (b > 0)}")

    println("${!((a != 0) || (b < 100))}")

}

/* -------------- 布尔 -------------- */

/* -------------- 数组 -------------- */
/*
数组用类 Array 实现，并且还有一个 size 属性及 get 和 set 方法，由于使用 []
重载了 get 和 set 方法，所以我们可以通过下标很方便的获取或者设置数组对应位置的值。

数组的创建两种方式：一种是使用函数arrayOf()；另外一种是使用工厂函数

[] 代表调用成员函数get()和set()

Kotlin中的数组是不可变类型的

除了Array,还有ByteArray,ShortArray,IntArray,用来表示各个类型的数组，省去了装箱的操作
*/
fun t_arr() {
    val a = arrayOf(1, 2, 3)
    val b = Array(3, { i -> (i * 2) })

    printIntArr(a)
    printIntArr(b)

    val x: IntArray = intArrayOf(1, 2, 3, 4)
    x[0] = x[1] + x[2]
    println("x[0] = ${x[0]}")
}

// 打印数组中的内容(int)
private fun printIntArr(b: Array<Int>) {
    print("[")
    val _last_item: Int = b[b.size - 1]
    for (i in b) {
        if (i != _last_item)
            print("$i,")
        else
            print("$i")
    }
    println("]")
}
/* -------------- 数组 -------------- */

/* -------------- 字符串 -------------- */
/*String是不可变的，[]可以很方便获取字符串中的某个字符，也可以通过for循环来遍历*/
fun t_str() {
    val s_arr: String = "www.qq.com"
    val _last_str = s_arr[s_arr.length - 1]
    print("[")
    for (c in s_arr) {
        // 这里使用==,===都可以,使用equals比较正则
        if (_last_str.equals(c)) {
            print(" $c ")
        } else {
            print(" $c , ")
        }
    }
    println("]")
}

//kotlin支持""""""字符串，支持多行字符串
fun t_str2() {
    val txt_wel_world = """
        Today I shed my old skin, which has too long suffered the bruises of failure and the wounds of mediocrity.

　　Today I am born anew and my birthplace is a vineyard where there is fruit for all.

    """
    println(txt_wel_world)
    // trimMargin 删除多余的空白,默认使用|用作边界前缀，可以使用其它字符并作为参数传入trimMargin(">")
    val txt_wel_world2 = """
        Today I shed my old skin, which has too long suffered the bruises of failure and the wounds of mediocrity.

　　Today I am born anew and my birthplace is a vineyard where there is fruit for all.

    """.trimMargin()
    println(txt_wel_world2)
}
/* -------------- 字符串 -------------- */

/* -------------- 字符串模板 -------------- */
/*
字符串可以包含模板表达式，会求值并把结果合并到字符串中，模板表达式以$开头，由一个简单的名字构成
或使用{}起来的任意表达式
*/
fun t_str_template() {
    val i = 10
    val s = "i = $i"
    println(s)

    val weather_code = 10
    // java中的三元运算符这里不支持只能使用if...else进行转换操作
    println("今天天气怎么样${if (weather_code > 0) "晴" else "阴"}")

    val s1 = "runoob"
    // runoob.length is 6
    val str = "$s1.length is ${s1.length}"
    println(str)

    // 原生字符串和转义字符串内部都支持模板。 如果你需要在原生字符串中表示字面值 $ 字符（它不支持反斜杠转义）
    val price = """
        ${'$'}9.99
    """.trimIndent()
    println(price)
}
/* -------------- 字符串模板 -------------- */


fun main(args: Array<String>) {
    println("基本数据类型")
    basic_data_type()
    comare_num()
    println("l = $l")
    bit_opt()
    println("字符操作 ${decimalDigitValue('8')}")
    t_bool()
    t_arr()
    t_str()
    t_str2()
    t_str_template()
}

条件控制

/* -------------- if表达式 -------------- */
/*一个if语句包含一个布尔表达式或多条语句*/
fun t_if() {
    var a = 10
    var b = 5

    // 传统用法
    var max = a

    if (a < b)
        max = b

    println("传统用法 max = $max")

    // 使用else
    if (a > b) {
        max = a
    } else {
        max = b
    }
    println("使用else max = $max")

    // 使用表达式
    max = if (a > b) a else b
    println("使用表达式 max = $max")

    val _is_max = if (a > b) {
        print("choose a")
        a // 将a赋值给_is_max
    } else {
        print("choose b")
        b // 将b赋值给_is_max
    }
    println("使用表达式 _is_max = $_is_max")

    // java 的三元操作符,val c = if(condition) a else b
}

fun t_if_sample() {
    var x = 0
    if (x > 0) {
        println("x 大于 0")
    } else if (x < 0) {
        println("x 小于 0")
    } else {
        println("x 等于 0")
    }

    var a = 1
    var b = 2
    var c = if (a >= b) a else b
    println("c 的值为 $c")
}

fun t_arange() {
    var x = 5
    var y = 9

    if (x in 1..8) {
        println("x 在区间内")
    }
}
/* -------------- if表达式 -------------- */

/* -------------- when表达式 -------------- */
/*
when将它的参数和所有的分支条件顺序比较，直到某个分支满足条件
when 即可以被当做表达式使用也可以当做语句使用。如果它被当做表达式，
符合条件的分支值就是整个表达式的值，如果当做语句使用，则忽略个别分支的值
when 类似其它语言的switch
*/
fun t_when() {
    val x = 3
    when (x) {
        1 -> println("x==1")
        2 -> println("x==2")
        else -> {
            println("x 不是 1, 也不是 2")
        }
    }
}

/*
在when中，else同switch 的default,如果其它分支都不满足条件将会求else分支
如果很多分支需要用相同的方式处理，则可以把多个分支条件放在一起，用,分隔
*/
fun t_when2() {
    val x = 2
    when (x) {
        1, 2 -> println("x == 1 or x == 2")
        else -> println("other wise")
    }
}

/*我们也可以检测 一个值在(in)或不在(!in)一个区间或集合中*/
fun t_when3() {
    var x = 5
    val validNumbers = arrayOf(2, 3, 5)
    when (x) {
        in 1..10 -> println("x is in the range")
        in validNumbers -> println(" x is valid")
        !in 10..20 -> println(" x is outside the range")
        else -> println("none of the above")
    }
}

/*另一种可能性是检测一个值是(is)或不是(!is)一个特定类型的值。注意:
由于智能转换，你可以访问该类型的方法和属性而无需任何额外的检测*/


fun hasPrefix(x: Any): Boolean {
    // 如果是字符串返回pr
    var x1 = when (x) {
        is String -> {
            x.startsWith("prefiex")
            true
        }
        else -> {
            false
        }
    }
    return x1
}

fun hasPrefix2(x: Any) {
    // 如果是字符串返回pr
    when (x) {
        is String -> {
            x.startsWith("prefiex")
        }
        else -> {
            false
        }
    }
}

fun t_when4() {
    println("${hasPrefix(15)}")
    println("${hasPrefix("中国人的天下")}")

    println("${hasPrefix2(15)}")
    println("${hasPrefix2("中国人的天下")}")
}

// when 也可以用来取代 if-else if链。 如果不提供参数，所有的分支条件都是简单的布尔表达式，而当一个分支的条件为真时则执行该分支
fun t_when5() {
    val x = 15

    when {
//        x.isOdd() -> println(" x is odd")
//        x.isEvent() -> println(" x is event")
        else -> {
            println("x is funny")
        }
    }
}

fun t_when_sample() {
    var x = 0

    when (x) {
        0, 1 -> println("x==0 or x==1")
        else -> println("otherwise")
    }

    when (x) {
        1 -> println("x == 1")
        2 -> println("x == 2")
        else -> println("x 不是1 也不是2")
    }

    when (x) {
        in 0..10 -> println("x在该区间范围内")
        else -> println("x不在该区间范围内")
    }
}


fun t_when_sample2() {
    val items = setOf("apple", "banna", "kiwi")
    when {
        "orange" in items -> println("juicy")
        "apple" in items -> println("apple if fine too")
    }
}

/* -------------- when表达式 -------------- */
fun main(args: Array<String>) {
    t_if()

    t_if_sample()

    t_arange()

    t_when()

    t_when2()

    t_when3()

    t_when4()

    t_when_sample()

    t_when_sample2()
}

循环控制

/* -------------- For 循环 -------------- */
// for 循环可以对任何迭代器(iterator)的对象进行遍历 for (item in collection) print(item)
fun t_for_1() {
    val ages = arrayOf(22, 34, 55, 52, 51)
    for (age in ages) {
        println(age)
    }

    // 通过索引遍历一个数组或者list
    for (index in ages.indices) {
        println("_index $index value = ${ages[index]}")
    }

    for ((index, value) in ages.withIndex()) {
        println("item at $index value is $value")
    }
}

fun t_for_sample() {
    val items = listOf("apple", "banana", "kiwi")
    for (item in items) {
        println(item)
    }

    for (index in items.indices) {
        println("item at $index value is ${items[index]}")
    }
}
/* -------------- For 循环 -------------- */

/* -------------- while 与 do...while 循环 -------------- */
/*
while最基本的循环
while(a){
    // 循环内容
}

do..while循环对于while，如果不满足条件，则不会进行循环，即使条件不满足,do也会执行一次

do..while至少会执行一次
do{
}while(a)
*/
fun t_do_while() {
    println("t_do_while run ...")
    var x = 5
    while (x > 0)
        println(x--)

    var y = 5
    do {
        println(y--)
    } while (y > 0)

    y = -1
    do {
        println(y--)
    } while (y > 0)
}
/* -------------- while 与 do...while 循环 -------------- */

/* -------------- 返回和跳转 -------------- */
/*
 *return 跳出函数和循环
 *break 终止循环
 *continue 继续下一次循环
 */
fun t_r_b_c() {
    println("t_r_b_c run ...")
    val i = 7
    for (i in 1..10) {
        // 继续下一次循环
        if (i == 3) continue
        println(i)
        // 退出循环
        if (i > 5)
            break
    }
}

/*break&continue
* 在 Kotlin 中任何表达式都可以用标签（label）来标记。 标签的格式为标识符后跟 @ 符号，例如：abc@、fooBar@都是有效的标签。
* 要为一个表达式加标签，我们只要在其前加标签即可。
*
* 嵌套循环可以使用
* 标签限制的 break 跳转到刚好位于该标签指定的循环后面的执行点。
* continue 继续标签指定的循环的下一次迭代。
*/
fun t_b_c() {
    println("t_b_c run ...")
    val i = 7
    loop@ for (i in 1..100) {
        // 继续下一次循环
        if (i == 3) continue
        println(i)
        // 退出循环
        if (i > 5)
            break@loop
    }
}

/* -------------- 返回和跳转 -------------- */

/* -------------- 标签处返回 -------------- */
/*
Kotlin 有函数字面量、局部函数和对象表达式。因此 Kotlin 的函数可以被嵌套。 标签限制的 return 允许我们从外层函数返回。
最重要的一个用途就是从 lambda 表达式中返回。回想一下我们这么写的时候：

fun foo() {
    ints.forEach {
        if (it == 0) return
        print(it)
    }
}

这个 return 表达式从最直接包围它的函数即 foo 中返回。 （注意，这种非局部的返回只支持传给内联函数的 lambda 表达式。）
如果我们需要从 lambda 表达式中返回，我们必须给它加标签并用以限制 return。

fun foo() {
    ints.forEach lit@ {
        if (it == 0) return@lit
        print(it)
    }
}

现在，它只会从 lambda 表达式中返回。通常情况下使用隐式标签更方便。 该标签与接受该 lambda 的函数同名。

fun foo() {
    ints.forEach {
        if (it == 0) return@forEach
        print(it)
    }
}

或者，我们用一个匿名函数替代 lambda 表达式。 匿名函数内部的 return 语句将从该匿名函数自身返回

fun foo() {
    ints.forEach(fun(value: Int) {
        if (value == 0) return
        print(value)
    })
}

当要返一个回值的时候，解析器优先选用标签限制的 return，即

return@a 1
意为"从标签 @a 返回 1"，而不是"返回一个标签标注的表达式 (@a 1)"。
*/

fun t_nest_loop() {
    val nums = arrayOf(3, 1, 15, 44, 22, 8, 79)
    // 正序
    for (i in nums.indices) {
        for (j in nums.indices) {
            if (nums[i] < nums[j]) {
                var tmp = nums[i]
                nums[i] = nums[j]
                nums[j] = tmp
            }
        }
    }

    print("[ ")
    for ((index, value) in nums.withIndex()) {
        if (index != nums.size - 1) {
            print("$value , ")
        } else {
            println("$value ]")
        }
    }

    // 倒序
    for (i in nums.indices) {
        for (j in nums.indices) {
            if (nums[i] > nums[j]) {
                var tmp = nums[i]
                nums[i] = nums[j]
                nums[j] = tmp
            }
        }
    }

    print("[ ")
    for ((index, value) in nums.withIndex()) {
        if (index != nums.size - 1) {
            print("$value , ")
        } else {
            println("$value ]")
        }
    }

}
/* -------------- 标签处返回 -------------- */


fun main(args: Array<String>) {
    println("main run ...")
    t_for_1()
    t_for_sample()
    t_do_while()
    t_r_b_c()
    t_b_c()
    t_nest_loop()
}