Kotlin集合简介

前言

简单记录一下Kotlin集合的使用以及如何遍历List，Set和Map，记录于此，方便自己查阅。

正文

集合按照其存储结构可以分为两大类，即单列集合Collection和双列集合Map。

Collection

Collection是所有单列集合的父接口，List和Set是其子类。

1. List的特点是元素有序、元素可重复。

2. Set的特点是元素无序并且不可重复。

List

List分为可变集合MutableList（Read&Write，Mutable）和不可变集合List（ReadOnly，Immutable）。其中可变集合MutableList可以对集合中的元素进行增加和删除的操作，不可变集合List对集合中的元素仅提供只读操作。

1. 元素有序

2. 元素可重复

不可变List

不可变List是一个只读操作的集合，只有size属性和get()函数。

var listInt1 = listOf<Int>()
var listInt2 = listOf(1, 2, 3)
var listInt3 = listOfNotNull(1,2,3)

打印后结果，分别如下：

[]
[11, 22, 33]
[11, 22, 33]

下面列举一下遍历的方式。

1. 方式1

//方式1 
var listInt = listOfNotNull(7, 1, 9, 0, 10)
var intIterator = listInt.listIterator()
while (intIterator.hasNext()) {
    Log.d(TAG, "listInt [" + intIterator.nextIndex() + "]: " + intIterator.next())
}

结果

listInt [0]: 7
listInt [1]: 1
listInt [2]: 9
listInt [3]: 0
listInt [4]: 10

2. 方式2

//方式2
var listInt = listOfNotNull(7, 1, 9, 0, 10)
for( item in listInt){
    Log.d(TAG, "listInt : $item")
}

3. 方式3

//方式3
var listInt = listOfNotNull(7, 1, 9, 0, 10)
listInt.forEach {
    Log.d(TAG, "listInt : $it")
}

4. 方式4

//方式4
var listInt = listOfNotNull(7, 1, 9, 0, 10)
for( index in listInt.indices){
    Log.d(TAG, "listInt:  "+ listInt.get(index))
}

5. 方式5

var listInt = listOfNotNull(7, 1, 9, 0, 10)
for((index,item) in listInt.withIndex()){
    Log.d(TAG, "listInt[$index]: $item ")
}

6. 方式6

var listInt = listOfNotNull(7, 1, 9, 0, 10)
var array = listInt.toIntArray()
for (item in array) {
    Log.d(TAG, "listInt :$item ")
}

MutableList

MutableList是List集合中的可变集合，MutableList＜E＞接口继承于List＜E＞接口和Mutable Collection＜E＞接口，增加了对集合中元素的添加及删除的操作。

新增功能

1. 删除

2. 添加

var listInt1 = mutableListOf<Int>()
var listInt2 = mutableListOf(10, 12, 0);

打印后结果，分别如下：

test :[] 
test :[10, 12, 0]

遍历方式一样，略过。

Set

Set接口和List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致。

1. 元素无序

2. 元素不重复

不可变Set

var set = setOf(0, 1,0,2,3,4)
var set1 = setOfNotNull(0, 1,0,2,3,4)

输出

[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4]

下面列举一下遍历的方式。

1. 方式1

var set = setOf(0, 1,0,2,3,4)
var iterator = set.iterator()
while (iterator.hasNext()) {
    Log.d(TAG, "set : "+ iterator.next())
}

2. 方式2

var set = setOf(0, 1,0,2,3,4)
for( item in set){
    Log.d(TAG, "set : $item")
}

3. 方式3

var set = setOf(0, 1, 0, 2, 3, 4)
set.forEach() {
    Log.d(TAG, "set : $it ")
}

4. 方式4

var set = setOf(0, 1, 0, 2, 3, 4)
var array = set.toIntArray()
for (item in array) {
    Log.d(TAG, "set : $item ")
}

5. 方式5

var set = setOf(0, 1,0,2,3,4)
for((index,item) in set.withIndex()){
    Log.d(TAG, "set[$index]: $item ")
}

MutableSet

MutableSet接口继承于Set接口与MutableCollection接口，同时对Set接口进行扩展，在该接口中添加了对集合中元素的添加和删除等操作。

新增功能

1. 添加

2. 删除

可变MutableSet集合是使用mutableSetOf()函数来创建对象的

var mutableSet = mutableSetOf(2, 1, 5, 0, 3)
Log.d(TAG, "mutableSet 1 : $mutableSet")
mutableSet.add(0)
Log.d(TAG, "mutableSet 2 : $mutableSet")
mutableSet.add(10)
Log.d(TAG, "mutableSet 3 : $mutableSet")

mutableSet 1 : [2, 1, 5, 0, 3]
mutableSet 2 : [2, 1, 5, 0, 3]
mutableSet 3 : [2, 1, 5, 0, 3, 10]

不可添加重复元素。

Map

Map是双列集合类的根接口，用于存储具有键（Key）、值（Value）映射关系的元素，每个元素都包含一对键值，在使用Map集合时可以通过指定的Key找到对应的Value。

Map集合中的元素是无序可重复的，Map集合分为不可变集合Map和可变集合MutableMap两种，其中可变集合MutableMap可以对集合中的元素进行增加和删除的操作，不可变集合Map对集合中的元素仅提供只读操作。

1. 元素无序

2. 元素可重复

不可变Map

var map = mapOf(1 to 111, 2 to 222, 3 to 333)
var map1 = mapOf(1 to "百度", 2 to "谷歌", 3 to "必应")

打印

{1=111, 2=222, 3=333} 
{1=百度, 2=谷歌, 3=必应}

下面列举一下遍历的方式。

1. 方式1

 var map = mapOf(1 to "百度", 2 to "谷歌", 3 to "必应")
 map.forEach() {
     Log.d(TAG, "test : {${it.key}} to {${it.value}}")
 }

2. 方式2

var map = mapOf(1 to "百度", 2 to "谷歌", 3 to "必应")
var iterator = map.iterator()
while (iterator.hasNext()) {
    val entry: Map.Entry<Int, String> = iterator.next()
    Log.d(TAG, "test : ${entry.key} to ${entry.value}")
}

3. 方式3

var map = mapOf(1 to "百度", 2 to "谷歌", 3 to "必应")
for( item in map){
    Log.d(TAG, "test: ${item.key} to ${item.value}")
}

MutableMap

可变MutableMap集合是使用mutableMapOf ()函数来创建的.

新增功能

1. 删除

2. 添加

var mutableMap = mutableMapOf(1 to "百度", 2 to "谷歌", 3 to "必应")

遍历跟不可变map一样。

参考文章