1.函数简化

fun plus(args1:Int,args2:Int):Int {
    return args1+args2
}
fun plus(args1:Int,args2:Int):Int = args1+args2

2.命名参数,参数默认值,位置参数

        /**
         * 命名参数,位置参数调用的时候有个主意事项,位置参数必须放在命名参数的前面
        * 如果写成(name="huhu",20,"hehe"),那么后两个参数就会报错
        *Mixing named and positioned arguments is not allowed
         */
        namedParams("huhu", age = 20, id = "hehe")

3.嵌套函数

可以在函数内部声明一个函数,这个函数不可以被外部函数之外的地方使用

4.字符串模板和原生字符串

val name = "world"
//         👇 用 '$' 符号加参数的方式
println("Hi $name")
println("Hi ${args.length})

  fun testString() {
        var strings = """ 
                wo hsi yige zho fa.?jn
                dkjfkajdkf adfa
                jdkfjak
                """
        println(strings)
    }

5.数组和集合的操作符

forEach():遍历每一个元素

 fun testArraySysmol() {
        var strArray1 = intArrayOf(1,2,3,4)
        strArray1.forEach { i -> println(i) }
    }

filter:对每个元素进行过滤操作,如果条件满足则留下,不满足则剔除,返回一个集合类型的数据

    fun testArraySysmol() {
        var strArray1 = intArrayOf(1,2,3,4)
//注意:这里数组类型使用.filter()之后,返回值为List类型
        val filter: List<Int> = strArray1.filter { i -> i != 1 }
       filter.forEach { i -> println(i) }
    }

map:遍历每一个元素并执行给定的表达式,返回一个List集合

    fun testArraySysmol() {
        var strArray1 = intArrayOf(1,2,3,4)
          var mapResult:List<Int> =  strArray1.map { i -> i+2 }
        mapResult.forEach { i -> println(i) }
    }

flatMap:遍历每一个元素,并未每个元素创建一个新的集合,最后合并成为一个集合

    fun testArraySysmol() {
        var strArray1 = intArrayOf(1,2,3,4)
       var flatMapResult:List<String> =  strArray1.flatMap { i -> listOf("${i+2}","a") }

        flatMapResult.forEach { i -> print(i) }
    }

Range:区间,范围

   fun rangeTest() {
//表示1到1000,包括1000
        val rangeNum:IntRange = 1..1000
//表示1到1000,但不包括1000
        val rangeNum:IntRange = 1 until 1000
        for (i in rangeNum) println(i)
//step : 设置步长  1,3,5,7,9
 for (i in rangeNum step 2) println(i)
//downTo:递减区间
 for (i in 4 downTo 1) println(i)
    }

Sequence:惰性加载集合

• 一旦满足遍历退出的条件，就可以省略后续不必要的遍历过程。
• 像 List 这种实现 Iterable 接口的集合类，每调用一次函数就会生成一个新的 Iterable，下一个函数再基于新的 Iterable 执行，每次函数调用产生的临时 Iterable 会导致额外的内存消耗，而 Sequence 在整个流程中只有一个。

 fun listTest() {
        val listResult = listOf<Int>(1,2,3,4)
        var result2 = listResult.map { i->
            print("Map $i ,")
            i*2
        }
            .filter { i ->
                print("Filter $i ,")
                i%3 == 0
            }
  //list不管下面执行不执行,上面的代码都会立即执行
        println(result2.first())
    }

    fun squenceTest() {
        var squenceResult = sequenceOf(1,2,3,4)
       var result2:Sequence<Int> =  squenceResult.map { i ->
            print("Map $i ,")
            i*2
        }
            .filter { i ->
                print("Filter $i ,")
                i%3 == 0

            }
        //在下面的这句println执行前,上面的print()是不会调用的,也就是说sequence只是指定流程,而并不立即执行
        println(result2.first())
    }

条件控制

    fun whenTest(num:Int) {
        when(num) {
          //   也可以这样写
         // 0,1 -> println("我是0,或者1")
            0 -> println("我是0")
            1 -> println("我是1")
            2 -> println("我是2")
            else -> print("我是特殊情况")
        }
    }

• in

   fun whenTest(num:Int) {
        when(num) {
           in 0..10 -> println("我在里面")
            in listOf<Int>(11,22,33,44,55) -> println("我在集合中")
            else -> print("我是特殊情况")
       }
 }

• is :进行特定类型的检测
• when后面省略参数,每一个分支条件都可以是一个布尔表达式：

when {
    str1.contains("a") -> print("字符串 str1 包含 a")
    str2.length == 3 -> print("字符串 str2 的长度为 3")
}

For

   fun testFor() {
        //循环集合
        var listData = listOf<String>("mike","marry","jonse")
        for (item in listData) println(item)
        //循环一个100次呢
        for (item in 1..100) print("$item ,")
    }

try..catch

   fun testTryCatch() {
        try {
           val i = 5
            val j = 0
            i/j
        }catch (e:Exception) {
            println("我异常了")
        }finally {
            println("我是必须要执行的")
        }
    }

• 和java的亮点不同:
  1.java中如果抛出一个异常,那么调用的地方一定要进行处理,否则报错
  kotlin中是不会报错的,但在运行时可能报错
  2.Kotlin 中 try-catch 语句也可以是一个表达式，允许代码块的最后一行作为返回值：

val a: Int? = try { parseInt(input) } catch (e: NumberFormatException) { null }

?.和?:

   var str: String? = null
    fun testnullsafe() {
       var length:Int? =  str?.length
       var length2:Int =  str?.length?:-1
    }
第二种用法:
fun validate(user: User) {
    val id = user.id ?: return // 👈 验证 user.id 是否为空，为空时 return 
}

== 与 ===

• == ：可以对基本数据类型以及 String 等类型进行内容比较，相当于 Java 中的 equals
• === ：对引用的内存地址进行比较，相当于 Java 中的 ==