[toc]
前言
這一節我們主要說下Kotlin中關于數據集合中的常用高階函數
map
map是遍歷一個數組遍歷的過程可以對數組item進行操作(篩選、數據轉換等) ,返回一個新的數據集合
例子：
val list = listOf(2, 8, 4, 5, 9, 7)
//Kotlin 寫法 等價于 newList的轉化
val newList1 = list.map {
it * 3 + 2
}
flatmap
就是把幾個小的list轉換到一個大的list中
例子：
val flatList = listOf(
2..10,
5..25,
100..200
)
//flatten() flatMap方法中無其他操作可以用flatten()
val flatMapList = flatList.flatMap { intRange: IntRange ->
intRange
}
嵌套使用：
//上面flatMapList2表達式的完整寫法
val flatMapList3 = flatList.flatMap(fun(intRange: IntRange): List<String> {
return intRange.map(fun(intElement: Int): String {
return "No.$intElement"
})
})
reduce
求list的和、求階乘
求和：
/reduce求list的和 acc是累加的結果 i是每次遍歷出來的元素
val int: Int = list.reduce { acc, i -> acc + i }
求階乘：
//0->0 1->(1*1)*1 2->(1*1)*2 3->(1*2)*3
(0..6).map(::factorial).forEach(::println)
fun factorial(n: Int): Int {
if (n == 0) return 1
//相當于 n=3是 1*1,(1+2)*2,(1+2+3)*3,(1+2+3+4)*4
return (1..n).reduce { acc, i -> acc * i }
}
fold
是帶初始值的reduce 相對更強大，且對返回值無要求
println((0..6).map(::factorial).fold(100) { acc, i -> acc + i })//100+873=973
字符串拼接：
這里傳入的類型初始值是StringBuilder()
println((0..6).map(::factorial).fold(StringBuilder())
{ acc, i -> acc.append(i).append(",") })
joinToString
字符串拼接
println((0..6).joinToString("/", ".", ";"))
filter/takeWhile
根據條件篩選
println((0..6).map(::factorial))
println((0..6).map(::factorial).filter { it % 2 == 1 })
println((0..6).map(::factorial).takeWhile { it < 130 })//遇到第一個不滿足條件的停止輸出
尾遞歸優化
Kotlin 支持一種稱為尾遞歸的函數式編程?格。這允許一些通常用循環寫的算法改用遞歸函數來寫，而無堆棧溢出的?險。當一個函數用tailrec修飾符標記并滿足所需的形式時，編譯器會優化該遞歸，留下一個快速而高效的基于循環的版本。
這是官網的說法。反正我是覺得有些晦澀。我的理解，首先理解什么是尾遞歸。下看下下面的三個例子：
data class TreeNode(val value: Int) {
var left: TreeNode? = null
var right: TreeNode? = null
}
//尾遞歸
tailrec fun findListNode(head: ListNode?, value: Int): ListNode? {
head ?: return null
if (head.value == value) return head
return findListNode(head.next, value)
}
//返回中存在 * 運算 所以是非尾遞歸
fun factorial(n: Long): Long {
return n * factorial(n - 1)
}
//這個也是非 尾遞歸
fun findTreeNode(root: TreeNode?, value: Int): TreeNode? {
root ?: return null
if (root.value == value) return root
return findTreeNode(root.left, value) ?: findTreeNode(root.right, value)
}
調用完自己之后沒有任何操作的遞歸就是尾遞歸尾遞歸優化就是在方法_上加tailrec關鍵地提示編譯器進行優化(將遞歸轉化味迭代進行處理)
若非尾遞歸加上tailrec也會提示(提示黃色警告)。
閉包
在函數為一等公民的語言中，都具有閉包的特性。我的理解就是函數里面聲明函數，函數里面返回函數，這就是閉包。在Java中調用完方法，方法內部的狀態是不會被記住的，但是在Kotlin中，函數的狀態在調用后不會被銷毀。閉包有點像java的內部類，內部類持有外部類的引用，會導致外部類無法釋放，也就是java中的內存泄漏。我個人覺的在Kotlin中閉包也會帶來消耗。
- 函數的運行環境
- 持有函數運行狀態
- 函數內部可以定義函數
- 函數內部也可以定義類
復合函數
本身不是語法上的關鍵字或是格式，是按照以前現有的知識，只不過在編寫上有點難以理解。這個只是函數的復合 沒有新的知識點
結合例子說明：
val add5 = { i: Int -> i + 5 }//g(x)
val multiplyBy2 = { i: Int -> i * 2 }//f(x)
fun main(args: Array<String>) {
println(multiplyBy2(add5(8)))
val add5AndMultiplyBy2 = add5 andThen multiplyBy2 //m(x)=f(g(x)) 2*(8+5)=26
println(add5AndMultiplyBy2(8))
val add5AndMultiplyByCopy = multiplyBy2 andThen add5//m(x)=g(f(x)) 2*8+5=21//前后參數類型相同可以置換位置 否則是不可以的 所以置換后的結果也是不同的
println(add5AndMultiplyByCopy(8))
val add5ComposeThen = add5 compose multiplyBy2
println(add5ComposeThen(8))//m(x)=g(f(x)) 21
val complexFunX = funFx complexFun funGxy
// val complexFunXCopy =funGxy complexFun funFx //這個就不可以 類型參數是要根據條件
println(complexFunX(3, 2))//3*3+50+2=61
}
//m(x)=f(g(x)) add5 andThen multiplyBy2相當于g(x).andThen(f(g(x)))=Function1<P1, P2>.andThen(f(g(x)))
//復合函數 擴展Function1的擴展方法 infix 中綴表達式
//Function1 傳入1個參數的函數 P1 接收的參數類型 P2返回的參數類型
//擴展方法andThen接收 一個參數的函數 他的參數 是add5的返回值 再返回最終結果
//andThen左邊的函數 Function1<P1,P2> 接收一個參數P1 返回結果P2
//andThen右邊的函數 function:Function1<P2,R> 參數為左邊函數的返回值P2 返回結果R
//聚合的結果返回函數Function1<P1,R> 是以P1作為參數 R做為結果的函數
//相當于P1,P2 聚合 P2,R 返回 P1,R
//f(g(x)) P1相當于x P2 相當于g(x)返回值 返回的結果Function1<P1,R> R相當于f(g(x)) 的返回值
//Function1<P1,P2> 相當于g(x)
//function:Function1<P2,R> 相當于x
//
infix fun <P1, P2, R> Function1<P1, P2>.andThen(function: Function1<P2, R>): Function1<P1, R> {
return fun(p1: P1): R {
return function.invoke(this.invoke(p1))
}
}
//compose左邊函數接收參數P2 返回R
//compse右邊函數 接收參數P1 返回P2
//返回結果函數P1,R
//相當于先執行右邊返回了P1,P2 在執行P2,R函數 聚合成P1,R
//g(f(x))
//f(x).compose(g(f(x)))
infix fun <P1, P2, R> Function1<P2, R>.compose(function: Function1<P1, P2>): Function1<P1, R> {
return fun(p1: P1): R {
return this.invoke(function.invoke(p1))
}
}
//課外擴展 m(x,y) = f(g(x,y)
val funFx = { i: Int -> i + 2 }
val funGxy = { i: Int, j: Int -> 3 * i + 100 / j }
//m(x,y) = f(g(x,y))
infix fun <P1, P2, P3, R> Function1<P3, R>.complexFun(function: Function2<P1, P2, P3>): Function2<P1, P2, R> {
return fun(p1: P1, p2: P2): R {
return this.invoke(function.invoke(p1, p2))
}
}
柯里化函數(currying) -函數的鏈式調用
- 柯里化函數就是把多個函數轉話成一個一個參數傳入
- 柯里化就是將具有多個參數的函數，變成多個單個參數的函數，然后鏈式調用。注意調用時參數的順序不能顛倒
個人覺得 柯里化的意義在于：允許調用者分段調用。因為Kotlin是函數為一等公民的語言。那么假設有一個方法需要傳10個參數，可能A模塊傳了2個，然后返回函數，B模塊調用A模塊的方法并將其8個參數補齊，并真正使用。
例子：
//正常下的函數編寫：
fun log1(tag: String, target: OutputStream, message: Any?) {
target.write("[$tag] $message\n".toByteArray())
}
上面函數變化：
//這是另外一種表達方式 與之前的函數表達結果相同
fun log2(tag: String) = fun(target: OutputStream) = fun(message: Any?) = target.write("[$tag] $message\n".toByteArray())
這就是柯里化函數。
再講將新的函數表達抽象就變成柯里化函數
//kotlin中柯里化鏈式調用的含義
fun <P1, P2, P3, R> Function3<P1, P2, P3, R>.curried() = fun(p1: P1) = fun(p2: P2) = fun(p3: P3) = this(p1, p2, p3)
調用：
// ::log1與 { tag: String, target: OutputStream, message: Any? -> log1(tag, target, message) } 是等價的 表示對函數的引用
// { tag: String, target: OutputStream, message: Any? -> log1(tag, target, message) }.curried()("ggxiaozhi")(System.out)("Hello World!")
log1("ggxiaozhi", System.out, "Hello World!")
log2("ggxiaozhi")(System.out)("Hello World!!")
//一個函數的參數復合柯里化版本 那么就可以使用::方法名字 如：::log1 拿到引用使用.curried()方法
::log1.curried()("ggxiaozhi")(System.out)("Hello World!!!")
這里封裝成擴展方法，是為了方便以后調用
偏函數
偏函數其實就是給多個參數的函數設置默認參數，那么再使用的時候只需要傳入部分參數即可。
在上面柯里化函數的例子中，如果默認參數在前面，也可以使用偏函數，如：
val consoleLogWithTag = (::log1.curried())("ggxiaozhi")(System.out)
consoleLogWithTag("Hello World Tag")//偏函數
consoleLogWithTag方法就是一個偏函數。首先經過柯里化后，將第一個參數和第二個參數固定得到consoleLogWithTag一個新的函數。那個這個函數其實就是偏函數
所以偏函數與柯里化函數存在一定的聯系，當柯里化函數最前面的參數想設置默認值的時候可以使用偏函數
下面我們來看下真正的偏函數：
//partial2
val bytes = "我是中國人".toByteArray(charset("GBK"))
val stringFormGBK = makeStringFromGBKBytes(bytes)
println(stringFormGBK)
//partial1
val stringFormGBKP1=makeStringFromGBKBytesp1(charset("GBK"))
println(stringFormGBKP1)
//偏函數 1-3
fun <P1, P2, R> Function2<P1, P2, R>.partial2() = fun(p2: P2) = fun(p1: P1) = this(p1, p2)//第一個參數默認 傳入第二個參數
fun <P1, P2, R> Function2<P1, P2, R>.partial1() = fun(p1: P1) = fun(p2: P2) = this(p1, p2)//第二個參數默認 傳入第一個
完全可以使用默認參數+具名參數的方式來實現參數的固定。如果需要固定的參數在中間，雖然說可以通過具名參數來解決，但是很尷尬，因為必須使用一大堆具名參數。因為默認參數你不傳就用默認參數，但是你傳入了，如果不使用具名參數那么函數就會以為你傳參數的位置是要覆蓋默認參數，所以必須具名函數因此偏函數就誕生了。偏函數就是一個多元函數傳入了部分參數之后的得到的新的函數。
總結：
- 當柯里化后的函數 如果默認函數位置在參數的前面 那么 可以直接使用偏函數
- 如果函數的默認函數在氣其他位置 那么可以使用擴展方法 FunctionN 來實現
結語
下篇我們說下反射和泛型
