kotlin学习笔记-异常好玩的list集合总结

摘要：可能是最流行的集合类型。它是一个范性有序的集合。一个无序并不支持重复的集合。接口继承接口，集合中可以存放重复对象。集合类提供了，等高阶函数去处理。我们声明一个集合或者数组，可以转换成相应类型的集合。调用转换为可变集合。

不积跬步无以至千里,不积小流无以成江海

先看看Kotlin中for循环的遍历

 fun  testList(){
        var StringVal = "12_12_13_15_a_b_c_d_yu_er"
        var ssArray = StringVal.split("_")
        var ss01 = ssArray[0]
        var ss02 = ssArray[1]
        var size =  ssArray.size
        println("ss01:   $ss01")
        println("ss02:   $ss02")
        println("size:$size")
        val items = listOf("apple", "banana", "kiwi")
        //迭代for循环
        for (item in ssArray){
            println("item:  $item")
        }

        for (item in ssArray)  println("item:  $item")


        //循环体可以是一个代码块:
        for (item : String in ssArray ){
            println("item:  $item")
        }

        //通过索引进行遍历,for 可以循环遍历任何提供了迭代器的对象。
        //如果你想要通过索引遍历一个数组或者一个 list
        //注意这种"在区间上遍历"会编译成优化的实现而不会创建额外对象。
        for (i in ssArray.indices) {
            print(ssArray[i])
        }


        //这种"在区间上遍历"会编译成优化的实现而不会创建额外对象。或者你可以用库函数 withIndex：
        fun forbetween(index :Int,value : Objects){
            for ((index,value) in ssArray.withIndex()){
                println("the element at $index is $value")
            }
        }
    }

，Kotlin针对集合进行了更加简洁和有效的封装

Iterable：父类。所有我们可以遍历一系列的都是实现这个接口。

MutableIterable：一个支持遍历的同时可以执行删除的Iterables。

Collection：这个类相是一个范性集合。我们通过函数访问可以返回集合的size、是否为空、是否包含一个或者一些item。这个集合的所有方法提供查询，因为connections是不可修改的。

MutableCollection：一个支持增加和删除item的Collection。它提供了额外的函数，比如add 、remove、clear等等。

List：可能是最流行的集合类型。它是一个范性有序的集合。因为它的有序，我们可以使用get函数通过position来访问。

MutableList：一个支持增加和删除item的List。

Set：一个无序并不支持重复item的集合。

MutableSet：一个支持增加和删除item的Set。

Map：一个key-value对的collection。key在map中是唯一的，也就是说不能有两对key是一样的键值对存在于一个map中。

MutableMap：一个支持增加和删除item的map。

比如： List是以线性方式管理物件集合，其可以很快的在任何地方进行增加和删除元素。List接口继承Collection接口，集合中可以存放重复对象。

对于接口的实现

Kotlin中可以这样写：

而在Java 中却不能这样写：

        
        val list1 = listOf()           //返回的是kotlin的List，只读
        val list2 = mutableListOf()    //返回的是kotlin的MutableList，可读写
        val list3 = arrayListOf()      //返回的是java的ArrayList，java的ArrayList是可读写的


        var setList = setOf()         //返回的是kotlin的set集合，一个无序并不支持重复item的集合 只读
        var setMutableList   = mutableSetOf() //返回的是kotlin的set集合 MutableSet  可读写
        var hashSet = hashSetOf()   //返回的是java的set集合 hashSet  可读写

        var map = mapOf() //返回kotlin中的map，只读
        mutableMapOf() // 返回的是kotlin中的hashmap集合，可读可写
        hashMapOf() //返回java中的hashmap 可读可写

        //eg:怎么取用
        list2.add(1)
        var first : Int = list2.first()
        list3.add(1)
        var first2 : Int = list3.first()

集合set:

set集合中的元素是不会有重复的，并且是乱序的。创建set需要使用setOf()，mutableSetOf()：

val set= setOf(
        "祖安",
        "皮尔特沃夫"
)
val mutableSet= mutableSetOf(
        "阿利斯塔",
        "希维尔"
)

Map:
Map是一个存放键和值的集合，每一个元素都包含键和值。Kotlin中Map和list一样，也分为只读和可变两种Map。

创建Map时需要调用mapOf()，mutableMapOf()：

val map= mapOf(
        1 to "伊泽瑞尔", 2 to "雷克顿", 3 to "古拉加斯", 4 to "泰达米尔"
)
val hashMap= hashMapOf(
        1 to "伊泽瑞尔", 2 to "雷克顿", 3 to "古拉加斯", 4 to "泰达米尔"
)

map和hashMap的区别，这里就不说了，Java的基础

val count=map.size  //获取元素数量
val keys=map.keys   //返回map中key的集合
keys.forEach(::print)   //输出Log：1,2,3,4
val values=map.values    //返回map中key的集合
values.forEach(::print)     //输出Log：伊泽瑞尔,雷克顿,古拉加斯,泰达米尔
val entry=map.entries   //返回键/值对集合
entry.forEach{
    println("key: ${it.key} , value: ${it.value}")
}       //输出key:1 , value:伊泽瑞尔  key:2...

val isEmpty=map.isEmpty()   //判断集合是否为空 Boolean
val isContainsKey=map.containsKey(3)    //判断集合中是否包含某个key
val isContainsValue=map.containsValue("雷克顿")    //判断集合中是否包含某个value
val valueStr=map.get(2) //获取指定key的元素值，没有则返回null

上面说了map和list一样是只读的，可变的map需要使用mutableMap：

var mutableMapOf= mutableMapOf()
mutableMapOf.putAll(map)    //添加整个map
mutableMapOf.put(5,"拉克丝")   //添加指定key的value
mutableMapOf.remove(2)  //移除元素
mutableMapOf.clear()    //清空集合

很多情况下，函数和方法的名字和list的都是一样的。

val list = listOf(1, 2, 3, 4, 5, 6)

list.any {//只要集合中的任何一个元素满足条件(使得lambda表达式返回true)，any函数就返回true
    it >= 0
}
list.all {//集合中的全部元素都满足条件(使得lambda表达式返回true)，all函数才返回true
    it >= 0
}
list.none {//若集合中没有元素满足条件（使lambda表达式返回true），则none函数返回true
    it < 0
}
list.count {//count函数的返回值为：集合中满足条件的元素的总数
    it >= 0
}

//对所有元素求和
kotlinList.sum()

//将集合中的每一个元素代入lambda表达式，然后对lambda表达式的返回值求和
kotlinList.sumBy {
    it % 2
}

//在一个初始值的基础上,从第一项到最后一项通过一个函数累计所有的元素
//accumulator的初始值为100，element从集合的第一个元素开始，lambda表达式的返回值就是accumulator的新值
kotlinList.fold(100) { accumulator, element ->
    accumulator + element / 2
}

//同fold，只是迭代的方向相反
kotlinList.foldRight(100) { accumulator, element ->
    accumulator + element / 2
}

//同fold，只是accumulator的初始值就是集合的第一个元素，element从第二个元素开始
kotlinList.reduce { accumulator, element ->
    accumulator + element / 2
}

//同reduce但方向相反：accumulator的初始值就是集合的最后一个元素，element从倒数第二个元素开始往前迭代
kotlinList.reduceRight { accumulator, element ->
    accumulator + element / 2
}

//遍历所有元素
kotlinList.forEach {
    print(it)
}

//同forEach，只是可以同时拿到元素的索引
kotlinList.forEachIndexed { index, value ->
    println("position $index contains a $value")
}

//返回集合中最大的元素，集合为空(empty)则返回null
kotlinList.max()

//返回集合中使得lambda表达式返回值最大的元素，集合为空(empty)则返回null
kotlinList.maxBy { it }

//返回集合中最小的元素，集合为空(empty)则返回null
kotlinList.min()

//返回集合中使得lambda表达式返回值最小的元素，集合为空(empty)则返回null
kotlinList.minBy { it }

//返回一个新List，去除集合的前n个元素
kotlinList.drop(2)
//返回一个新List，去除集合的后n个元素
kotlinList.dropLast(2)
//返回一个新List，去除集合中满足条件(lambda返回true)的第一个元素
list.dropWhile {
    it > 3
}
//返回一个新List，去除集合中满足条件(lambda返回true)的最后一个元素
kotlinList.dropLastWhile {
    it > 3
}

val list = listOf(1, 2, 3, 4, 5, 6)
list.reversed() //返回一个颠倒元素顺序的新集合
list.sorted() //返回一个升序排序后的新集合
list.sortedBy {//将每个元素代入lambda表达式，根据lambda表达式返回值的大小来对集合进行排序
    it*2
}

list.sortedDescending()//返回一个降序排序后的新集合
list.sortedByDescending {
    it*2
}

val list = listOf(1, 2, 3, 4, 5, 6)
val list2 = listOf(5, 6, 7, 8, 9, 0)

//拼接两个集合，返回一个新集合
//本质是调用list.plus(list2)
list + list2

//把一个给定的集合分割成两个list，一个list中是代入lambda表达式后返回true的元素，另一个list中是代入后返回false的元素
val (list3, list4) = list.partition {
    it % 2 == 0
}

//返回一个由pair组成的list，每一个pair由两个集合中相同index的元素组成
val pairList: List> = list.zip(list2)

//unzip与zip的功能相反，将一个由pair组成的list分解成两个list
val (list5, list6) = pairList.unzip()

当我们声明一个集合，可以把这个集合根据调用集合类相应的高阶函数来转换成相应的数组。集合类提供了toIntArray()、toDoubleArray()、toFloatArray()、toBetArray()，toTypedArray等高阶函数去处理。

Kotlin中，集合可分为不可变集合与可变集合。我们声明一个集合或者数组，可以转换成相应类型的集合。调用toXXX()转换成不可变集合。调用toMutableXXX()转换为可变集合。集合类提供了toList()、toMutableList()、toSet()、toMutableSet()、toHashSet()、toMap()等高阶函数去处理

例如：

嗯，今天就提到这里，学习Kotlin还有很长的一段路走，一门新的语言需要一颗耐心，摒弃杂念，向前出发吧

推荐几个学习的地址：

官网文档：
http://kotlinlang.org/
runoob中文文档
http://www.runoob.com/kotlin/...

Kotlin开发之旅《一》— 初学者Kotlin基础必备

我的Android重构之旅：插件化篇

20+个很棒的Android开源项目

Kotlin已成为Android开发一级语言——这次你绝对不能错过

在这里获得的不仅仅是技术！