快速学习Kotlin（七）集合与操作符

集合是我们在代码编写时常用的操作数据的方式之一，具有非常重要的作用。

在kotlin中也有集合的概念，kotlin中的集合一般有三种：List、Map以及Set三种。而这三种集合每种又可以分为可变集合与不可变集合两种。

不可变集合

顾名思义，不可变集合就是集合在初始化时已经将元素放入集合当中去，之后只能对集合中的元素进行查看和遍历，不能对其进行添加、修改和删除。

        var list = listOf<String>("A","B","C","D");
        
        var set = setOf<String>("a","b","c","d","e");
        
        var map = mapOf<Int,String>(1 to "aa",2 to "bb",3 to "cc",4 to "dd",5 to "dd");

在kotlin中并没有声明为集合的函数，所以我们不能像Java中那样直接使用ArrayList或者HashMap这样来声明一个集合。而是应该改用listof、setof和mapof等方法来声明一个集合。并且用这种方式声明的集合都是不能变集合，我们在声明的同时就在括号中将其初始值添加进去，之后便可以直接遍历取出这些值。

可变集合

绝大多数情况下，我们在操作集合的时候都不是一层不变的，很多时候都是在对集合中的数据进行增删改查，那么该如何操作呢？这个时候就必须使用到可变集合。

var list  = mutableListOf<String>();
    list.add("A");
    list.add("B");
    list.add("C");

    list.get(0);
    list.get(1)

    list.removeAt(0);



    var set  = mutableSetOf<Int>();
    set.add(1);
    set.add(2);

    set.remove(0);
    var size = set.size


    var map = mutableMapOf<Int,String>();
    map.put(1,"aa");
    map.put(2,"bb");
    var value = map.get(1)
    

当我们把集合声明为mutableListOf、mutableSetOf和mutableMapOf时，集合就变成了一个可变集合。我们可以对集合进行像Java一样增删改查的操作。

此外如果你想对Map进行操作，kotlin也提供各种不同的map来进行数据的操作。

• hashMapOf()——创建一个hashMap
• linkedMapOf()——创建一个linkedMap
• sortedMapOf()——创建一个sortedMap

另外在对可变集合在声明的时候也可以进行初始化操作，如果不进行初始化则默认为一个空集合。

var list  = mutableListOf<String>("Q","W","E");

var set  = mutableSetOf<Int>(1,2,3,4);

var map = mutableMapOf<Int,String>(1 to "aa",2 to "bb");

集合的遍历

有些时候我们会需要去取出集合中的所有元素，对不同元素进行不同的操作。这时候就需要对集合进行遍历操作。下面列出集中集合遍历的方式来提供参考。

• list集合遍历

    var list:List<String> = listOf<String>("a","b","c","d","e","f","g","h","i");
    var value:String;
    
    //第一种遍历方式
    for (value in list){
        println("集合遍历结果：$value");
    }
    
    //第二种遍历方式
    list.forEach {
        println("集合遍历结果：$it")
    }
    
    //遍历结果
    集合遍历结果：a
    集合遍历结果：b
    集合遍历结果：c
    集合遍历结果：d
    集合遍历结果：e
    集合遍历结果：f
    集合遍历结果：g
    集合遍历结果：h
    集合遍历结果：i
    

这两种遍历list集合输出的结果都是一样的。但是假设我们此时还需要同时输出集合下角标和元素值，那么又当如何遍历？这里写出第三种遍历方式，可以同时遍历下角标和元素值

    var list:List<String> = listOf<String>("a","b","c","d","e","f","g","h","i");
    var value:String;




    for ((index,value) in list.withIndex()){
        println("角标为$index,元素值为$value");
    }
    
    //遍历结果
    角标为0,元素值为a
    角标为1,元素值为b
    角标为2,元素值为c
    角标为3,元素值为d
    角标为4,元素值为e
    角标为5,元素值为f
    角标为6,元素值为g
    角标为7,元素值为h
    角标为8,元素值为i
    

看到，这里使用了解构的方式来遍历整个集合，从而达到可以同时遍历下角标和元素内容的目的。

• Map集合遍历

        var map:Map<String,String> = mapOf("1" to "a","2" to "b","3" to "c","4" to "d","5" to "e");

        //第一种遍历集合方式
        map.forEach {

            println("集合的key为${it.key}，集合的value为${it.value};");

        };


        //第二种解构遍历集合方式
        for ((key,value) in map){

            println("集合的key为${key}，集合的value为${value};");

        }
        
        //遍历结果
        集合的key为1，集合的value为a;
        集合的key为2，集合的value为b;
        集合的key为3，集合的value为c;
        集合的key为4，集合的value为d;
        集合的key为5，集合的value为e;

操作符

熟悉RxJava的都知道，RxJava之所以强大的地方在于其拥有很多非常好用的操作符，这些操作符大大节约了我们编程的难度方便了我们的开发。在kotlin中集合里面也有很多操作符。下面我来列举几个常用的操作符。

• any

说明：如果至少有一个元素符合判断条件，则返回true，否则false,例：

val list = listOf(1, 2, 3, 4, 5)
list.any { it > 10 }

结果为false

• all

说明：如果集合中所有的元素都符合判断条件，则返回true否则false,例：

val list = listOf(1, 2, 3, 4, 5)
list.any { it < 10 }

结果为true

• count

说明：返回集合中符合判断条件的元素总数。例：

val list = listOf(1, 2, 3, 4, 5)
list.count { it <3 }

结果为2

• forEach

说明：遍历所有元素，并执行给定的操作（类似于Java 中的for循环）。例：

val list = listOf(1, 2, 3, 4, 5)
list.forEach{ Log.i(TAG,it.toString()) }

结果为：1 2 3 4 5

• forEachIndexed

说明：与forEach作用一样，但是同时可以得到元素的index。例：

val list = listOf(1, 2, 3, 4, 5)
list.forEachIndexed { index, i -> Log.i(TAG, "index:" + index + " value:" + i.toString()) }

结果为
index:0 value:1
index:1 value:2
index:2 value:3
index:3 value:4
index:4 value:5

• drop

说明：返回去掉前n个元素的列表。例：

val list = listOf(1, 2, 3, 4, 5)
var s = list.drop(2)
s.forEach {
Log.i(TAG, it.toString())
}

结果为 ：3 4 5（去掉了前两个元素）

• filter

说明：过滤所有符合给定函数条件的元素。例：

list.filter { it > 2 }

结果为：3 4 5

• flatMap

说明：遍历所有的元素，为每一个创建一个集合，最后把所有的集合放在一个集合中。例：

list.flatMap { listOf(it, it + 1) }

结果为： 1 2 2 3 3 4 4 5 5 6（每个元素都执行加1后作为一个新元素）

• map

说明：返回一个每一个元素根据给定的函数转换所组成的集合。例：

list.map { it * 2 }

结果为：2 4 6 8 10

• zip

说明：返回由pair组成的List，每个pair由两个集合中相同index的元素组成。这个返回的List的大小由最小的那个集合决定。例：

list.zip(listOf(7, 8))

结果为：(1, 7) (2, 8)

• first

说明：返回符合给定函数条件的第一个元素。例：

list.first { it > 2 }

结果为：3

• last

说明：返回符合给定函数条件的最后一个元素。例：

list.last { it % 2 == 0 }

结果为：4

如果觉得我的文章能够帮助到你，也欢迎关注我的微信公众号「晨雨细曲」，有新技术和知识会推送在这上面。