Kotlin学习笔记——Day2

/**
 * 声明常量
 */
fun main(args: Array<String>){
    val a: Int = 1 //立即初始化
    val b = 2 //推导出Int类型
    val c: Int //当没有初始化值的时候必须声明类型
    c = 3 //赋值
}

/**
 * 变量
 */
fun main(args: Array<String>){
    var  x = 5 //推导出Int类型
    x += 1
    println("x = $x")
}

输出：x = 6

/**
 * 使用字符串模板
 */
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"
    println(s2)
}

输出：a was 1, but now is 2

/**
 * 使用条件表达式
 */
fun main(args: Array<String>){
    println("${maxOf(3,9)}")
}

fun maxOf(a: Int, b: Int): Int{
    if (a > b){
        return a
    }else{
        return b
    }
}
/**
 * 把if当表达式
 */
fun maxOf(a: Int, b: Int) = if (a > b) a else b

输出：9

/**
 * 使用可空变量以及空值检查
 */
 //使用一个返回可空值的函数
fun parseInt(str: String): Int? {
    return str.toIntOrNull()
}

fun printProduct(arg1: String, arg2: String){
    val x = parseInt(arg1)
    val y = parseInt(arg2)

    //直接使用x*y会产生错误因为他们中有可能会有空值
    if (x != null && y != null){
        // x 和 y 将会在空值检测后自动转换为非空值
        println(x * y)
    }
    else{
        println("either '$arg1' or '$arg2' is not a number")
    }
}

fun main(args: Array<String>){
    printProduct("5","-4")
    printProduct("a","b")
}

输出：-20
either ‘a’ or ‘b’ is not a number

/**
 *  使用值检查并自动转换
 *  使用 is 操作符检查一个表达式是否是某个类型的实例。如果对不可变的局部变量或属性进行过了类型检查，就没有必要明确转换
 */
fun getStringLength(obj: Any): Int? {
    if (obj is String){
        // obj 会在这个分支自动转换为String类型
        return obj.length
    }
    // obj 在种类检查外仍然是 Any类型
    return null
}

fun main(args: Array<String>){
    fun printLength(obj: Any){
        println("'$obj' string length is ${getStringLength(obj) ?: "...err, not a string"}")
    }
    printLength("ajjshhjdiehfiihdfIjds")
    printLength(10000)
    printLength(listOf(Any()))
}

输出：’ajjshhjdiehfiihdfIjds’ string length is 21
‘10000’ string length is …err, not a string
‘[java.lang.Object@78308db1]’ string length is …err, not a string

/**
 * 使用循环
 */
fun main(args: Array<String>){
    val items = listOf("apple","banana","li")
//    for (item in items){
//        println(item)
//    }
    for (index in items.indices){
        println("item at $index is ${items[index]}")
    }
}

/**
 * 使用while循环
 */
fun main(args: Array<String>){
    val items = listOf("apple","banana","li")
    var index = 0
    while (index < items.size){
        println("items at $index is ${items[index]}")
        index ++
    }
}

输出：item at 0 is apple
item at 1 is banana
item at 2 is li

/**
 * 使用when表达式
 */
fun main(args: Array<String>){
    println(describe(1))
    println(describe("Hello"))
    println(describe(1000L))
    println(describe(2))
    println(describe("other"))
}
fun describe(obj: Any): String =
        when(obj){
            1           ->          "One"
            "Hello"     ->          "Hi"
            is Long     ->          "Long"
            !is String  ->          "Not a String"
            else        ->          "Unknown"
        }

输出：One
Hi
Long
Not a String
Unknown

/**
 * 使用ranges
 */
fun main(args: Array<String>){
    val x = 10
    val y = 9
    if (x in 1..y+1){
        println("fits in range")
    }
}

输出：fits in range

/**
 *检查数值是否在范围外
 */
fun main(args: Array<String>){
    val list = listOf("a","b","c")
    if (-1 !in 0..list.lastIndex){
        println("-1 is out of range")
    }
    if (list.size !in list.indices){
        println("list size is out of valid list indices range too")
    }
}

输出：-1 is out of range
list size is out of valid list indices range too

/**
 * 在范围内迭代
 */
fun main(args: Array<String>){
    for (x in 1..5){
        print(x)
    }
}

输出：12345

/**
 * 或者使用步进
 */
fun main(args: Array<String>){
    for (x in 1..10 step 2){
        print(x)
    }
    for (x in 9 downTo 0 step 3){
        print(x)
    }
}

输出：135799630

/**
 * 使用集合
 * 对一个集合进行迭代
 */
fun main(array: Array<String>){
    val items = listOf("apple","banana","li")
    for (item in items){
        println(item)
    }
}

输出：apple
banana
li

/**
 * 使用in操作符检查集合中是否包含某个对象
 */
fun main(args: Array<String>){
    val items = setOf("apple","banana","li")
    when{
        "orange" in items -> println("juicy")
        "apple" in items  -> println("apple is fine")
    }
}

输出：apple is fine

/**
 * 使用lambda表达式过滤和映射集合
 */
fun main(args: Array<String>){
    val fruits = listOf("banana","apple","li","abc")
    fruits
            .filter { it.startsWith("a") }
            .sortedBy { it }
            .map { it.toUpperCase() }
            .forEach { println(it)}
}

输出：ABC
APPLE