kotlin list总结

集合的创建

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


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

        var map = mapOf<String, Int>() //返回kotlin中的map，只读
        mutableMapOf<String, Int>() // 返回的是kotlin中的hashmap集合，可读可写
        hashMapOf<String, Int>() //返回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<String>(
        "祖安",
        "皮尔特沃夫"
)
val mutableSet= mutableSetOf<String>(
        "阿利斯塔",
        "希维尔"
)

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

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

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

---

---

---

集合操作符

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 }

过滤

drop()：从第一项开始去除前n个元素，并返回剩余的元素列表。
dropWhile{}：根据给定函数从第一项开始去掉指定元素，直到不满足条件为止的前面的元素，并返回剩余元素列表。
dropLastWhile{}：根据给定函数从最后一项开始去掉指定元素，直到不满足条件为止的后面的元素，并返回剩余元素的列表。
filter{}：过滤出所有符合给定函数条件的元素。
filterNot{}：过滤所有不符合给定函数条件的元素。
filterNotNull()：过滤所有元素中不是null的元素。
slice()：过滤一个list中指定index的元素。
take()：返回从第一个开始的n个元素。
takeLast()：返回从最后一个开始的n个元素。
takeWhile{}：返回从第一个开始符合给定函数条件的元素，直到不符合条件为止。
takeLastWhile{}:返回从最后一个开始符合给定函数条件的元素，直到不符合条件为止。
fileter{}.mapTo(){}: 过滤所有符合条件的数据，到mapTo 列表中，{}是保存的字段
filter{}.map{}.sum() :过滤所有符合条件的数据，在map中进行计算，并求和

        list2.drop(3).forEach {
            print(it)//输出7389
        }
        println()
        list2.dropWhile { it < 6 }.forEach {
            print(it)//输出67389
        }
        println()
        list2.dropLastWhile { it > 6 }.forEach {
            print(it)//输出45673
        }

        println()
        list2.filter { it % 2 == 0 }.forEach {
            print(it)//输出468
        }
        println()
        list2.filterNot { it % 2 == 0 }.forEach {
            print(it)//输出5739
        }
        println()
        val listT = listOf("1", "2", null, "3")
        listT.forEach { print(it) }
        println()//输出12null3
        listT.filterNotNull().forEach {
            print(it)//输出123
        }
        println()
        list2.slice(listOf(1, 3, 5)).forEach {
            print(it)//输出578
        }

        println()
        list2.take(4).forEach {
            print(it)//输出4567
        }
        println()
        list2.takeLast(4).forEach {
            print(it)//输出
        }
        println()
        list2.takeWhile { it < 6 }.forEach {
            print(it)//输出45
        }
        println()
        list2.takeLastWhile { it > 6 }.forEach {
            print(it)//输出89
        }
        // 过滤条件
        list2.filter { it<4 }.mapTo(mutableList){2}

        // 过去计算
        list2.filter { it<4 }.map { it * it }.sum()

排序&逆序

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<Pair<Int, Int>> = list.zip(list2)

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

 

•