1,高阶函数
定义
- 函数的参数类型包含函数或者返回值为函数类型
- 如果函数的参数只有一个参数或者最后一个参数为一个lambda表达式则可以把该函数提取到"()"外部,如果该函数没有其他的参数可以把"()"省略
如下例中三个形式不同,意义相同
IntArray(5) {
it
}.forEach({ele: Int ->
ele + 1
})
IntArray(5) {
it
}.forEach(){ele: Int ->
ele + 1
}
IntArray(5) {
it
}.forEach{ ele: Int ->
ele + 1
}
这里有关lambda表达式有几点需要注意
lambda表达式的类型推导有个顺序，实际上lambda最后一行不管表达式的值的类型是什么，我们都可以把他的返回类型声明为Unit，当然你不声明的话就像你说的是返回表达式的类型也就是Int了。这里foreach的参数类型是确定的，等于为参数的lambda表达式声明了类型必须为int->unit。
val func = { ele: Int ->
ele + 1
}
这个func 相当于已经声明了是 Int-> Int 所以不能再传入foreach中,
{ ele: Int ->
ele + 1
}
没有变量接收,所以可以被foreach声明为int ->Unit
接下来写个例子
1,写个求函数运行时长的函数
fun cast(func: () -> Unit) {
val start = System.currentTimeMillis();
func()
println(System.currentTimeMillis() - start)
}
2,写一个求斐波那契数的函数
fun fibonacci(): () -> Long {
var first = 0L
var second = 1L
return {
val next = first + second
val current = first
first = second
second = next
current
}
}
3,求出得到前10个斐波那契数所需时间
cast {
val funcc= fibonacci()
for (i in 1..10){
println(funcc())
}
}
2,内联函数
定义
- 内联函数:就是把函数的参数直接挪到函数体内进行执行
- 一个普通的函数 加上"inline" 即可定义为内联函数
- 高阶函数更适合做内联函数,因为本身高阶函数会再次调用或返回函数,
- 好处,减少了函数的调用,节省性能的开销
fun main() {
castTime {
println("HelloWord")
}
}
inline fun castTime(func: () -> Unit) {
val startTime = System.currentTimeMillis()
func()
// 编译器在编译时相当于把函数体挪到这个位置
//println("HelloWord")
println(System.currentTimeMillis() - startTime)
}
高阶函数的内联
- 函数本身被内联到调用处
- 函数的函数参数被内联到调用处
内联高阶函数的return
示例
val arrays = arrayOf(1, 2, 3, 4)
arrays.forEach {
if (it == 3) return@forEach
println("---------$it---------")
}
结果
---------1---------
---------2---------
---------4---------
内联函数无法像Java中那样通过break结束本次遍历,只能通过标签,跳出本次内联函数的调用
在lambda表达式中直接return的写法也叫local return,与之相对应的 如果在lambda表达式外部调用的 叫 non-local return ;
其实简单理解就是带内联函数标签的中断叫localreturn ;不带内联函数标签的中断叫non-local return
non-local return 返回的是主调用函数,直接中断内联函数的调用
例子:该次return 直接返回到main函数,之后的也不再执行
fun main() {
val arrays = arrayOf(1, 2, 3, 4)
arrays.forEach {
if (it == 3) return
println("---------$it---------")
}
println("------------------")
}
并不是所以有得内联函数都可以进行non-local return
crossline关键字
例如:由于block定义和调用处于不同的上下文,此时编译器不会通过,除非加上crossline 关键字表示 block 肯定不会出现non-local return,这样才行
inline fun runnable(crossinline block:()->Unit):Runnable{
return object :Runnable{
override fun run(){
block()
}
}
}
内联属性
内联函数的限制
3,几个有用的函数
具体用法:
class Person(var name: String, var age: Int, var sex: Boolean) {
}
fun main() {
val person = Person("WJF", 25, true)
println("${person.name}-${person.age}-${person.sex}")
person.let {
it.name = "11111"
it.age = 1
it.sex = false
}
person.run {
name = "22222"
age = 2
sex = false
}
println("${person.name}-${person.age}-${person.sex}")
var person2 = person.also {
it.name = "33333"
it.age = 3
it.sex = true
}
println("${person.name}-${person.age}-${person.sex}")
var person3 = person.apply {
name = "44444"
age = 4
sex = false
}
println("${person.name}-${person.age}-${person.sex}")
println("${person2 == person3}")
println("${person2 === person3}")
}
运行结果
WJF-25-true
22222-2-false
33333-3-true
44444-4-false
true
true
结果我们得出结论
- 可以看出其实let()和run()只有内部引用不同,同样都没有返回值
- also()和apply()只有内部引用不同,同时返回了Person对象,但是这个对象都是原始的person 只是属性变了引用没变
user 的使用
将读出build.gradle文件的每一行内容并打印出来
File("build.gradle").inputStream().reader().buffered()
.use {
val readLines = it.readLines()
readLines.forEach { ele: String ->
println(ele)
}
}
4,集合变换与序列
<1>集合的变换
- filter :保留满足条件的元素
- map :集合中的所有元素一 一映射到其他元素结构新集合
- floatMap : 集合中所有的元素一 一映射到新集合并合并这些集合得到新的集合
个人理解
1,filter就是过滤元素形成新的集合
2,map就是针对当前集合对其元素进行变换,之后组成新的集合
3,floatMap 就是对集合中的每个元素进行操作形成n个新的集合 并且将他们组合在一起
举例
fun main() {
val arr = arrayOf(1, 2, 3, 4, 5)
arr.asSequence()
.filter {
println("filter${it}")
it % 2 == 0
}.forEach {
println("$it")
}
//filter就是过滤元素
arr.filter {
println("filter${it}")
it % 2 == 0
}.forEach {
println("$it")
}
//map就是针对当前集合对其元素进行变换,形成新的集合
arr.map {
"$it"
}.forEach {
println(it)
}
//floatMap 就是对集合中的每个元素进行操作形成n个新的集合 并且将他们组合在一起
arr.flatMap {
(1..it)
}.forEach {
println(it)
}
// arr.asSequence()
// .flatMap {
// (1..it).asSequence()
// }.forEach {
// println(it)
// }
}
asSequence() 是数据流的意思,相当于数据流的"懒加载",像上个例子中,如果加上asSequence()在没有出口(例如forEach)的时候是不会执行的,而且执行顺序 变成集合中数据一个一个的网下执行,不是统一变换后在执行下一步
例如
val arr = arrayOf(1, 2, 3, 4, 5)
arr.filter {
println("filter${it}")
it % 2 == 0
}.forEach {
println("$it")
}
执行结果为
filter1
filter2
filter3
filter4
filter5
2
4
在加上.asSequence()之后
val arr = arrayOf(1, 2, 3, 4, 5)
arr.asSequence()
.filter {
println("filter${it}")
it % 2 == 0
}.forEach {
println("$it")
}
执行结果为
filter1
filter2
2
filter3
filter4
4
filter5
<2>集合的聚合操作
聚合操作其实就需要将集合里的元素进行运算
- sum : 集合所有元素求和
- reduce : 将元素依次按规则聚合,结果与元素类型一致
- fold : 给定初始化值,将元素按规则聚合,结果与初始化值类型相同
例子
val arr = arrayOf(1, 2, 3, 4)
val arrStr = arrayOf("11", "21", "31", "14")
//sum操作符
println(arr.sum())
//reduce操作符
val count = arr.reduce { acc, i ->
acc + i
}
println(count)
//fold操作
arr.fold(StringBuilder()) { acc, i ->
acc.append(i)
}.forEach {
println(it)
}
//fold操作
arr.fold("") { acc, i ->
"$acc$i"
}.forEach {
println(it)
}
//zip变换
arr.zip(arrStr).forEach {
println("${it.first}--${it.second}")
}
5,SAM转换
Java的lambda表达式没有自己的类型,必须有一个接口来接收它,而且这个接口必须是单一方法,实际上Java中的lambda的类型就是"单一方法的接口类型" ,也可以是Kotlin的接口进行接收
Kotlin中的匿名内部类
写法
object:接口名称{
方法(){
xxxxxx
}
}
对于Kotlin调用Java的匿名内部类时,如果写成lambda形式,Kotlin自动会把lambda转换成匿名内部类的形式
坑!!!!!!!!!!!
对于Kotlin调用Java代码时有些需要添加和移除listener的,不能再用lambda表达式了,因为移除的不是同一个对象
正确操作
定义一个Java类
public class EventManager {
private HashSet hashSet=new HashSet<>();
public interface OnEventListener {
public void onEvent(int i);
}
public void addEventListener(OnEventListener eventListener){
hashSet.add(eventListener);
}
public void removeEventListener(OnEventListener eventListener){
hashSet.remove(eventListener);
}
}
正确调用
val manager=EventManager()
//使用匿名内部类的形式先定义出具体对象
val onEvent=EventManager.OnEventListener {
println(it)
}
//添加该对象
manager.addEventListener(onEvent)
//移除该对象
manager.removeEventListener(onEvent)
小案例:读取项目的build.gradle文件的每个字符出现的次数
//读取build.gradle文件各个字符出现的次数
File("build.gradle")
.readText()//文件到String
.toCharArray()//变成字符数组
.filter { !it.isWhitespace() }//过滤空白字符
.groupBy { it }//以每个字符为分组依据进行分组
.map {
it.key to it.value.size//拿到每个字符对应的size
}.let {
println(it)//输出
}