Android开发，Kotlin的了解与学习（五）-----基本语法之集合相关

map相关

map，使用如下

var mMap1 = hashMapOf("3" to 2, "a" to 5, "asd" to 9)
var mMap2 = hashMapOf<String, Int>()
mMap1.put("sdf", 9)
mMap2.put("qwe", 4)

快捷获取key and value

在java中，获取map类型的参数的key和value值是需要通过先转换成set再获取的方式，这是比较麻烦的，kotlin中就避免了这种情况，可以直接获取到键值对，如下

mMap1.forEach {
it.key
it.value
}
for ((key,value) in mMap1){

}

通过这两种方式可以很轻松的获取到每一个keyvalue

集合操作符

这是指的一类的操作符：

any：用于判断，集合中是否存在符合条件的值，返回布尔值

var list = listOf(1,2,3,4,5,6,7,8,9)
println(list.any { it < 6 })//返回true

all：用于判断，集合中是否全都满足条件，返回布尔值

var list = listOf(1,2,3,4,5,6,7,8,9)
println(list.all { it >3 })//返回false

none：用于判断，集合中是否都不满足条件，返回布尔值

var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
println(list.none { it < 0 })//返回true

count：用于统计，集合中满足条件的个数，返回Int值

var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
println(list.count { it > 7 })//返回2

reduce：用于统计，集合中从第一项到最后一项的累计

var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
println(list.reduce { total, next -> total + next })//返回45

需要注意，如果为String类型，累计的值就为字符串拼接

reduceRight：用于统计，集合中从最后一项到第一项的累计

var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
println(list.reduceRight { total, next ->  total + next})//返回45

在对数字进行累计时效果和上一个一样，字符串时不一样

max：用于统计，获取集合中的最大的元素

var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
println(list.max())//返回9

ps：如果为字符串集合，也可以用max，返回的就是根据字符串规则判断出的最大字符串

maxBy：和max类似，不过是在对元素进行一番处理之后的最大值所对应的那个元素

var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
println(list.maxBy { it  % 5 })//返回4

如上，当4%5时得到4，是所有元素进行类似处理后所能得到最大的值，所以返回4，虽然9%5也得到4，但是该函数会返回第一个得到该最大值的元素进行返回

min：和max类似

minBy：和maxBy类似

sum：用于获取集合中所有元素相加的总值

var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
println(list.sum（）)

sumBy：用于获取集合中所有元素经过处理后相加的总值

var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
println(list.sumBy { it*2 })

dropWhile：删除集合中满足条件的元素

var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
println("drop:"+list.dropWhile { it < 6 })//输出6.7.8.9的集合

dropLastWhile：倒序遍历集合，删除集合中满足条件的元素

var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
println("drop:"+list.dropLastWhile { it < 6 })//输出6.7.8.9的集合

ps：和上一个比较类似，只是是倒序删除

drop：删除集合中前几个的元素

var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
println(list.drop(3))//输出4.5.6.7.8.9的几个

ps；drop（3）并不代表删除第三个，而是代表删除前三个，删除某一个使用remove

fold：用于统计，和reduce类似，不过有初始值

var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
println(list.fold(5){total, next -> total + next})

foldRight：用于统计，和reduce类似，不过有初始值

var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
println(list.foldRight(3){total, next -> total + next})

这里有一点需要注意，假如用于遍历的是int类型的集合，fold的初始值也为int，那么遍历出来的结果就相当于在reduce的基础上加上初始值。但是如果遍历的是Int集合，但是初始值为String类型，比如 (list.foldRight(“a”){total, next -> total + next}，那么返回的结果就是a123456789，而不是a45，也不会报错

forEach：之前提到过，遍历集合

var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
list.forEach { println(it) }

forEachIndexed：和forEach类似，不过可以得到集合的数组下标

var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
list.forEachIndexed { index, it -> println("index=$index,it=$it") }

filter：过滤出不满足条件的元素

var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
println(list.filter { it % 2 > 0 })//输出1.3.5.7.9

ps：其实类似的操作用其他的操作符一样可以实现

filterNot：过滤出所有满足条件的元素

var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
println(list.filterNot { it % 2 > 0 })//输出2.4.6.8

filterNotNull：过滤出所有不是null的元素

var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
println(list.filterNotNull())

take：获取从第一个开始的前几个元素

var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
println(list.take(3))//返回1.2.3

ps：其实和drop是相反的，drop（3）就会返回4.5.6.7.8.9

takeLast：获取从最后一个开始的前一个元素

var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
println(list.takeLast(3))//返回9.8.7

takeWhile：获取满足条件的元素

var list = listOf(1, 2, 8, 4, 5, 4, 7, 2, -1)
println(list.takeWhile { it < 5 })

takeLastWhile：获取倒序开始的满足条件的元素

var list = listOf(1, 2, 8, 4, 5, 4, 7, 2, -1)
println(list.takeLastWhile { it < 5 })

slice：过滤出指定下标的元素

var list = listOf(1, 2, 8, 4, 5, 4, 7, 2, -1)
println(list.slice(listOf(1,3,5)))//返回2,4,4

映射相关

map：将集合中的元素经过处理后存储到另一个集合中

var list = listOf(1, 2, 8, 4, 5, 4, 7, 2, -1)
println(list.map { it - 3 })//返回-2,-1,5,1,2,1,4，-1，-4

mapIndexed：和map类似，不过还可以得到集合下标

var list = listOf(1, 2, 8, 4, 5)
println(list.mapIndexed { index, it -> it + index })

mapNotNull：得到非空的集合

var list2 = listOf(9, 5, 9, 3, null)
println(list2.mapNotNull {  })//还能进行操作

flatMap：将两个几个合并，同时进行部分处理

var list = listOf(1, 2, 8, 4, 5)
var list2 = listOf(1, 5, 9, 3)
println(listOf(list, list2).flatMap { it + 1 })

排序相关
reversed：相反排序

var list = listOf(1, 2, 8, 4, 5)
println(list.reversed())//得到5.4.8.2.1

sorted：自然排序，从小到大

var list = listOf(1, 2, 8, 4, 5)
println(list.sorted())//得到1.2.4.5.8

ps：如果是字符串集合，会按照首字符-字母（字母按照首字母排序）的顺序排序

sortedBy：按照规则排序

var list = listOf(1, 2, 8, 4, 5)
println(list.sortedBy { it % 2 })//输出2.8.4.1.5

sortedDescending：倒序排序

var list = listOf(1, 2, 8, 4, 5)
println(list.sortedDescending())//输出8.5.4.2.1

sortedByDescending：按照规则倒序排序

var list = listOf(1, 2, 8, 4, 5)
println(list.sortedByDescending { it%2 })//输出1.5.2.8.4

生产操作符

zip：将两个集合按照下标组合成一个双元（Pair）集合

var list = listOf(1, 2, 8, 4, 5)
var list2 = listOf(9, 5, 9, 3)
println(list.zip(list2))//输出（1,9),(2,5),(8,9),(4,3)

ps：这里出现了双元集合，可以视作一个map，如果要取双元集合的某一个值，只需要这样

var pair = list.zip(list2).get(0)
pair.first//1
pair.second//9

partition ：判断条件是否成立，拆分成一个Pair

var list2 = listOf(9, 5, 9, 3)
println(list2.partition { it > 5 })//输出（[9,9],[5,3]）

ps：满足条件的在前，不满足的在否

plus：合并两个集合

var list = listOf(1, 2, 8, 4, 5)
var list2 = listOf(9, 5, 9, 3)
println(list.plus(list2))

ps：前面提到过的flapMap其实也可以，只是flapMap可以用来进行条件处理

pps：这里还可以这么写

var list = listOf(1, 2, 8, 4, 5)
var list2 = listOf(9, 5, 9, 3)
println(list + list2)

unZip：将双元集合拆分成两个普通集合

var list4 = listOf(Pair(1,"a"), Pair(2,"b"), Pair(3,"c"))
println(list4.unzip())//得到一个Pair（[1,2,3],["a","b","c"]）

ps：通过first和secend来获取

元素相关

这个就比较多了，一些简单的我就不写示例代码了，因为和java差不多

contains、equels、indexOf、lastIndexOf这几个就不说啦

elementAt：寻找对应下标的元素，其实和get，我没找出什么不同

var list = listOf(9, 5, 9, 3)
println(list.elementAt(2))

elementAtOrElse：这个方法比较神奇

var list = listOf(9, 5, 9, 3)
println(list.elementAtOrElse(6, { it - 5 }))

因为elementAt的下标超出长度时，是会报数组越界的，而使用elementAtOrElse，就代表了当发生数组越界时，使用集合中最后一个元素经过处理后的值，我比较好奇的是，默认值就默认值，为什么还是最后一个元素经过处理后的值

first：返回符合条件的第一个元素，如果没有，会出NoSuchElementException，last同理

var list = listOf(1, 2, 8, 4, 5)
println(list.first({ it > 3 }))//返回8

ps：这个方法是可以不在first中写语句的，代表获得第一个

firstOrNull：很明显了，获取满足的第一个，如果没有返回null，lastOrNull同理

建议使用该方法

indexOfFirst，和indexOf差不多的，前者是返回第一个满足条件的下标，后者是返回最后一个满足条件的下标，都没有则返回-1，indexOfLast同理

需要和lastIndexOf进行对比，这个是返回的元素而不是下标

single：满足符合条件的单个元素，没有则异常

singleOrNull：没有就返回null

var list = listOf(1, 2, 8, 4, 5, 2)
println(list.singleOrNull({it == 2}))

注意重点：单个，此时2这个元素有两个，则返回null

这一节的内容不知不觉写了这么多，大部分都是kotlin独有的处理操作符，很明显，在方便性上比java好很多，可是，因为操作符太多，很多东西用的时候不一定想得到，可以能还是会走if 或者for的老路，所以建议大家在以后需要对集合进行处理的时候，可以先找一找有没有对应的处理办法，因为kotlin在集合操作上提供了很多东西，不用真是太可惜了。

Android开发，Kotlin的了解与学习（六）-----类与继承