kotlin中lambda表达式

1、Lambda表达式语法

{ x : int ,y:Int  ->   x+y  }
其中 箭头 -> 前的部分是参数，箭头后面是函数体
kotlin中lambda表达式始终用花括号包围，注意参数部分没有用括号括起来，箭头可以把实参列表和lambda的函数体隔开

可以把lambda的表达式存储到一个变量中，把这个变量当做普通函数对待，

val sum ={ x: Int,y :Int  -> x+y }
priint(sum(1+2)  
可以调用保存在变量中的lambda表达式

我们看下下面这个例子

people.maxby({ p:Person -> p.age} )
花括号中的代码是lambda表达式，他做为实参传递给maxby()函数。
lambda是可以进行改进的
people.maxBy(){p : Pserson -> p.age)}
kotlin中有这种一个语法 ,如果lambda表达式是函数调用的最后一个实参，它可以放在括号外面，
再次改进
people.maxBy{p : Pserson -> p.age)}
当lambda是唯一的实参时候，可以去掉代码中的空括号对

1. 1在作用域内访问变量

fun priMessage(message : Collection<String> ,prefix :String){
      message.forEach{ 
          print("$prefix &it)          
          }
}
//例子中的forEach()作用是对每一个元素都执行lambda操作，可以看到，它可以访问函数中的参数，也可访问函数中的变量

和java不同。kotlin中允许在lambda内部访问非final变量甚至修改他们，从lambda内访问外部变量。我们称这些变量诶lambda捕捉，当你捕获final变量时候，它的值和使用这个值得lambda代码一起存储，而对非final变量是，他的值被封装在一个特殊的包容器中，就可以改变这个值，

捕捉可变变量：实现细节
java只运允许捕获final变量。当你想捕获可变变量的时候，可以使用两种技巧，要么声明一个单元素数据，其中存储可变值，要么创建一个包装类的实例，其中存储要改变值的引用

1.2成员引用

java8 和kotlin一样，如果把函数转换成一个值，使用 :: 运算符来转换

val getAge =Person :: age                                                                                                              

这种表达式被称为成员引用，它提供简明语法来创建一个调用单个方法或者访问单个属性的函数值， :: 双冒号把类名称与你要引用的成员一个方法或者一个属性名称隔开

Person :: age   Person是类，age是成员

注意，不管引用的是函数还是属性，都不要在成员引用的名称后面加括号。成员引用和引用该函数的lambda具有一样的类型，可以互相调用:

people.maxBy(Person ::age)

引用顶层函数：

fun saluter() =printIn("saluter")
run(::salute)
输出 saluter

2 集合的函数式编程

2.1 filter和map

fliter函数遍历集合并选出要给定lambda后会返回true的那些元素

val list =listOf(1,2,3,4)
print(list.filter{it%2==0})

输出[2,4]

fliter函数可以从集合中移除你不想要的元素，但是他并不会改变这些元素。元素的变换是map的用武之地。

map函数对集合中的每一个元素应用给定的函数，并把结果收集到一个新的集合，

val list=listOf(1,2,3,4)
println(list.map{it*it})
[1,3,7,16]

注意是新的集合
键和值分别有各组的函数来处理，filterKeys和mapkeys过滤和变换键，而filterValus和mapValus 过滤和变换相应的值。

2.2 “all”,“any”,“count”,“find”:对集合应用判断式

kotlin中，他们是通过all和any函数表达集合中的所有元素是否都符合某个条件。find函数返回第一个符合条件的元素。

1. 是否所有元素都满足判断式用all
2. !all 不是所有添加都满足
3. any 可以替换 !all 表示不是所有
4. count 表示满足某个条件的数量
5. find表示其中一个元素
6. find 如果有多个匹配元素就返回其中一个元素，或者返回null 如果没有一个元素能满足判断式，还有同义的方法，findorNull

groupBy：把列表转换成分组map

val people =listOf(Person("Alice",31),Person("bob",29),Person("Carol",31）)
println( people.groupBy{it.age})
输出
{29=[Person(name=Bob,age=29)],
31=[Person(name=Alice,age=31),Person(name=Carol,age=31)]
}

flatMap和flatten:处理嵌套集合中的元素

flatMap做两件事 首先根据实参给定的函数对集合中的每个元素做变换，然后把多个列表合并成一个列表

val string=listOf（"abc","def"）
print(String.fltMap{it,toList()})
输出 [a,b,c,d,e,f]

flatten只是平铺不需要变换，

惰性集合操作:序列

people.asSequence().map(Person::name).filter{it.startWith("A")}

在kotlin中fliter和map都会返回一个列表，这意味着链子调用会创建两个列表，一个保存filter函数结果，一个保存map函数结果，
如过有一百万个元素，调用会变得低效。

people.asSequence().map(Person::name).fliter{ it.startWith("A")}.tolist()//tolist把结果转换为列表

kotlin中集合操作的入口就是Sequence接口，这个接口表示的就是一个可以逐个列举元素的序列，Sequence只提供一个方法 iterator用来从序列中获取值。因为是惰性的可以更高效的对集合元素执行链式操作，asSequence吧任意集合转化成序列，tolist来反向转换

"with"函数

在很多语句中会对同一个对象多次操作，而不需要吧对象名称写出来，

fun alphabet():String{
val result=StringBuilder()
for (letter in 'A'.....'z'){
  result.append(letter)
}
result.append("\n Now I know this alphabet")
return result.toString
}

没错都会调用result这个对象
如果使用with

fun alphabet():String{
val stringBuilder=StringBuild()
		return with(stringBuukder){
  				for (letter in 'A'.....'z'){ 
                  this.append(letter)
             }
             append("sssssssssssssss")
           this.toString()
    }
}

with()返回值是执行lambda代码的结果，该结果就是执行lambda中最后一个表达式的值，如果想返回的是接受着对象而不是lambda的结果，这个时候apply函数就用到了。

"apply"函数

apply函数几乎和with函数一模一样。唯一的区别是apply函数始终会返回作为实参传递给他的对象(接收者对象)

fun alphabet =StringBuilder().apply{
for (letter in 'A'...'Z'){
  append(letter)
}
append("fdfffa")
}.toString()

apply被声明扩展参数，他的接受者变成了作为实参的lanbda的接受者，执行的apply的介绍过是StringBuilder，所以可以调用toString把他转换为string