lambda、集合、函數(shù)

一.lambda

在kotlin中,函數(shù)作為一等公民,lambda 是把一小段函數(shù)封裝成一個匿名函數(shù),以參數(shù)的形式傳遞給函數(shù)使用.實際上是一種函數(shù)字面量(一眼就能看明白的函數(shù))--目的就是表達簡潔.

標準lambda表達式:
val sum:(Int,Int)->Int={x:Int,y:Int->x+y}

語法:

  • 用{} 包裹
  • 在lambda內(nèi)部已經(jīng)申明了參數(shù)部分的類型,以及返回類型支持推導,lambda變量可以省略函數(shù)類型聲明;[化簡]
    val sum={x:Int,y:Int->x+y}
  • 如果lambda變量聲明了函數(shù)類型,那么lambda的參數(shù)部分的類型可以省略.[化簡]
    val sum:(Int,Int)->Int=(x,y->x+y)
  • 如果lambda 表達式返回的不是Unit,默認最后一行表達式的值類型就是返回類型.

這些簡化特征的關鍵點是推導機制.核心思想是簡化,看起來易懂.
因為lambda本質(zhì)是一個匿名函數(shù),所以在kotlin中,lambda可以直接表示

  • 一個普通變量的具體表達式實現(xiàn),
    val/var xxxx={}
  • 一個函數(shù)(lambda函數(shù)表達式)
    fun foo(int:Int)={
    xxxx
    }
  • 也可以作為函數(shù)的參數(shù).
    fun test(a : Int, 參數(shù)名 : (參數(shù)1 ： 類型，參數(shù)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;
   }

說明在轉(zhuǎn)成java文件之后,lambda表達式已經(jīng)被表示成一個函數(shù),其中Function0 表示無參函數(shù),Function2表示帶兩個參數(shù)的函數(shù).

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函數(shù)
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;
         }
      });
   }

在匿名函數(shù)體,Lambda(以及局部函數(shù),object表達式)在語法中都存在"{}",這個{}內(nèi)部的代碼如果訪問了外部變量則稱為一個閉包.閉包可以當參數(shù)傳遞或直接使用,可以簡單看成"訪問外部環(huán)境變量的函數(shù)

3.帶參數(shù)的Lambda
public class LambdaExpression {
  //帶接受者的Lambda
    val sum1: Int.(Int) -> Int = { other -> plus(other) }
    var minu: Int.(Int) -> Int = { other -> minus(other) }
  //擴展函數(shù)
    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 現(xiàn)代化的布局.好處:代碼簡化,用{} 包裹內(nèi)部的元素,使用方便,層次分明. 缺點:對于習慣了xml 布局的剛開始會覺得不太適應,嵌套看上去會較多({}).

原理:


image.png

正是使用到函數(shù)當做參數(shù)的特性,使得把容器的構造固定,然后可以動態(tài)的往里面添加不同的控件(填充作為參數(shù)的函數(shù)).
看下源碼:

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

二、集合高階函數(shù)api 實現(xiàn)

  • fold
  • flatten
  • map
  • flatmap

惰性集合

這是函數(shù)式思想里面的一個 "惰性求值"的應用.(表達式不在它被綁定到變量之后就立即求值，而是在該值被取用的時候求值)

解決普通操作處理很多元素低效的問

惰性求值--表示一種在需要時才進行求值計算方式。不在被綁定的時候立即求值，而是在該值被取用時才求值?？梢詷嬙斐鲆粋€無限的數(shù)據(jù)類型

  • 序列 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

為什么會出現(xiàn)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 兩個步驟是分開依次執(zhí)行,首先filter會遍歷所有的列表元素,重新生成一個過濾列表;再已過濾列表為輸入源進行map.
2.對于list序列化的.
SequencesKt.map(SequencesKt.filter(CollectionsKt.asSequence((Iterable)mylist), (Function1)null.INSTANCE), (Function1)null.INSTANCE);
這個函數(shù)差分成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不同的狀態(tài),每個操作對應返回相應的狀態(tài).也就是說這里使用了中的狀態(tài)模式實現(xiàn)的.
前面幾步是不會進行計算的,因為只是返回一個Sequence,而Sequence實際上是一個包含迭代器的接口.直到觸發(fā)toList() 函數(shù)時,會執(zhí)行 iterator的 迭代器 forEach函數(shù).最終執(zhí)行序列的每個iterator的迭代方法,把執(zhí)行的結果加入到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的惰性求值的原理

二、函數(shù)式編程

狹義理解：只通過純函數(shù)進行編程，不允許有副作用。給定同樣的輸入，會有相同的輸出。非常適合推理。劣勢：絕對的副作用，所有的數(shù)據(jù)結構都是不可變。
廣義理解：“任何以函數(shù)為中心進行編程”的語言都可稱函數(shù)式編程。

常見的函數(shù)式語言特征：

  • 函數(shù)是頭等公民
  • 方便的閉包語法
  • 遞歸式的構造列表
  • 科里化函數(shù)
  • 惰性求值
  • 模式匹配
  • 尾遞歸優(yōu)化
  • 范型能力，高階類型
  • Typeclass
  • 類型推導
?著作權歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

相關閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容