2017年的google开发者大会宣布Android Studio内置kotlin支持后，我也开始接触kotlin。这一系列笔记是一个没有接触过高级语言的小白，学习kotlin的记录记录历程。
一 集合
与java不同，kotlin中的集合分为可变集合（MutableCollection）和不可变集合（Collection）。不可变集合包括了（list,set,maps等）；可变集合如（MutableList，MutableSet，MutableMap等）
下面用代码来看一下Collection的基本用法吧
kotlin中文官网-集合
Kotlin 没有专门的语法结构创建 list 或 set。 要用标准库的方法，如 listOf()、 mutableListOf()、 setOf()、 mutableSetOf()。 在非性能关键代码中创建 map 可以用一个简单的惯用法来完成：mapOf(a to b, c to d)
（1）
val writeList = mutableListOf<Int>(1,2,3,4)//----[1,2,3,4]
Log.v("Rhett","writeList = "+writeList.toString())
val readList: List<Int> = writeList//用这种方式获取的list，它和writelist指向了同一块内存的，和writelist能够改变数据不同，它只有get(),size()等方法，不能改变内存中的数据。当writelist改变数据时，readlist也会随着变化
Log.v("Rhett","readList_old = "+readList.toString())-----[1,2,3,4]
writeList.add(6)-------writelist和readlist都会变为：[1,2,3,4,6]
Log.d("Rhett","readList_new = "+readList.toString())
readList.clear()//因为是不可变集合，所以这句话是错误的
writeList.clear()//清空
Log.i("Rhett","readList_new_new = "+readList.toString())writelist和readlist都会变为[]，而不是null
（2）
val readList2: List<Int> = writeList.toList()//和上面的不同，toList 扩展方法只是复制列表项，因此返回的 list 保证永远不会改变。
//因此readlist2和writelist指向了不同的内存空间，所以后面无论writelist怎么变化，readlist2依旧保持原来的值
（3）
val writelist3: MutableList<Int> = writeList.toMutableList()//writelist3现在成为了一个有自己内存空间的对象，可以进行增删操作，他们连个之间互不影响
根据上岸的解释，一个list改变指向相同的内存的 list 也会随着变化。 如果一个 list 只存在只读引用，我们可以考虑该集合完全不可变。创建一个这样的集合的一个简单方式如下：
val items = listOf(1, 2, 3)
有时你想给调用者返回一个集合在某个特定时间的一个快照, 一个保证不会变的：
class Controller {
private val _items = mutableListOf<String>()
val items: List<String> get() = _items.toList()
}
list,set,map还有一些其他的扩展如：
val items = listOf(1,2,3,4)
Log.v("Rhett","first = "+ items.first()) // 1
Log.v("Rhett","last = "+ items.last()) // 4
Log.v("Rhett","%2==0 is "+ items.filter { it %2 ==0 }) //[2,4]
val list = mutableListOf<Int>(1,3,2,5,7,4)
list.requireNoNulls()
if(list.none(){it > 4}){
Log.v("Rhett","no item above 4 ")
}else{
Log.v("Rhett","there are some item above 4 ") //print this
}
list.sortBy { it.inc() }
Log.v("Rhett","list = "+ list.toString())//[1,2,34,5,7]
以及zip、fold、reduce 等
mao的初始化比较特殊，如下
val map = hashMapOf<String,Int>("one" to 1,"two" to 2)
Log.v("Rhett","map.one = "+map["one"])
常用的一些拓展
聚合
- any
如果至少有一个元素与指定条件相符，则返回true。
val list = listOf(1, 2, 3, 4, 5, 6)
assertTrue(list.any { it % 2 == 0 })
assertFalse(list.any { it > 10 })
- count
返回与指定条件相符的元素个数。
- fold
将对集合从第一个到最后一个元素的操作结果进行累加，并加上初始值。
- foldRight
同fold，但是，是从最后一个元素到第一个元素。
- forEach
对每个元素执行指定的操作。
- forEachIndexed
同forEach，不过同时还获得元素的索引。
list forEachIndexed { index, value
println("position $index contains a $value") }
- max
返回最大元素。如果没有元素，则返回null。
- maxBy
返回使指定函数产生最大值的第一个元素。如果没有元素，则返回null。
- min
返回最小元素，如果没有元素，则返回null。
- minBy
返回使指定函数产生最小值的第一个元素。如果没有元素，则返回null。
- none
如果没有元素与指定条件相符，则返回true。
assertTrue(list.none { it % 7 == 0 }) - reduce
同fold，但是不包括初始值。只是将对集合从第一个元素到最后一个元素的操作结果进行累加。
assertEquals(21, list.reduce { total, next -> total + next }) - reduceRight
同reduce，但是，是从最后一个元素到第一个元素。
assertEquals(21, list.reduceRight { total, next -> total + next }) - sumBy
返回集合中元素进转换函数产生值的总和。
assertEquals(3, list.sumBy { it % 2 })
筛选
drop
返回所有元素列表，但不包括前N个元素。
assertEquals(listOf(5, 6), list.drop(4))dropWhile
返回所有元素列表，但不包括第一个满足指定条件的元素。
assertEquals(listOf(3, 4, 5, 6), list.dropWhile { it < 3 })dropLastWhile
返回所有元素列表，但不包括满足指定条件的最后一个元素。
assertEquals(listOf(1, 2, 3, 4), list.dropLastWhile { it > 4 })filter
返回所有与指定条件相符的元素列表。
assertEquals(listOf(2, 4, 6), list.filter { it % 2 == 0 })filterNot
返回与指定条件不符的所有元素列表。
assertEquals(listOf(1, 3, 5), list.filterNot { it % 2 == 0 })filterNotNull
返回所有元素列表，但不包括null元素。
assertEquals(listOf(1, 2, 3, 4), listWithNull.filterNotNull())slice
返回指定索引的元素列表。
assertEquals(listOf(2, 4, 5), list.slice(listOf(1, 3, 4)))take
返回前N个元素列表。
assertEquals(listOf(1, 2), list.take(2))takeLast
返回最后N个元素列表。
assertEquals(listOf(5, 6), list.takeLast(2))takeWhile
返回满足指定条件第一个元素列表。
assertEquals(listOf(1, 2), list.takeWhile { it < 3 })
映射
- flatMap
通过遍历每个元素创建一个新集合，最后，把所有集合整合到包含所有元素的唯一列表中。
assertEquals(listOf(1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7), list.flatMap { listOf(it, it + 1) }) - groupBy
返回一个映射表，该表包括经指定函数对原始集合中元素进行分组后的元素。
assertEquals(mapOf("odd" to listOf(1, 3, 5), "even" to listOf(2, 4, 6)), list.groupBy { if (it % 2 == 0) "even" else "odd" }) - map
返回一个列表，该列表包含对原始集合中每个元素进行转换后结果。
assertEquals(listOf(2, 4, 6, 8, 10, 12), list.map { it * 2 }) - mapIndexed
返回一个列表，该列表包含对原始集合中每个元素进行转换后结果和它们的索引。
assertEquals(listOf (0, 2, 6, 12, 20, 30), list.mapIndexed { index, it -> index * it }) - mapNotNull
返回一个列表，该列表包含对原始集合中非null元素转换后的结果。
assertEquals(listOf(2, 4, 6, 8), listWithNull mapNotNull { it * 2 })
元素
contains
在集合中如果找到指定元素，则返回true。
assertTrue(list.contains(2))elementAt
返回指定索引位置的元素。如果索引超出这个集合的范围，则抛出IndexOutOfBoundsException。
assertEquals(2, list.elementAt(1))elementAtOrElse
返回指定索引位置的元素。如果索引超出这个集合的范围，则返回调用默认函数的结果。
assertEquals(20, list.elementAtOrElse(10, { 2 * it }))elementAtOrNull
返回索引位置的元素。如果索引超出这个集合的范围，则返回null。
assertNull(list.elementAtOrNull(10))first
返回与指定条件相符的第一个元素。
assertEquals(2, list.first { it % 2 == 0 })firstOrNull
返回与指定条件相符的第一个元素。如果没有找到相符的元素，则返回null。
assertNull(list.firstOrNull { it % 7 == 0 })indexOf
返回第一个元素的索引。如何集合没有包含元素，则返回-1。
assertEquals(3, list.indexOf(4))indexOfFirst
返回第一个与指定条件相符的元素索引。如果集合没有包含这样的元素，则返回 -1。
assertEquals(1, list.indexOfFirst { it % 2 == 0 })indexOfLast
返回最后一个与指定条件相符的元素索引。如果集合没有包含这样的元素，则返回 -1。
assertEquals(5, list.indexOfLast { it % 2 == 0 })last
返回与指定条件相符的最后一个元素。
assertEquals(6, list.last { it % 2 == 0 })lastIndexOf
返回最后一个元素索引。如果集合没有包含元素，则返回 -1。
val listRepeated = listOf(2, 2, 3, 4, 5, 5, 6)
assertEquals(5, listRepeated.lastIndexOf(5))
- lastOrNull
返回与指定条件相符的最后一个元素。如果没有找到这样的元素，则返回null。
val list = listOf(1, 2, 3, 4, 5, 6)
assertNull(list.lastOrNull { it % 7 == 0 })
- single
返回与指定条件相符的单一元素。如果没有或有多个相符的元素，则抛出异常。
assertEquals(5, list.single { it % 5 == 0 }) - singleOrNull
返回与指定条件相符的单一元素。如果没有找到这样元素或有找到多个这样元素，则返回null。
assertNull(list.singleOrNull { it % 7 == 0 })
生成
- merge
返回一个列表，该列表由两个集合中有相同索引元素经转换函数转换而组成的。这个列表的长度是最大集合的长度。
val list = listOf(1, 2, 3, 4, 5, 6)
val listRepeated = listOf(2, 2, 3, 4, 5, 5, 6)
assertEquals(listOf(3, 4, 6, 8, 10, 11), list.merge(listRepeated) { it1, it2 -> it1 + it2 })
partition
将原始集合拆分一对集合，一个集合包含判断条件为true的元素，另一个集合包含判断条件为false的元素。
assertEquals(Pair(listOf(2, 4, 6), listOf(1, 3, 5)), list.partition { it % 2 == 0 })plus
返回一个列表，该列表包含原始集合的所有元素和指定集合的所有元素。由于函数名称原因，我们可以使用“+”操作符。
assertEquals(listOf(1, 2, 3, 4, 5, 6, 7, 8), list + listOf(7, 8))
-zip
返回一个列表，该列表由两个集合中相同索引元素建立的元素对。这个列表长度为最短集合的长度。
assertEquals(listOf(Pair(1, 7), Pair(2, 8)), list.zip(listOf(7, 8)))
排序
- reverse
返回逆序元素列表。
val unsortedList = listOf(3, 2, 7, 5)
assertEquals(listOf(5, 7, 2, 3), unsortedList.reverse())
sort
返回所有元素分类排序列表。
assertEquals(listOf(2, 3, 5, 7), unsortedList.sort())sortBy
返回所有元素列表，其元素通过特定的比较器分类排序。
assertEquals(listOf(3, 7, 2, 5), unsortedList.sortBy { it % 3 })sortDescending
返回所有元素分类排序列表，其顺序为降序。
assertEquals(listOf(7, 5, 3, 2), unsortedList.sortDescending())sortDescendingBy
返回所有元素的分类排序列表，其顺序为通过特定排序函数结果的降序。
assertEquals(listOf(2, 5, 7, 3), unsortedList.sortDescendingBy { it % 3 })
