kotlin vararg 、infix、tailrec

1.官方文档

　　https://kotlinlang.org/docs/functions.html#variable-number-of-arguments-varargs

　　https://www.kotlincn.net/docs/reference/functions.html#%E5%8F%AF%E5%8F%98%E6%95%B0%E9%87%8F%E7%9A%84%E5%8F%82%E6%95%B0varargs

2.vararg

2.1 作用与调用方法

　　kotlin 中的函数支持可变参数，用vararg关键字声明。它生成的实际上是一个同类型的数组参数。在函数内可以数组形式使用它,如下：

fun fun1(vararg numbers : Int){
    val sz = numbers.size
    for (i in 0 until sz){
        Log.e(TAG_VARARG,"fun1 bumber[$i] = ${numbers[i]}")
    }
    for (num in numbers){
        Log.e(TAG_VARARG,"fun1 $num")
    }
}

调用方法，实参个数可以为0

    //1.简单调用
    fun1(1,2,3,4,5)
    fun1()  //变参可以个数为0

使用*加数组名调用

    //2.使用*加数组名调用
    val array = intArrayOf(6,7,8,9,0)
    fun1(*array)

    val array2 = ArrayList<Int>()
    fun1(*array2.toIntArray())

无效的调用

    //3.无效调用
    val array3 = ArrayList<Int>()
    val f1 = 3.14f;
    val i2 = 100
    fun1(*f1) //error ，
    fun1(*i2) //error
    fun1(*array3) //error,ArrayList不是数组 

2.2 可变参数的个数只能是一个

下面是错误的声明，有两个vararg参数

fun fun2(vararg args : Int,vararg args2 : Int){

}

2.3 变参与数组参数的对比

在顶级定义相同类型的变参与数组参数，它们生成的函数签名相同

fun fun3(vararg numbers : Int){
}
fun fun3(numbers : IntArray){
}
class JJJJJJ{
    fun fun33(vararg numbers : Int){
    }
    fun fun33(numbers : IntArray){
    }
}

　　两个fun3冲突，两个fun33也冲突，报错如下：

　　

局部范围内定义相同类型的变参与数组可共存 

//3.2 局部范围内定义相同类型的变参与数组可共存
fun vararg_test3_2(){
    fun fun3(vararg numbers : Int){
        Log.e(TAG_VARARG,"fun3(vararg)  ${numbers[0]}")
    }
    fun fun3(numbers : IntArray){
        Log.e(TAG_VARARG,"fun3(IntArray)  ${numbers[0]}")
    }
    fun fun3(numbers : Array<Int>){
        Log.e(TAG_VARARG,"fun3(Array<Int>)  ${numbers[0]}")
    }
    val array1 = intArrayOf(1,2,3,4)
    val array2 = arrayOf(5,6,7,8)
    fun3(0)　　　　　　　　//调用的是fun3(vararg)
    fun3(array1)        //调用的是fun3(IntArray)
    fun3(array2)        //调用的是fun3(Array<Int>)
}

数组参数只能传数组对象

//3.3 数组参数只能传数组对象
fun vararg_test3_3(){
    fun fun3(numbers : IntArray)  {
    }
    fun fun3(vararg numbers : Int)  {
    }
    val array = intArrayOf(1,2,3)
//    fun3(1,1f)            //error，只能传数组参数
    fun3(array)
    fun3(1)     //可以传类型
}

数组对象可返回，变参不可返回

//3.4 数组对象可返回，变参不可返回
fun fun3_4() : IntArray? = null
//fun fun3_4(a:Int) : (vararg arg : Int)? = null  //error

2.4 可变参数的位置：前，中、后

　　当可变参数不是最后一个时，其它参数要显示指定才可以

//4.可变参数的位置：前，中、后,当可变参数不是最后一个时，其它参数要显示指定才可以
fun fun4(vararg args : Int,name : String,i : Int = 0) = Unit
fun fun4(i : Int = 1,vararg args : Int,name : String) = Unit
fun fun4(name : String,i : Int = 2,vararg args : Int) = Unit

fun vararg_test4(){
    fun4(1,name = "前",i = 99)       //调用第1个
    fun4(1,name = "前")              //调用第1个

    fun4(2,3,name = "中")         　　//调用第2个
    fun4(2,name = "中")              //调用第2个

    fun4(name = "后",i = 10,2,3,4)   //调用第3个
    fun4("后",2,5,6,7)     　　　　　　//调用第3个
}

2.5 lambda的参数不支持可变参数

//5.lambda的参数不支持可变参数
//fun fun5(vararg lambdas : (vararg lmd2 : Int) -> Int)){}   //error
//fun fun5(num : Int, lmd : (vararg lmd2 : Int) -> Int){}　　 //error
fun vararg_test5() = Unit

2.6 可变参数的类型是函数或lamuda表达式

//6.可变参数的类型是函数或lamuda表达式
fun fun6(vararg lambdas : (a : Int,b : Int) -> Int) : Int{
    var total = 0
    for (i in 0 until lambdas.size){
        val lambda = lambdas[i]
        total += lambda(i,10)
    }
    return total
}
fun add(a : Int,b : Int) = a + b
fun vararg_test6(){
    val sum1 = fun6(::add,::add,::add,::add)
    Log.e(TAG_VARARG,"sum1 = $sum1")

    val sum2 = fun6({x,b-> 3 }, ::add,::add)
    Log.e(TAG_VARARG,"sum2 = $sum2")
}

结果

2021-03-15 23:08:42.526 16625-16625/com.example.kotlin E/vararg: sum1 = 46
2021-03-15 23:08:42.527 16625-16625/com.example.kotlin E/vararg: sum2 = 26

2.7 变参与模板

//7.模板
fun<T,U> fun7(u : U,vararg args : T) = Unit
fun vararg_test7(){
    fun7(1,1,2,3,4,)
}

2.8 变参的默认值

变参可以有默认值

//8.变参可以有默认值
fun fun8(vararg args : Float = FloatArray(8)){
    Log.e(TAG_VARARG,"args.size = ${args.size}")
}
fun vararg_test8(){
    fun8()                  //结果 8
    fun8(1f,2f)      　　　　//结果 2
    val floatArray = FloatArray(4,)
    fun8(*floatArray,)      //结果4
}

结果

2021-03-15 23:13:44.615 17263-17263/com.example.kotlin E/vararg: args.size = 8
2021-03-15 23:13:44.615 17263-17263/com.example.kotlin E/vararg: args.size = 2
2021-03-15 23:13:44.615 17263-17263/com.example.kotlin E/vararg: args.size = 4

3.infix

3.1 简介

　　标有 infix 关键字的成员函数或者扩展函数 可以忽略该调用的点和圆括号。如

   infix fun Int.suffix(subfix : String) = "$this-$subfix"

　　可以这个函数的调用可以写成：

　　99 suffix "sss"

　　99 是 Int , suffix是函数， "sss" 是参数

3.2 infix的要求

• 必须是成员函数或扩展函数
• 函数只能有一个参数
• 函数的形参不能是变参
• 函数的形参不能有默认值

  infix fun Int.Max(max : Int = 64) = max  //error

• 在使用infix语法调用时必需指定接收者，如下第8行是个错误。

  //指定接收者
  fun infix_test1_2(){
      class JJJ {
          infix fun prefix(prefix : String) = "$prefix-$this"
          fun test(){
              prefix("EE")     　　    //ok
              this prefix "HHH"       //ok
              //prefix "jjj"          //error
          }
      }
  }

3.3 infix函数的优先级

它的优先级在  ..  之后， 在  ?: 之前，具体如下表：

Precedence	Title	Symbols
Highest	Postfix	++, --, ., ?., ?
	Prefix	-, +, ++, --, !, label
	Type RHS	:, as, as?
	Multiplicative	*, /, %
	Additive	+, -
	Range	..
	Infix function	simpleIdentifier
	Elvis	?:
	Named checks	in, !in, is, !is
	Comparison	<, >, <=, >=
	Equality	==, !==
	Conjunction	&&
	Disjunction	||
	Spread operator	*
Lowest	Assignment	=, +=, -=, *=, /=, %=

示例：

//2.它的优先级在  ..  之后， 在  ?: 之前
fun infix_test2(){

    infix fun Int.suffix(subfix : String) = "$this-$subfix"
    infix fun Int.MAX(max : Int ) = max

    val str1 = 1.suffix("sss")
//    val str2 = "eee" + 2 suffix "aaa"  //error
    val str3 = "eee-" + (3 suffix "aaa")  //ok
    val str4 = null ?: 4 suffix "bbb"
    var str5 = ""
    for (i in 0 until (3 MAX 6)){
        str5 += "$i"
    }

    Log.e(TAG_INFIX,"str1 = $str1")
    Log.e(TAG_INFIX,"str2 = error")
    Log.e(TAG_INFIX,"str3 = $str3")
    Log.e(TAG_INFIX,"str4 = $str4")
    Log.e(TAG_INFIX,"str5 = $str5")
}

结果

2021-03-15 23:28:13.355 17873-17873/com.example.kotlin E/infix: str1 = 1-sss
2021-03-15 23:28:13.355 17873-17873/com.example.kotlin E/infix: str2 = error
2021-03-15 23:28:13.355 17873-17873/com.example.kotlin E/infix: str3 = eee-3-aaa
2021-03-15 23:28:13.355 17873-17873/com.example.kotlin E/infix: str4 = 4-bbb
2021-03-15 23:28:13.355 17873-17873/com.example.kotlin E/infix: str5 = 012345

4.tailrec

4.1 功能

　　在 Kotlin for JVM 与 Kotlin/Native 中支持尾递归，在满足尾递归条件的函数前面加tailrec修饰，编译器会优化该递归成一个快速而高效的基于循环的版本，减少栈消耗。

　　不加tailrec不优化。

4.2 尾递归条件

• 最后一条语句是函数调用语句
• 调用的函数是自身

错误示例1：

fun factorial1(n : Int) : Int{
    return if (n == 1) 1 else n * factorial1(n - 1)
}

　　最后一句代码是 n *  factorial1(n - 1) ，这是个表达式，不是函数调用，虽然这个表达式是包含了一个函数调用。

错误示例2：

tailrec fun btree(root : TreeNode?) {
    if (root?.left != null) {
        btree(root.left)
    }
    println("value = ${root?.value}")
    if (root?.right != null){
        btree(root.right)
        println()
    }
}

　　对自身的调用不是最后一条语句。

4.3 示例 

//2.示例
fun factorial1(n : Int) : Int{
    return if (n == 1) 1 else n * factorial1(n - 1)
}

var ret2 = 1
tailrec fun factorial2(n : Int) : Int {
    if (n <= 1) return 1
    ret2 *= n
    return factorial2(n - 1)
}

var ret3 = 1
fun factorial3(n : Int) : Int {
    if (n <= 1) return 1
    ret3 *= n
    return factorial3(n - 1)
}

fun tailrec_test(){
    var start = SystemClock.elapsedRealtimeNanos()
    val ret1 = factorial1(6)
    var end = SystemClock.elapsedRealtimeNanos()
    Log.e(TAG_TAILREC,"ret1 = $ret1 ,takes ${end - start}")


    start = SystemClock.elapsedRealtimeNanos()
    factorial2(6)
    end = SystemClock.elapsedRealtimeNanos()
    Log.e(TAG_TAILREC,"ret2 = $ret2 ,takes ${end - start}")

    start = SystemClock.elapsedRealtimeNanos()
    factorial3(6)
    end = SystemClock.elapsedRealtimeNanos()
    Log.e(TAG_TAILREC,"ret3 = $ret3 ,takes ${end - start}")

}

结果：

2021-03-16 21:41:16.753 19747-19747/com.example.kotlin E/tailrec: ret1 = 720 ,takes 17810
2021-03-16 21:41:16.753 19747-19747/com.example.kotlin E/tailrec: ret2 = 720 ,takes 16930
2021-03-16 21:41:16.753 19747-19747/com.example.kotlin E/tailrec: ret3 = 720 ,takes 18800

• factorial1 是非尾递归、
• factorial2是尾递归、加了tailrec的，启用优化
• factorial2是尾递归、没加tailrec，未优化

它们的Kotlin ByteCode对比如下：

factorial1

  public final static factorial1(I)I
    // annotable parameter count: 1 (visible)
    // annotable parameter count: 1 (invisible)
   L0
    LINENUMBER 32 L0
    ILOAD 0
    ICONST_1
    IF_ICMPNE L1
    ICONST_1
    GOTO L2
   L1
    ILOAD 0
    ILOAD 0
    ICONST_1
    ISUB
    INVOKESTATIC com/example/kotlin/TailrecKt.factorial1 (I)I
    IMUL
   L2
    IRETURN
   L3
    LOCALVARIABLE n I L0 L3 0
    MAXSTACK = 3
    MAXLOCALS = 1

factorial2

  // access flags 0x19
  public final static factorial2(I)I
    // annotable parameter count: 1 (visible)
    // annotable parameter count: 1 (invisible)
   L0
    LINENUMBER 37 L0
    ILOAD 0
    ICONST_1
    IF_ICMPGT L1
    ICONST_1
    IRETURN
   L1
    LINENUMBER 38 L1
    GETSTATIC com/example/kotlin/TailrecKt.ret2 : I
    ILOAD 0
    IMUL
    PUTSTATIC com/example/kotlin/TailrecKt.ret2 : I
   L2
    LINENUMBER 39 L2
    ILOAD 0
    ICONST_1
    ISUB
    ISTORE 0
    GOTO L0
   L3
    LOCALVARIABLE n I L0 L3 0
    MAXSTACK = 2
    MAXLOCALS = 1

factorial3

  public final static factorial3(I)I
    // annotable parameter count: 1 (visible)
    // annotable parameter count: 1 (invisible)
   L0
    LINENUMBER 44 L0
    ILOAD 0
    ICONST_1
    IF_ICMPGT L1
    ICONST_1
    IRETURN
   L1
    LINENUMBER 45 L1
    GETSTATIC com/example/kotlin/TailrecKt.ret3 : I
    ILOAD 0
    IMUL
    PUTSTATIC com/example/kotlin/TailrecKt.ret3 : I
   L2
    LINENUMBER 46 L2
    ILOAD 0
    ICONST_1
    ISUB
    INVOKESTATIC com/example/kotlin/TailrecKt.factorial3 (I)I
    IRETURN
   L3
    LOCALVARIABLE n I L0 L3 0
    MAXSTACK = 2
    MAXLOCALS = 1