Kotlin 学习笔记（十二）kotlin中集合序列使用、操作符汇总、list和sequence比较

MilkyWayLadakh_ZH-CN7734727282_1920x1080.jpg

前言
本篇博客为本人学习Kotlin 中所遇到的问题，如果哪里写的不对，希望欧大佬帮忙指出，多谢。

1. 集合的基础使用

kotlin 中的集合主要为：Array、List、Set、Map ， Sequence

1.1 数组

val arr = arrayOf("1",2,3,4)

1.2 List

不可变集合 ( listOf() )

val arr = arrayOf("1","2",3,4,5)   
val list1 = listOf(1,2,"3",4,"5")                // 随意创建         
val list2 = listOf("1","2","3","4","5")  // 确定元素的值类型
val list3 = listOf(arr)                          // 可传入一个数组

以下代码是错误的。因为List只能是不可变集合。而add、remove、clear等函数时MutableList中的函数
list1.add() 
list1.remove

可变集合 ( mutableListOf )

val arr = arrayOf("1","2",3,4)
val mutableList1 = mutableListOf(1,2,3,4,"5")                // 随意创建         
val mutableList2 = mutableListOf("1","2","3","4","5")  // 确定元素的值类型
val mutableList3 = mutableListOf(arr)                          // 可传入一个数组
val mutableList : ArrayList  // 这里的ArrayList<>和Java里面的ArrayList一致

mutableList1.add("6")  // 添加元素
mutableList1.add("7")
mutableList1.remove(1)   // 删除某一元素

1.3 Set

val set1 = setOf(1,2,"3","4","2",1,2,3,4,5)
val mutableSet1 = mutableSetOf(1,2,"3","4","2",1,2,3,4,5)

// 这里的HashSet<>和Java里面的HashSet<>一致
val mutableSet2 : HashSet  

// 输出结果 ： 1 2 3 4 2 3 4 5

当我们看到输出结果的时候发现所有的重复数据都没有了，这里的特点也是kotlin和java 保持了一致。

1.4 Map

// 以键值对的形式出现，键与值之间使用to

val map1 = mapOf("key1" to 2 , "key2" to 3)
val map2 = mapOf(1 to "value1" , 2 to "value2")
val mutableMap = mutableMapOf("key1" to 2 , "key1" to 3)

// 同Java中的HashMap
val hashMap = hashMapOf("key1" to 2 , "key1" to 3)   

val map = val map1 = mapOf("key1" to 2 , "key1" to 3 ,
                             "key1" to "value1" , "key2" to "value2")

//输出结果 key1      value1   ， key2     value2

当我们的键存在重复时，集合会过滤掉之前重复的元素。value 只保留了最后一个元素。而过滤掉了之前key值相同的所有元素。

2 List 和 Sequence 选择使用

相信大多Android 开发者都理解集合和序列的区别，那么我们应该如何更好的使用这两个？

总结List的使用场景：

量级比较小的集合元素（当数量比较少的时候 List 和 Sequence 的循环耗时相差无几）
访问索引元素 (Lists(集合) 是有索引的，Sequences(序列) 则必须逐项进行.其实和 java 中的 ArrayList 和 LinkedList 知识点差不多)
返回/传递给其他的函数 （每次迭代Sequences(序列) 时，都会计算元素。Lists(集合) 中的元素只计算一次，然后存储在内存中。）

我们这里之举一个例子通过耗时的循环来看下两者区别

Kotlin

list.map { it *3 }
  .filter { it % 2 == 0 }
  .count { it < 10 }

Kotlin code

      Object element$iv$iv;
      int it;
      while(var5.hasNext()) {
         element$iv$iv = var5.next();
         it = ((Number)element$iv$iv).intValue();
         Integer var12 = it * 3;
         destination$iv$iv.add(var12);
      }

      $receiver$iv = (Iterable)((List)destination$iv$iv);
      destination$iv$iv = (Collection)(new ArrayList());
      var5 = $receiver$iv.iterator();

      while(var5.hasNext()) {
         element$iv$iv = var5.next();
         it = ((Number)element$iv$iv).intValue();
         if (it % 2 == 0) {
            destination$iv$iv.add(element$iv$iv);
         }
      }

      $receiver$iv = (Iterable)((List)destination$iv$iv);
      if (!($receiver$iv instanceof Collection) || !((Collection)$receiver$iv).isEmpty()) {
         int count$iv = 0;
         Iterator var13 = $receiver$iv.iterator();

         while(var13.hasNext()) {
            Object element$iv = var13.next();
            int it = ((Number)element$iv).intValue();
            if (it < 10) {
               ++count$iv;
            }
         }
      }

你会发现Kotlin编译器会创建三个while循环.而Sequences则只会存在一个循环，所以在循环多的情况下还是Sequences 比较快一点。
kotlin

    val result = list.asSequence()
            .map{ println("In Map"); it * 2 }
            .filter { println("In Filter");it % 3  == 0 }
    println("Before Average")
    println(result.average())

Kotlin code

      List list = CollectionsKt.listOf(new Integer[]{1, 2, 3, 4, 5, 6});
      Sequence result = SequencesKt.filter(SequencesKt.map(CollectionsKt.asSequence((Iterable)list), (Function1)null.INSTANCE), (Function1)null.INSTANCE);
      String var3 = "Before Average";
      System.out.println(var3);
      double var5 = SequencesKt.averageOfInt(result);
      System.out.println(var5);

序列(Sequences) 的秘诀在于它们是共享同一个迭代器(iterator) ---序列允许 map操作转换一个元素后，然后立马可以将这个元素传递给 filter操作，而不是像集合(lists) 一样等待所有的元素都循环完成了map操作后，用一个新的集合存储起来，然后又遍历循环从新的集合取出元素完成filter操作。

3. 操作符汇总

下面对这6类操作符进行一一的讲解，不过这里就不对他们的源码进行分析。大多都存在于_Collections.kt这个文件中。下边的测试代码和运行结果我都将结果和方法放在一起了好对比。

3.1 元素操作符

contains(元素) : 检查集合中是否包含指定的元素，若存在则返回true，反之返回false

elementAt(index) : 获取对应下标的元素。若下标越界，会抛出IndexOutOfBoundsException（下标越界）异常，同get(index)一样

elementAtOrElse(index,{...}) : 获取对应下标的元素。若下标越界，返回默认值，此默认值就是你传入的下标的运算值

elementAtOrNull(index) : 获取对应下标的元素。若下标越界，返回null

first() : 获取第一个元素，若集合为空集合，这会抛出NoSuchElementException异常

first{} : 获取指定元素的第一个元素。若不满足条件，则抛出NoSuchElementException异常

firstOrNull() : 获取第一个元素，若集合为空集合，返回null

firstOrNull{} : 获取指定元素的第一个元素。若不满足条件，返回null

getOrElse(index,{...}) : 同elementAtOrElse一样

getOrNull(index) : 同elementAtOrNull一样

last () : 同first()相反

last {} : 同first{}相反

lastOrNull{} : 同firstOrNull()相反

lastOrNull() : 同firstOrNull{}相反

indexOf(元素) : 返回指定元素的下标，若不存在，则返回-1

indexOfFirst{...} : 返回第一个满足条件元素的下标，若不存在，则返回-1

indexOfLast{...} : 返回最后一个满足条件元素的下标，若不存在，则返回-1

single() : 若集合的长度等于0,则抛出NoSuchElementException异常，若等于1，则返回第一个元素。反之，则抛出IllegalArgumentException异常

single{} : 找到集合中满足条件的元素，若元素满足条件，则返回该元素。否则会根据不同的条件，抛出异常。这个方法慎用

singleOrNull() : 若集合的长度等于1,则返回第一个元素。否则，返回null

singleOrNull{} : 找到集合中满足条件的元素，若元素满足条件，则返回该元素。否则返回null

forEach{...} : 遍历元素。一般用作元素的打印

forEachIndexed{index,value} : 遍历元素，可获得集合中元素的下标。一般用作元素以及下标的打印

componentX() ：这个函数在前面的章节中提过多次了。用于获取元素。其中的X只能代表1..5。详情可看下面的例子

eg：

val list = listOf("kotlin","Android","Java","PHP","Python","IOS")

println(list.contains("JS"))   // false

println(list.elementAt(2))  // Java
println(list.elementAtOrElse(10,{it}))   // 10 
println(list.elementAtOrNull(10))   // null

println(list.get(2))  //  Java
println(list.getOrElse(10,{it}))  // 10
println(list.getOrNull(10))  // null

println(list.first())   //  kotlin
println(list.first{ it == "Android" })  // Android
println(list.firstOrNull())   // kotlin
println(list.firstOrNull { it == "Android" })   // Android

println(list.last())   // IOS
println(list.last{ it == "Android" })   // Android
println(list.lastOrNull())  // IOS
println(list.lastOrNull { it == "Android" })  // Android

println(list.indexOf("Android"))  // 1
println(list.indexOfFirst { it == "Android" })  //  1
println(list.indexOfLast { it == "Android" })   //  1

val list2 = listOf("list")
// 只有当集合只有一个元素时，才去用这个函数，不然都会抛出异常。
println(list2.single())      // list
 //当集合中的元素满足条件时，才去用这个函数，不然都会抛出异常。若满足条件返回该元素
println(list2.single { it == "list" })   // list
// 只有当集合只有一个元素时，才去用这个函数，不然都会返回null。
println(list2.singleOrNull())    // list
//当集合中的元素满足条件时，才去用这个函数，不然返回null。若满足条件返回该元素
println(list2.singleOrNull { it == "list" })   // list 

list.forEach { println(it) } 
// kotlin
// Android
// Java
// PHP
// Python
// IOS

list.forEachIndexed { index, it -> println("index : $index \t value = $it") }
/**
index : 0    value = kotlin
index : 1    value = Android
index : 2    value = Java
index : 3    value = PHP
index : 4    value = Python
index : 5    value = IOS
**/

  // 等价于`list[0]  <=> list.get(0)`
println(list.component1())    //  kotlin
....
 // 等价于`list[4]  <=> list.get(4)`
println(list.component5())   // Python

3.2 顺序操作符

reversed() : 反序。

sorted() : 升序。

sortedBy{} : 根据条件升序。把不满足条件的放在前面，满足条件的放在后面

sortedDescending() : 降序。

sortedByDescending{} : 根据条件降序。

eg:

    val list1 = listOf(-1,-2,1,3,5,6,7,2,4)
    // 反序
    println(list1.reversed())    // [4, 2, 7, 6, 5, 3, 1, -2, -1]
    // 升序
    println(list1.sorted())   // [-2, -1, 1, 2, 3, 4, 5, 6, 7]
    // 根据条件升序，即把不满足条件的放在前面，满足条件的放在后面
    println(list1.sortedBy { it % 2 == 0})  // [-1, 1, 3, 5, 7, -2, 6, 2, 4]
    // 降序
    println(list1.sortedDescending())   // [7, 6, 5, 4, 3, 2, 1, -1, -2]
    // 根据条件降序，和`sortedBy{}`相反
    println(list1.sortedByDescending { it % 2 == 0 })   // [-2, 6, 2, 4, -1, 1, 3, 5, 7]

3.3 映射操作符

map{...} : 把每个元素按照特定的方法进行转换，组成新的集合。

mapNotNull{...} : 同map{}函数的作用相同，过滤掉转换之后为null的元素

mapIndexed{index,result} : 把每个元素按照特定的方法进行转换，只是其可以操作元素的下标(index)，组成新的集合。

mapIndexedNotNull{index,result} : 同mapIndexed{}函数的作用相同，只是过滤掉转换之后为null的元素

flatMap{...} : 根据条件合并两个集合，组成新的集合。

groupBy{...} : 分组。即根据条件把集合拆分为为一个Map>类型的集合。

eg:

    val list1 = listOf("kotlin","Android","Java","PHP","JavaScript")

    println(list1.map { "str-".plus(it) })
    //[str-kotlin, str-Android, str-Java, str-PHP, str-JavaScript]

    println(list1.mapNotNull { "str-".plus(it) })
    // [str-kotlin, str-Android, str-Java, str-PHP, str-JavaScript]
    
    println(list1.mapIndexed { index, str ->
        index.toString().plus("-").plus(str)
    })
    //[0-kotlin, 1-Android, 2-Java, 3-PHP, 4-JavaScript]
    
    println(list1.mapIndexedNotNull { index, str ->
        index.toString().plus("-").plus(str)
    })
    // [0-kotlin, 1-Android, 2-Java, 3-PHP, 4-JavaScript]
    
    println( list1.flatMap { listOf(it,"new-".plus(it)) })
    //[kotlin, new-kotlin, Android, new-Android, Java, new-Java, PHP, new-PHP, JavaScript, new-JavaScript]
    
    println(list1.groupBy { if (it.startsWith("Java")) "big" else "latter" })
    // {latter=[kotlin, Android, PHP], big=[Java, JavaScript]}

3.4 过滤操作符

filter{...} : 把不满足条件的元素过滤掉

filterIndexed{...} : 和filter{}函数作用类似，可以操作集合中元素的下标

filterNot{...} : 和filter{}函数的作用相反

filterNotNull() : 过滤掉集合中为null的元素。

take(num) : 返回集合中前num个元素组成的集合

takeWhile{...} : 循环遍历集合，从第一个元素开始遍历集合，当第一个出现不满足条件元素的时候，退出遍历。然后把满足条件所有元素组成的集合返回。

takeLast(num) : 返回集合中后num个元素组成的集合

takeLastWhile{...} : 循环遍历集合，从最后一个元素开始遍历集合，当第一个出现不满足条件元素的时候，退出遍历。然后把满足条件所有元素组成的集合返回。

drop(num) : 过滤集合中前num个元素

dropWhile{...} : 相同条件下，和执行takeWhile{...}函数后得到的结果相反

dropLast(num) : 过滤集合中后num个元素

dropLastWhile{...} : 相同条件下，和执行takeLastWhile{...}函数后得到的结果相反

distinct() : 去除重复元素

distinctBy{...} : 根据操作元素后的结果去除重复元素

slice : 过滤掉所有不满足执行下标的元素。

eg:

    val list1 = listOf(-1,-3,1,3,5,6,7,2,4)
    val list2 = listOf(1,3,4,5,null,6,null,10)
    val list3 = listOf(1,1,5,2,2,6,3,3,7,4)

    println(list1.filter { it > 1  })   // [3, 5, 6, 7, 2, 4]
    println(list1.filterIndexed { index, result ->
        index < 5 && result > 3
    })
    //  [5] 

    println(list1.filterNot { it > 1 })   //  [-1, -3, 1]
    println(list2.filterNotNull())   //   [1, 3, 4, 5, 6, 10]

    println(list1.take(5))    //  [-1, -3, 1, 3, 5]
    println(list1.takeWhile { it < 5 })   //  [-1, -3, 1, 3]
    println(list1.takeLast(5))   //  [5, 6, 7, 2, 4]
    println(list1.takeLastWhile { it > 5 })   //  []

    println(list1.drop(5))   // [6, 7, 2, 4]
    println(list1.dropWhile { it < 5 })   //  [5, 6, 7, 2, 4]
    println(list1.dropLast(5))  // [-1, -3, 1, 3]
    println(list1.dropLastWhile { it > 5 })  // [-1, -3, 1, 3, 5, 6, 7, 2, 4]

    println(list3.distinct())  //  [1, 5, 2, 6, 3, 7, 4]
    println(list3.distinctBy { it + 2 })  //  [1, 5, 2, 6, 3, 7, 4]

    println(list1.slice(listOf(1,3,5,7)))  //  [-3, 3, 6, 2]
    println(list1.slice(IntRange(1,5)))  //   [-3, 1, 3, 5, 6]

3.5 生产操作符

plus() : 合并两个集合中的元素，组成一个新的集合。也可以使用符号+

zip : 由两个集合按照相同的下标组成一个新集合。该新集合的类型是：List

unzip : 和zip的作用相反。把一个类型为List的集合拆分为两个集合。看下面的例子

partition : 判断元素是否满足条件把集合拆分为有两个Pair组成的新集合

eg:

    val list1 = listOf(1,2)
    val list2 = listOf("kotlin","Android","Java")

    println(list1.plus(list2))  // [1, 2, kotlin, Android, Java]
    println(list1 + list2)   //  [1, 2, kotlin, Android, Java]
    // 组成的新集合由元素少的原集合决定
    println(list1.zip(list2))   //  [(1, kotlin), (2, Android)]
    // 组成的新集合由元素少的原集合决定
    println(list1.zip(list2){
        it1,it2-> it1.toString().plus("-").plus(it2)
    })  //  [1-kotlin, 2-Android]
    
    val newList = listOf(Pair(1,"Kotlin"),Pair(2,"Android"),Pair(3,"Java"))
    println(newList.unzip())   //  ([1, 2, 3,], [Kotlin, Android, Java])

    println(list2.partition { it.startsWith("Ja") })  //  ([Java], [kotlin, Android])

3.6 统计操作符

any() : 判断是不是一个集合，若是，则在判断集合是否为空，若为空则返回false,反之返回true,若不是集合，则返回hasNext

any{...} : 判断集合中是否存在满足条件的元素。若存在则返回true,反之返回false

all{...} : 判断集合中的所有元素是否都满足条件。若是则返回true,反之则返回false

none() : 和any()函数的作用相反

none{...} : 和all{...}函数的作用相反

max() : 获取集合中最大的元素，若为空元素集合，则返回null

maxBy{...} : 获取方法处理后返回结果最大值对应那个元素的初始值，如果没有则返回null

min() : 获取集合中最小的元素，若为空元素集合，则返回null

minBy{...} : 获取方法处理后返回结果最小值对应那个元素的初始值，如果没有则返回null

sum() : 计算出集合元素累加的结果。

sumBy{...} : 根据元素运算操作后的结果，然后根据这个结果计算出累加的值。

sumByDouble{...} : 和sumBy{}相似，不过sumBy{}是操作Int类型数据，而sumByDouble{}操作的是Double类型数据

average() : 获取平均数

reduce{...} : 从集合中的第一项到最后一项的累计操作。

reduceIndexed{...} : 和reduce{}作用相同，只是其可以操作元素的下标(index)

reduceRight{...} : 从集合中的最后一项到第一项的累计操作。

reduceRightIndexed{...} : 和reduceRight{}作用相同，只是其可以操作元素的下标(index)

fold{...} : 和reduce{}类似，但是fold{}有一个初始值

foldIndexed{...} : 和reduceIndexed{}类似，但是foldIndexed{}有一个初始值

foldRight{...} : 和reduceRight{}类似，但是foldRight{}有一个初始值

foldRightIndexed{...} : 和reduceRightIndexed{}类似，但是foldRightIndexed{}有一个初始值

eg：

    val list1 = listOf(1,2,3,4)
    println(list1.any())   // true
    println(list1.any{it > 10})   //  false
    println(list1.all { it > 2 })   //  false
    println(list1.none())   // false
    println(list1.none{ it > 2})    //  false
    println(list1.max())   //  4
    println(list1.maxBy { it + 2 })   // 4
    println(list1.min())    //  1
    println(list1.minBy { it + 2 })   //  1
    println(list1.sum())   //  10
    println(list1.sumBy { it + 2 })   // 18
    println(list1.sumByDouble { it.toDouble() })   //  10.0
    println(list1.average())    //  2.5
    println(list1.reduce { result, next -> result  + next})   //  10
    println(list1.reduceIndexed { index, result, next ->
        index + result + next
    })  //   16
    println(list1.reduceRight { result, next -> result  + next })   //   10
    println(list1.reduceRightIndexed {index, result, next ->
        index + result + next
    })  //  13
    println(list1.fold(3){result, next -> result  + next})  //  13
    println(list1.foldIndexed(3){index,result, next ->
        index + result  + next
    })  //  19
    println(list1.foldRight(3){result, next -> result  + next})   //  13
    println(list1.foldRightIndexed(3){index,result, next ->
        index + result  + next
    })  //  19

Kotlin 学习笔记（十二）kotlin中 集合序列使用、操作符汇总、list和sequence比较