lambda、集合、函数

作者: 浩林Leon | 来源:发表于2019-11-26 21:16 被阅读0次

一.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
类型推导

lambda、集合、函数

一.lambda

1.对于var 的lambda表达式

2.对于fun lambda函数

3.带参数的Lambda

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

二、集合高阶函数api 实现

惰性集合

二、函数式编程

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

lambda、集合、函数

一.lambda

1.对于var 的lambda表达式

2.对于fun lambda函数

3.带参数的Lambda

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

二、集合高阶函数api 实现

惰性集合

二、函数式编程

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

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