溫馨提示
寫博客是為了記錄在開發過程中所涉及到的技術以及遇到的問題的解決，如果該博客對您有所幫助，希望可以點個關注/喜歡；如果您對文章中的內容有什么不同的見解，歡迎留言進行討論。謝謝！
一、基本概念
- 傳入或者返回函數的函數
- 函數引用 ::println
- 帶有 Receiver 的引用 pdfPrinter::println
二、常見高階函數（forEach/map/flatMap）
- forEach : 迭代/遍歷數組/list
//forEach函數使用的一般結構
object.forEach{
//todo
}
例：
val list = listOf(1,3,5,10,18,36,2,9)
list.forEach(::println)
- map : 接受一個lambda表達式，并且有返回值，形成一個新的list
//map函數使用的一般結構
object.map{
//todo
}
例：
val newList = list.map{
it * 2 + 3//相當于返回值
}
val newList2 = list.map(Int::toDouble)
- flatMap : 集合數據進行合并成一個集合
//map函數使用的一般結構
object.flatMap {
it
//todo
}
或
object.flatMap {
it.map {
//todo
}
}
例：
val list = listOf(
1..20,
2..15,
100..166)
val flatList = list.flatMap{
it
}
val flatList = list.flatMap{
it.map{
"No.$it"
}
}
- reduce : 使用reduce對集合進行計算操作
//reduce函數使用的一般結構
object.reduce{acc,i ->
//acc 為累計的結果
//acc todo
}
例：
list.reduce{acc,i -> acc + i}
fun factorial(n: Int):Int{
if(n==0) return 1
return (1..n)reduce{acc,i -> acc * i}
}
//對0-6的數分別求階乘，并且打印出來
(0..6).map(::factorial).forEach(::println)
- fold : 使用fold對集合進行自定義計算
//fold函數使用的一般結構
object.fold([初始值]){acc,i ->
//todo
}
例：
// 對0-6 的階乘進行求和并加上初始值 5
println((0..6).map(::factorial).fold(5){acc,i ->
acc + i
})
//字符串拼接
println((0..6).map(::factorial).fold(StringBuilder()){acc,i ->
acc.append(i).append(",")
})
// 字符串連接
println((0..6).joinToString(","))
- foldRight : 與fold不同的是順序相反
//foldRight函數使用的一般結構
object.foldRight([初始值]){i,acc ->
//todo
}
例：
//字符串拼接
println((0..6).map(::factorial).foldRight(StringBuilder()){i,acc ->
acc.append(i).append(",")
})
- filter : 傳入Lambda 表達式為true是，保留該元素；使用filter對集合進行按條件過濾
//filter函數使用的一般結構
object.filter{
//todo
}
例：
//給一個長度為 n 的數組，每個元素都在 [1,n] 之間，要求找出 [1,n] 中沒有在數組里出現的元素。
fun findDisappearNumbers(nums: IntArray): List<Int> {
val ifAppear = BooleanArray(nums.size + 1)
nums.forEach { ifAppear[it] = true }
return ifAppear.mapIndexed {
index, boolean ->
if (boolean || index == 0) -1 else index
}.filter { it != -1 }
}
- takeWhile : 循環遍歷集合，直到第一個不滿足條件的數據時，停止循環
//takeWhile函數使用的一般結構
object.takeWhile{
//todo
}
- let : let擴展函數的實際上是一個作用域函數，當你需要去定義一個變量在一個特定的作用域范圍內，let函數的是一個不錯的選擇；let函數另一個作用就是可以避免寫一些判斷null的操作。
//let函數使用的一般結構
object.let{
it.todo()//在函數體內使用it替代object對象去訪問其公有的屬性和方法
...
}
//另一種用途 判斷object為null的操作
object?.let{//表示object不為null的條件下，才會去執行let函數體
it.todo()
}
例：
data class Person(val name: String,val age:Int){
fun work(){
println("$name is working!!!")
}
}
fun findPerson():Person?{
return null
}
fun main(args: Array<String>){
findPerson()?.let{person ->
person.work()
println(person.age)
}
}
- apply : apply一般用于一個對象實例初始化的時候，需要對對象中的屬性進行賦值;一般可用于多個擴展函數鏈式調用 ;數據model多層級包裹判空處理的問題
//apply函數使用的一般結構
object.apply{
//todo
}
//例：
//1、
data class Person(val name: String,val age:Int){
fun work(){
println("$name is working!!!")
}
}
fun findPerson():Person?{
return null
}
fun main(args: Array<String>){
findPerson()?.apply{
work()
println(age)
}
}
//2、
mSectionMetaData?.apply{
//mSectionMetaData不為空的時候操作mSectionMetaData
}?.questionnaire?.apply{
//questionnaire不為空的時候操作questionnaire
}?.section?.apply{
//section不為空的時候操作section
}?.sectionArticle?.apply{
//sectionArticle不為空的時候操作sectionArticle
}
- with : 適用于調用同一個類的多個方法時，可以省去類名重復，直接調用類的方法即可
//with函數使用的一般結構
with(object){
//todo
}
例：
val br = Buffered
- run ： run函數是let,with兩個函數結合體，準確來說它彌補了let函數在函數體內必須使用it參數替代對象，在run函數中可以像with函數一樣可以省略，直接訪問實例的公有屬性和方法，另一方面它彌補了with函數傳入對象判空問題，在run函數中可以像let函數一樣做判空處理
//run函數使用的一般結構
object.run{
//todo
}
- also : 適用于let函數的任何場景，also函數和let很像，只是唯一的不同點就是let函數最后的返回值是最后一行的返回值而also函數的返回值是返回當前的這個對象。一般可用于多個擴展函數鏈式調用
//also函數使用的一般結構
object.also{
//todo
}
- use : use函數作用于現實了Closeable接口的類，比如文件io操作
//use函數使用的一般結構
object.use{
//todo
}
例：
var l = BufferedReader(FileReader("123.txt")).use {
var line: String = ""
while (true){
line += it.readLine()?: break
}
line
}
println(l)
三、尾遞歸優化
- 遞歸的一種特殊形式
- 調用自身后無其他操作
- tailrec 關鍵字提示編譯器尾遞歸優化
- 尾遞歸與迭代的關系，尾遞歸一般情況下可以直接轉換為迭代
四、閉包
- 閉包就是函數的運行環境
- 持有函數運行狀態
- 函數內部可以定義函數
- 函數內部也可以定義類
五、函數復合
- 函數復合就是f(g(x))的形式的函數
六、Currying (科理化)
- 就是多元函數變成一元函數調用鏈
fun log(tag:String,target:OutputStream,message:Any?){
target.write("[$tag]: $message\n".toByteArray())
}
fun curriedLog(tag:String):(target:OutputStream) -> (message:Any?){
//todo
}
//fun log(tag:String)
// =fun (target:OutputStream)
// =(message:Any?)
// =target.write("[$tag]: $message\n".toByteArray())
fun<P1,P2,P3,R> Function3<P1,P2,P3,R>.curried()
=fun(p1:P1)=fun(p2:P2)=fun(p3:P3)=this(p1,p2,p3)
fun main(args: Array<String>){
log("Test",System.out,"Hello World！")
// log("Test")(System.out)("Hello World Currying")
::log.curried()("Test")(System.out)("Hello World Currying")
}
七、偏函數
- 傳入部分參數之后得到的新函數就是偏函數
fun log(tag:String,target:OutputStream,message:Any?){
target.write("[$tag]: $message\n".toByteArray())
}
fun<P1,P2,P3,R> Function3<P1,P2,P3,R>.curried()
=fun(p1:P1)=fun(p2:P2)=fun(p3:P3)=this(p1,p2,p3)
fun main(args: Array<String>){
val consoleLog = (::log.cueried())("Test out")(System.out)
consoleLog("Hello 偏函數！")
}
