Kotlin_03集合类

Kotlin集合类

本文是根据（《Kotlin极简教程》作者：陈光剑）总结摘录而来。

Kotlin的集合类没有像Scala那样自己单独来实现一套，而是在兄弟语言Java集合类的基础上进行了扩展。Kotlin的集合类中提供大量的函数式API，这些丰富的扩展函数使得我们的代码写起来更加顺畅。同时，Kotlin也汲取了Scala的集合类的优秀特性，比如引入了不可变集合类。

Kotlin的集合类分为：可变集合类（Mutable）与不可变集合类（Immutable）。
集合类型主要有3种：

• list（列表）
• set（集）
• map（映射）。

List、MutableList

//不可变集合
val list:List<Int> = listOf()
>>> list
[]
>>> list::class
class kotlin.collections.EmptyList

//可变集合
val list2 = mutableListOf<Int>()
>>> list2
[]
>>> list2::class
class java.util.ArrayList

//不可变集合转可变集合
val mlist = list.toMutableList()

遍历List元素

iterator

val list = listOf(0,1, 2, 3, 4, 5, 6,7,8,9)
>>> list
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> val iterator = list.iterator()

>>> while(iterator.hasNext()){
     println(iterator.next())
}

0
1
2

forEach

forEach是一个语法糖。实际上forEach在遍历List对象的时候，仍然使用的是iterator迭代器来进行循环遍历的

val list = listOf(1,2,3)
>>> list
[1, 2, 3]
>>> list.forEach{
    println(it)
}

1
2
3

当参数只有一个函数的时候，括号可以省略不写。
也就是说，这里面的forEach函数调用的写法，实际上与下面的写法等价：
list.forEach({
println(it)
})

List元素操作函数

List集合类的基本运算函数

过滤操作函数

映射操作函数

分组操作函数

1．groupBy(keySelector: (T) -> K): Map

排序操作符

1. reversed(): List
   倒序排列集合元素。

2. sorted和sortedDescending
   升序排序和降序排序。

3. sortedBy和sortedByDescending
   可变集合MutableList的排序操作，根据函数映射的结果进行升序排序和降序排序。

生产操作符

Set、MutableSet

类似的，Kotlin中的Set也分为：不可变Set和可变MutableSet（支持增加和删除）。
不可变Set同样是继承了Collection。MutableSet接口继承于Set, MutableCollection，同时对Set进行扩展，添加了对元素添加和删除等操作。

创建Set

Set中的元素是不可重复的（任意两个元素x, y都不相等）。这里的元素x, y不相等的意思是：

x.hashCode() ! = y.hashCode()
!x.equals(y)

结果都是true

常用的创建Set的函数如下所示：

• setOf（vararg elements: T）: Set：使用元素elements创建一个Set。

• mutableSetOf（）: MutableSet：创建一个可变Set。

初始容量

• 当元素个数n小于3，初始容量为n+1；

• 当元素个数n小于2147483647/2 + 1，初始容量为n + n/3；
  否则，初始容量为2147483647。

• 如果我们想对一个List去重，可以直接使用下面的方式：

  >>> list.toSet()
  [1, 2, 3]
  

其他set

Kotlin中的LinkedHashSet、HashSet、SortedSet、TreeSet就是直接使用的Java中的对应的集合类。
对应的创建的方法是：

• hashSetOf
• linkedSetOf
• mutableSetOf

• sortedSetOf
  代码示例如下：

  >>> val hs = hashSetOf(1,3,2,7)
  >>> hs
  [1, 2, 3, 7]
  >>> hs::class
  class java.util.HashSet
  >>> val ls = linkedSetOf(1,3,2,7)
  >>> ls
  [1, 3, 2, 7]
  >>> ls::class
  class java.util.LinkedHashSet
  >>> val ms = mutableSetOf(1,3,2,7)
  >>> ms
  [1, 3, 2, 7]
  >>> ms::class
  class java.util.LinkedHashSet
  >>> val ss = sortedSetOf(1,3,2,7)
  >>> ss
  [1, 2, 3, 7]
  >>> ss::class
  class java.util.TreeSet
  

  我们知道在Java中，Set接口有两个主要的实现类HashSet和TreeSet：

• HashSet：该类按照哈希算法来存取集合中的对象，存取速度较快。

• TreeSet：该类实现了SortedSet接口，能够对集合中的对象进行排序。
• LinkedHashSet：具有HashSet的查询速度，且内部使用链表维护元素的顺序，在对Set元素进行频繁插入、删除的场景中使用。

Kotlin并没有单独去实现一套HashSet、TreeSet和LinkedHashSet。如果我们在实际开发过程中，需要用到这些Set，就可以直接用上面的方法。

Set元素的加减操作plus minus

Kotlin中针对Set做了一些加减运算的扩展函数，例如：

operator fun Set.plus(element: T)
plusElement(element: T)
plus(elements: Iterable)
operator fun Set.minus(element: T)
minusElement(element: T)
minus(elements: Iterable)
代码示例：

>>> val ms = mutableSetOf(1,3,2,7)
>>> ms+10
[1, 3, 2, 7, 10]
>>> ms-1
[3, 2, 7]
>>>
>>> ms + listOf(8,9)
[1, 3, 2, 7, 8, 9]
>>> ms - listOf(8,9)
[1, 3, 2, 7]
>>> ms - listOf(1,3)
[2, 7]

Map、MutableMap

创建Map

在Kotlin中的Map区分了只读的Map和可编辑的Map （MutableMap、HashMap、LinkedHashMap）。Kotlin没有自己重新去实现一套集合类，而是在Java的集合类基础上做了一些扩展。

• HashMap。HashMap是基于哈希表（hash table）的Map接口的实现，以key-value的形式存在。在HashMap中，key-value是一个整体，系统会根据hash算法来来计算key-value的存储位置，我们可以通过key快速地存取value。它允许使用null值和null键。另外，HashMap中元素的顺序，随着时间的推移会发生变化。

• TreeMap。使用红黑二叉树（red-black tree）的Map接口的实现。

• LinkedHashMap。还有继承了HashMap，并使用链表实现的LinkedHashMap。LinkedHashMap保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录是先插入的记录。简单说，LinkedHashMap是有序的，它使用链表维护内部次序。

1. mapOf()
   创建一个只读空Map。示例如下：

   >>> val map1 = mapOf<String, Int>()
   >>> map1.size
   0
   >>> map1.isEmpty()
   true
   

   我们还可以用另外一个函数创建空Map：

   >>> val map2 = emptyMap<String, Int>()
   >>> map2.size
   0
   >>> map2.isEmpty()
   true
   

   空Map都是相等的：

   >>> map2==map1
   true
   

2. mapOf(pair: Pair

访问Map的元素

1. entries属性
   我们可以直接访问entries属性：

val entries: Set

Map操作符函数

总结

Kotlin的集合类没有像Scala那样自己单独来实现一套，而是在兄弟语言Java集合类的基础上进行了扩展。Kotlin的集合类中提供大量的函数式API，这些丰富的扩展函数使得我们的代码写起来更加顺畅。同时，Kotlin也汲取了Scala的集合类的优秀特性，比如引入了不可变集合类。