lambda、集合、函数

一.lambda

在kotlin中,函数作为一等公民,lambda 是把一小段函数封装成一个匿名函数,以参数的形式传递给函数使用.实际上是一种函数字面量(一眼就能看明白的函数)--目的就是表达简洁.

标准lambda表达式:
val sum:(Int,Int)->Int={x:Int,y:Int->x+y}

语法:

用{} 包裹
在lambda内部已经申明了参数部分的类型,以及返回类型支持推导,lambda变量可以省略函数类型声明;[化简]
val sum={x:Int,y:Int->x+y}
如果lambda变量声明了函数类型,那么lambda的参数部分的类型可以省略.[化简]
val sum:(Int,Int)->Int=(x,y->x+y)
如果lambda 表达式返回的不是Unit,默认最后一行表达式的值类型就是返回类型.

这些简化特征的关键点是推导机制.核心思想是简化,看起来易懂.
因为lambda本质是一个匿名函数,所以在kotlin中,lambda可以直接表示

一个普通变量的具体表达式实现,
val/var xxxx={}
一个函数(lambda函数表达式)
fun foo(int:Int)={
xxxx
}
也可以作为函数的参数.
fun test(a : Int, 参数名 : (参数1 ：类型，参数2 : 类型, ... ) -> 表达式返回类型){
...
}
demo:

1.对于var 的lambda表达式

    var println = { println("logo") }
    var sum0: (Int, Int) -> Int = { x: Int, y: Int -> x + y }
    var sum1 = { x: Int, y: Int -> x + y }
    var sum2: (Int, Int) -> Int = { x, y -> x + y }

通过decompile 得到的java文件

   @NotNull
   private Function0 println;
   @NotNull
   private Function2 sum0;
   @NotNull
   private Function2 sum1;
   @NotNull
   private Function2 sum2;

   @NotNull
   public final Function0 getPrintln() {
      return this.println;
   }

   public final void setPrintln(@NotNull Function0 var1) {
      Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
      this.println = var1;
   }

   @NotNull
   public final Function2 getSum0() {
      return this.sum0;
   }

   public final void setSum0(@NotNull Function2 var1) {
      Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
      this.sum0 = var1;
   }

   @NotNull
   public final Function2 getSum1() {
      return this.sum1;
   }

   public final void setSum1(@NotNull Function2 var1) {
      Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
      this.sum1 = var1;
   }

   @NotNull
   public final Function2 getSum2() {
      return this.sum2;
   }

   public final void setSum2(@NotNull Function2 var1) {
      Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
      this.sum2 = var1;
   }

说明在转成java文件之后,lambda表达式已经被表示成一个函数,其中Function0 表示无参函数,Function2表示带两个参数的函数.

package kotlin.jvm.functions

/** A function that takes 0 arguments. */
public interface Function0<out R> : Function<R> {
    /** Invokes the function. */
    public operator fun invoke(): R
}
/** A function that takes 1 argument. */
public interface Function1<in P1, out R> : Function<R> {
    /** Invokes the function with the specified argument. */
    public operator fun invoke(p1: P1): R
}

2.对于fun lambda函数

fun sum3(x: Int, y: Int) = { x + y }

decompile

 @NotNull
   public final Function0 sum3(final int x, final int y) {
      return (Function0)(new Function0() {
         // $FF: synthetic method
         // $FF: bridge method
         public Object invoke() {
            return this.invoke();
         }

         public final int invoke() {
            return x + y;
         }
      });
   }

在匿名函数体,Lambda(以及局部函数,object表达式)在语法中都存在"{}",这个{}内部的代码如果访问了外部变量则称为一个闭包.闭包可以当参数传递或直接使用,可以简单看成"访问外部环境变量的函数

3.带参数的Lambda

public class LambdaExpression {
  //带接受者的Lambda
    val sum1: Int.(Int) -> Int = { other -> plus(other) }
    var minu: Int.(Int) -> Int = { other -> minus(other) }
  //扩展函数
    fun Int.mix(value: Int): Unit {
        println(this.toString() + value.toString())
    }

    fun test() {
        sum1(10, 10)
        10.sum1(10)
        10.minu(9)
        10.mix(90)
    }
}

Decompile

public final class LambdaExpression {
   @NotNull
   private final Function2 sum1;
   @NotNull
   private Function2 minu;

   @NotNull
   public final Function2 getSum1() {
      return this.sum1;
   }

   @NotNull
   public final Function2 getMinu() {
      return this.minu;
   }

   public final void setMinu(@NotNull Function2 var1) {
      Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
      this.minu = var1;
   }

   public final void mix(int $this$mix, int value) {
      String var3 = $this$mix + String.valueOf(value);
      System.out.println(var3);
   }

   public final void test() {
      this.sum1.invoke(10, 10);
      this.sum1.invoke(10, 10);
      this.minu.invoke(10, 9);
      this.mix(10, 90);
   }

   public LambdaExpression() {
      this.sum1 = (Function2)null.INSTANCE;
      this.minu = (Function2)null.INSTANCE;
   }
}
// LambdaExpressionKt.java

4.类型安全的构建器与Anko Layouts DSL

先放一个anko 的demo吧

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val lambdaTest = LambdaTest()
        lambdaTest.test()
        setContentView(myLayout())
    }

    fun myLayout(): View {
        return linearLayout {
           val btn= button {
                setText("click")
                onClick {
                    toast("clickd Me")
                }
            }
        }
    }
}

image.png

实际上linearLayout 这段就是类型安全的构建器.这种也可以看做是DSL 在"局部领域的专有写法",可以写出
类似flutter 现代化的布局.好处:代码简化,用{} 包裹内部的元素,使用方便,层次分明. 缺点:对于习惯了xml 布局的刚开始会觉得不太适应,嵌套看上去会较多({}).

原理:

image.png

正是使用到函数当做参数的特性,使得把容器的构造固定,然后可以动态的往里面添加不同的控件(填充作为参数的函数).
看下源码:

inline fun Activity.linearLayout(init: (@AnkoViewDslMarker _LinearLayout).() -> Unit): android.widget.LinearLayout {
    return ankoView(`$$Anko$Factories$Sdk27ViewGroup`.LINEAR_LAYOUT, theme = 0) { init() }
}

二、集合高阶函数api 实现

fold
flatten
map
flatmap

惰性集合

这是函数式思想里面的一个 "惰性求值"的应用.(表达式不在它被绑定到变量之后就立即求值，而是在该值被取用的时候求值)

解决普通操作处理很多元素低效的问

惰性求值--表示一种在需要时才进行求值计算方式。不在被绑定的时候立即求值，而是在该值被取用时才求值。可以构造出一个无限的数据类型

序列 asSequence
中间操作
末端操作
无穷队列

demo 比较

val mylist = listOf(1, 2, 3, 4, 5, 6, 7, 8)
//1. 一般的集合
fun listTest() {
    println("---------list------")
    mylist.filter {
        println("filter${it}")
        it > 2
    }.map {
        println("map${it}")
        it * 2
    }
    print('\n')
}

// 2. 中间操作
fun lazyTest() {
    println("---------lazy list------")
    mylist.asSequence().filter {
        println("filter${it}")
        it > 2
    }.map {
        println("map${it}")
        it * 2
    }
    print('\n')
}

// 3.末端操作
fun lazyLastTest() {
    println("---------lazyLast list------")
    mylist.asSequence().filter {
        println("filter${it}")
        it > 2
    }.map {
        println("map${it}")
        it * 2
    }.toList()
    print('\n')
}
//输出结果
---------list------
filter1
filter2
filter3
filter4
filter5
filter6
filter7
filter8
map3
map4
map5
map6
map7
map8

---------lazy list------

---------lazyLast list------
filter1
filter2
filter3
map3
filter4
map4
filter5
map5
filter6
map6
filter7
map7
filter8
map8

image.png

为什么会出现3种不同的结果?

decompile下看看编译成的java 文件

@NotNull
   private static final List mylist = CollectionsKt.listOf(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8});

   @NotNull
   public static final List getMylist() {
      return mylist;
   }

   public static final void listTest() {
      String var0 = "---------list------";
      System.out.println(var0);
      Iterable $receiver$iv = (Iterable)mylist;
      Collection destination$iv$iv = (Collection)(new ArrayList());
      Iterator var3 = $receiver$iv.iterator();

      Object item$iv$iv;
      int it;
      boolean var6;
      String var7;
      while(var3.hasNext()) {
         item$iv$iv = var3.next();
         it = ((Number)item$iv$iv).intValue();
         var6 = false;
         var7 = "filter" + it;
         System.out.println(var7);
         if (it > 3) {
            destination$iv$iv.add(item$iv$iv);
         }
      }

      $receiver$iv = (Iterable)((List)destination$iv$iv);
      destination$iv$iv = (Collection)(new ArrayList(CollectionsKt.collectionSizeOrDefault($receiver$iv, 10)));
      var3 = $receiver$iv.iterator();

      while(var3.hasNext()) {
         item$iv$iv = var3.next();
         it = ((Number)item$iv$iv).intValue();
         var6 = false;
         var7 = "map" + it;
         System.out.println(var7);
         Integer var11 = it * 2;
         destination$iv$iv.add(var11);
      }

      List var10000 = (List)destination$iv$iv;
      char var13 = '\n';
      System.out.print(var13);
   }

   public static final void lazyTest() {
      String var0 = "---------lazy list------";
      System.out.println(var0);
      SequencesKt.map(SequencesKt.filter(CollectionsKt.asSequence((Iterable)mylist), (Function1)null.INSTANCE), (Function1)null.INSTANCE);
      char var1 = '\n';
      System.out.print(var1);
   }

   public static final void lazyLastTest() {
      String var0 = "---------lazyLast list------";
      System.out.println(var0);
      SequencesKt.toList(SequencesKt.map(SequencesKt.filter(CollectionsKt.asSequence((Iterable)mylist), (Function1)null.INSTANCE), (Function1)null.INSTANCE));
      char var1 = '\n';
      System.out.print(var1);
   }

1.原来普通list的filter,map 两个步骤是分开依次执行,首先filter会遍历所有的列表元素,重新生成一个过滤列表;再已过滤列表为输入源进行map.
2.对于list序列化的.
SequencesKt.map(SequencesKt.filter(CollectionsKt.asSequence((Iterable)mylist), (Function1)null.INSTANCE), (Function1)null.INSTANCE);
这个函数差分成3部分分析:
val collectionSequence=CollectionsKt.asSequence((Iterable)this.mylist)
val mapSequence =SequencesKt.filter(collectionSequence, (Function1)null.INSTANCE)
val filterSequence=SequencesKt.map(mapSequence, (Function1)null.INSTANCE)

Sequence的UML图

image.png

可以看到FilteringSequence,TransformingSequence,FlatteningSequence,MergingSequence 分别对应Sequence的filter{},map{},flatMap{},zip{} 等操作,这些属于Sequence不同的状态,每个操作对应返回相应的状态.也就是说这里使用了中的状态模式实现的.
前面几步是不会进行计算的,因为只是返回一个Sequence,而Sequence实际上是一个包含迭代器的接口.直到触发toList() 函数时,会执行 iterator的迭代器 forEach函数.最终执行序列的每个iterator的迭代方法,把执行的结果加入到ArrayList中.
如下面代码所示

public fun <T> Sequence<T>.toList(): List<T> {
    return this.toMutableList().optimizeReadOnlyList()
}

public fun <T> Sequence<T>.toMutableList(): MutableList<T> {
    return toCollection(ArrayList<T>())
}

public fun <T, C : MutableCollection<in T>> Sequence<T>.toCollection(destination: C): C {
    for (item in this) {
        destination.add(item)
    }
    return destination
}

这里也就解释了Sequence的惰性求值的原理

二、函数式编程

狭义理解：只通过纯函数进行编程，不允许有副作用。给定同样的输入，会有相同的输出。非常适合推理。劣势：绝对的副作用，所有的数据结构都是不可变。
广义理解：“任何以函数为中心进行编程”的语言都可称函数式编程。

常见的函数式语言特征：

函数是头等公民
方便的闭包语法
递归式的构造列表
科里化函数
惰性求值
模式匹配
尾递归优化
范型能力，高阶类型
Typeclass
类型推导

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 156,757评论 4赞 359
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 66,478评论 1赞 289
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 106,540评论 0赞 237
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 43,593评论 0赞 203
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 51,903评论 3赞 285
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 40,329评论 1赞 210
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 31,659评论 2赞 309
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 30,383评论 0赞 195
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 34,055评论 1赞 238
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 30,337评论 2赞 241
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 31,864评论 1赞 256
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 28,227评论 2赞 251
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 32,820评论 3赞 231
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 25,999评论 0赞 8
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 26,750评论 0赞 192
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 35,365评论 2赞 269
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 35,260评论 2赞 258

lambda、集合、函数

一.lambda

1.对于var 的lambda表达式

2.对于fun lambda函数

3.带参数的Lambda

4.类型安全的构建器 与Anko Layouts DSL

二、集合高阶函数api 实现

惰性集合

二、函数式编程

推荐阅读更多精彩内容

4.类型安全的构建器与Anko Layouts DSL