Kotlin 进阶之路(四) 集合

4.1 集合简介

• Collection

Collection 是单例集合的根接口

Collection 继承自 Iterable 接口，包含三个子类接口， List、Set、MutableCollection

上图中的虚线框标识的都是 Java 中的集合类，但是这些类可以在 Kotlin 中使用。List接口 在 Kotlin中有两个实现类，分别为 ArrayList 和 MutableList。Set 接口在 Kotlin 中也只有两个实现类，分别为 HashSet 和 MutableSet。

下表介绍了 Collection 接口的方法

• Map

Map 是双列集合的根接口，用于存储具有键 key 、值 value 映射关系的元素，每个元素都包含一对键值。

4.2 List 接口

• 不可变 List

Kotlin 中，不可变 List 是一个只读操作的集合，只有 size 属性和 get() 函数。不可变 List 通过 listOf() 函数创建。

val mList : List<Int> = listOf()
val mList : List<Int> = listOf(0)
val mList : List<Int> = listOf(1,2,3,4)

1.查询操作

isEmpty(): Boolean 判断集合是否为空

val size: Int 获取集合中元素的个数

contains(element: @UnsafeVariance E):Boolean 判断该集合中是否包含某个元素

iterator():MutableIterator< E> |返回在该集合的元素上进行迭代的迭代器

2.批量操作

containsAll(element: Collection<@UnsafeVariance E>):Boolean 判断该集合中是否包含指定集合中的所有元素

3.检索操作

get(Index : Int): E 查询集合中某个位置的元素

indexOf(element: @UnsafeVariance E>: Int 返回集合中指定元素首次出现的索引，如果不包含，则返回 -1

lastIndexOf(element: @UnsafeVariance E>: Int 返回集合中指定元素最后一次出现的索引，如果不包含，则返回 -1

subList(fromIndex: Int, toIndex: Int):List< E> 返回此集合中指定的 fromIndex 包含和 toIndex 不包含之间的集合

4.遍历操作

listIterator(): ListIterator 判断一个集合的迭代器

listIterator(index: Int): ListIterator 从指定位置开始返回集合的迭代器

fun main(args: Array<String>) {
    val list : List<Int> = listOf(0,1,2)
    list.isEmpty()//false
    list.contains(1)//true
    val iterator = list.iterator()
    while (iterator.hasNext()){
        println(iterator.next().toString())
    }
    val list1 : List<Int> = listOf(0,1,2)
    val list2 : List<Int> = listOf(0,1,2,3)
    list2.containsAll(list1)//true
    list1.get(0)//0
    list1.indexOf(1)//1
    list1.lastIndexOf(1)//1
    list1.subList(1,2)// 1
}

• 可变 MutableList

MutableList 增加了对集合中元素的添加及删除的操作，可变 MutableList 集合是使用 mutableListOf() 函数来创建对象的

1.查询操作

和 List 一样

2.修改操作

add(element E): Boolean 向集合中添加元素，如果添加成功，则返回 true，失败则为 false

add(index: Int, element: E): Unit 在指定位置添加一个元素

remove(element E):Boolean 移除集合中元素，如果移除成功，则返回 true，失败则为 false

removeAt(index : Int): E 移除指定索引处的元素

set(index:Int, element:E) : E 用指定的元素替换集合中指定位置的元素，返回该位置的原元素

3.批量操作

addAll(index: Int, elements: Collection): Boolean 向集合中添加一个集合，如果添加成功，则返回 true，失败则为 false

retainAll(elements: Collection): Boolean 判断集合是否包含一个集合，包含则返回 true，否则返回 false，并且该方法保留与指定集合中相同的对象，即求集合的交集

removeAll(elements: Collection): Boolean 移除集合中的一个集合，如果移除成功，则返回 true，失败则为 false

clear(): Unit 将集合中的元素清空

4.遍历操作

和 List 一样

fun main(args: Array<String>) {
    val muList : MutableList<Int> = mutableListOf(1,2,3)
    muList.add(4)//1,2,3,4
    muList.remove(1)//2,3,4
    muList.set(1,7)//2,7,4
    muList.add(1,5)//2,5,7,4
    muList.removeAt(2)//2,5,4
    val muList1 : MutableList<String> = mutableListOf("bj", "sh")
    val muList2 : MutableList<String> = mutableListOf("bj", "sh", "sz")
    muList2.removeAll(muList1)//muList2 [sz]
    muList2.addAll(muList1)// [sz, bj, sh]
    muList2.retainAll(muList1)//true
    muList2.clear()
}

4.3 Set 接口

• 不可变 Set

不可变 Set 同样是继承了 Collection 接口，调用 setOf() 创建， Set 和 List类似，都是只读操作的集合，区别在于 Set 中的元素具有不可重复性，重复的元素只会被记录一次。

查询操作和批量操作方法和 List 一致

• 可变 MutableSet

MutableSet 接口继承于 Set 接口与 MutableCollection 接口，使用 mutableSetOf() 创建

MutableSet 与 MutableList 类似，可对集合中元素进行添加和删除等操作。

4.4 Map 接口

• 不可变 Map

不可变 Map 通过 mapOf() 函数来创建

1.查询操作

isEmpty(): Boolean 判断集合是否为空

val size: Int 获取集合中元素的个数

containsKey(key: K): Boolean 判断该集合中是否包含指定的键

containsValue(value: @UnsafeVariance V): Boolean 判断该集合中是否包含指定的值

get(key: K): V? 根据 key（键） 获取 value（值），如果该元素存在，则返回元素的值，否则返回 null

var map = mapOf( 1 to "詹姆斯", 2 to "科比", 3 to "麦迪")
map.isEmpty()//false
map.containsKey(2)//true
map.containsValue("詹姆斯")//true
map.get(2)//科比

2.遍历操作

var mapKey = map.keys
var mapValue = map.values
println("集合中的所有key:"+mapKey)
println("集合中的所有Value:"+mapValue)
val mapEntry = map.entries
mapEntry.forEach {
    println("key: ${it.key}, value:${it.value}")
}
/*集合中的所有key:[1, 2, 3]
集合中的所有Value:[詹姆斯, 科比, 麦迪]
key: 1, value:詹姆斯
key: 2, value:科比
key: 3, value:麦迪*/

• 可变 MutableMap

可变 MutableMap 使用 mutableMapOf() 函数创建

1.修改操作

put(key: K, value: V): V? 将指定的 value 与映射中指定的 key 添加到集合中

remove(key: K): V? 移除集合中指定的 key 映射的元素

var muMap = mutableMapOf(1 to "詹姆斯", 2 to "科比", 3 to "麦迪")
muMap.put(2, "哈登")
println(muMap.values)//[詹姆斯, 哈登, 麦迪]
muMap.remove(2)
println(muMap.values)//[詹姆斯, 麦迪]

2.批量操作

putAll(from: Map<out K, V>): Unit 向集合中添加一个集合

clear(): Unit 清空集合中的映射

var muMap1 = mutableMapOf(1 to "梅", 2 to "竹", 3 to "兰")
var muMap2 = mutableMapOf(1 to "冬", 2 to "秋", 3 to "春")
muMap1.putAll(muMap2)
val entries = muMap1.entries
entries.forEach {
    println("key: ${it.key}, value:${it.value}")
}
muMap1.clear()
println("集合中元素的个数="+ muMap1.size)
/*key: 1, value:詹姆斯
key: 2, value:科比
key: 3, value:麦迪
key: 1, value:冬
key: 2, value:秋
key: 3, value:春
集合中元素的个数=0*/

后续

Kotlin 进阶之路(五) Lambda 编程