Kotlin的集合类同样由两个接口派生：Collection和Map
Kotlin集合与Java集合不同，Java集合都是可变集合。Kotlin集合可以分为可变集合和不可变集合。只有可变集合才能添加、删除、修改元素，不可变集合只能读取元素
Kotlin为可变集合创建了一个接口MutableCollection
Kotlin在JVM平台上并未真正实现HashSet、LinkedHashSet、ArrayList这些类，只是为Java的HashSet、LinkedHashSet、ArrayList指定了一个类型别名而已。这样就可以直接借用Java的这些集合类，Kotlin为这些集合类扩展了更多的方法
Set集合
Set集合：集合元素不允许重复
声明和创建Set集合
Kotlin并没有真正为JVM平台实现任何Set集合类，只是通过别名借用了Java集合框架的类。因此推荐使用Kotlin提供的工具函数来创建Set集合
setOf()：该函数返回不可变的Set集合
mutableSetOf()：该函数返回可变的MutableSet集合
hashSetOf():返回可变的HashSet集合
linkedSetOf() 返回可变的LinkedHashSet集合
sortedSetOf() 返回可变的TreeSet集合
emptySet<T>() 用于创建没有任何元素的set集合
//创建不可变集合 set
val set = setOf<Int>(1,2,3,4,5)
//创建可变集合
val mutSet = mutableSetOf(1,2,3,4)
println(mutSet)
println("Set实际返回的集合${set.javaClass}")
println("mutableSet实际返回的集合${mutSet.javaClass}")
//创建hashSet集合
val hashSetOf = hashSetOf(1,2,3,4,5)
//linkedhashset
var linkedSetOf = linkedSetOf(1, 2, 3, 4, 5, 6)
var sortedSetOf = sortedSetOf(1, 3, 6, 7, 8, 2)
println(sortedSetOf)
注意：这里Kotlin的4个工具函数创建的Set集合都能维护元素的顺序，其中setOf()、mutableSetOf()、linkedSetOf()创建的Set集合能维护元素的添加顺序,sortedSetOf()函数创建的Set集合会按照大小对元素排序
如果希望Set集合无序，只有通过hashSetOf()函数创建Set集合才行。
使用Set集合
- all 判断是否所有集合元素都满足指定规则
- any 判断是否任一元素都满足指定规则
- associate 根据Set集合生成Map集合
- drop 按规则去除集合的部分元素
- filter 过滤
- find 查找
var set = setOf("java","c","c++","VB")
//判断是否所有的set集合元素都大于4
println(set.all { it.length > 4 })
//判断是否任一的set集合元素大于4
println(set.any { it.length > 4 })
//以lambda表达式的值为key 集合元素为value 组成map集合
var associateBy = set.associateBy { "疯狂${it}讲义" }
println(associateBy.toString())
//in !in
println("java" in set)
println("kotlin" !in set)
//对set集合进行过滤 过滤条件为元素包含B
println(set.filter { "B" in it })
//查找set集合中包含a的元素 找到返回元素 否则返回null
val findSet = set.find { "a" in it }
println(findSet)
//将set集合所有元素拼接成String
println(set.fold("") { acc, s -> acc + s })
//查找set集合中某个元素的出现位置
println(set.indexOf("java"))
//map将每个集合元素映射成新值，并返回新值组成的set
println(set.map { "--!!${it}!!--" })
//max
println(set.max())
//反转集合顺序
println(set.reversed())
//交集
var bset = setOf("Erlang","GO","java")
println(set intersect bset)
//并集
println(set union bset)
//+ -
println(set + bset)
//返回删除set集合前面两个元素后的集合
val dropSet = set.drop(2)
println("=======${dropSet}")
遍历Set集合
Kotlin支持使用for-in循环遍历Set集合
var books = hashSetOf("疯狂Java","疯狂Android","疯狂IOS","疯狂Go","疯狂Python")
for (book in books) {
println(book)
}
因为setOf()返回的set是有序的，因此可以通过索引来遍历Set集合。Set集合提供了indices方法返回索引的区间
var books = hashSetOf("疯狂Java","疯狂Android","疯狂IOS","疯狂Go","疯狂Python")
for (i in books.indices){
println(books.elementAt(i))
}
可变的Set
使用mutableSetOf()、hashSetOf()、linkedSetOf()、sortedSetOf()函数返回的集合都是可变的，可变集合可以对该集合的元素执行添加、删除操作
添加元素
- add(element:E) 添加元素到set集合中
- addAll(elements:Collection<E>) 批量添加一个集合到集合中
//创建一个可变集合
val mutableSetOf = mutableSetOf("疯狂C")
//添加一个元素
mutableSetOf.add("疯狂java")
//批量添加一个集合到set集合中
mutableSetOf.addAll(setOf("Java","Kotlin"))
println(mutableSetOf)
删除元素
- remove(element:E)删除指定元素，删除成功返回true
- removeAll(elements:Collection<E>)批量删除Set集合的多个元素
- retainAll(elements:Collection<E>)只保留set集合中与elements集合共有的元素
- clear():清空集合
var languages = mutableSetOf("java","c","c++","python","go","Ruby")
//删除c++
languages.remove("c++")
//批量删除
languages.removeAll(setOf("java","c"))
println(languages)
//清空集合
languages.clear()
可变集合返回的Iterator对象，提供了一个remove方法，该方法可用于在遍历时删除元素
var languages = mutableSetOf("java", "c", "c++", "python", "go", "Ruby")
var it = languages.iterator()
while (it.hasNext()) {
var e = it.next()
//删除元素
if (e.length < 3) {
it.remove()
}
}
println(languages)
List集合
Kotlin并未真正实现List集合，只是通过别名借用了Java体系中的ArrayList集合
声明和创建List集合
- listOf() 该函数返回不可变的List集合
- listOfNotNull() 该函数返回不可变的List集合，该函数会自动去掉传入的一系列中的null中。
- mutableListOf() 该函数返回可变的MutableList集合
- arrayListOf() 该函数返回可变的ArrayList集合
- emptyList<T>()：创建没有任何元素的List集合
val list = listOf("Java", "Kotlin", null, "Go")
val list1 = listOfNotNull("Java", "Kotlin", null, "Go")
val mutableList = mutableListOf("Java", "Kotlin", null, "Go")
println(list.javaClass)
println(mutableList.javaClass)
val arrayListOf = arrayListOf("Java", "Kotlin", null, "Go")
println(arrayListOf.javaClass)
list的初始化函数
有一个接受 List 的大小与初始化函数的构造函数，该初始化函数根据索引定义元素的值。
var listEmp = List(3,{0})
使用List的方法
Set集合支持的操作 List集合一般都支持，除此之外它还增加了通过索引操作集合元素的方法
- get: 带operator修饰的方法，因此可用[]运算符访问集合元素
- indexOf:返回集合元素在List中的索引
- lastIndexOf:返回集合元素在List中最后一次出现的位置
- subList:返回List集合的子集合
val list = listOf("Java", "Kotlin", null, "Go")
for (i in list.indices){
println(list[i])
}
//获取指定元素出现的位置
println(list.indexOf("Kotlin"))
//获取List的子集合
println(list.subList(1, 3))
可变的List
使用mutableListOf()、arrayListof()返回的List集合都是可变的，创建可变List集合后，就可以对List的元素执行添加、插入、删除、替换操作
var mutableList = mutableListOf("kotlin",null,"go","java")
//向list集合中插入
mutableList.add(2,"C++")
//删除索引为1的元素
mutableList.removeAt(1)
//删除"go"元素
mutableList.remove("go")
//将索引1处的元素替换为Basic
mutableList[1]= "Basic"
//清空集合
mutableList.clear()
Map集合
Kotlin的Map集合也分为可变和不可变，同样的Kotlin并没有真正为JVM平台实现任何Map集合类，只是通过别名借用了Java集合框架的类
声明和创建Map集合
- mapOf()：该函数返回不可变的Map集合
- mutableMapOf()：该函数返回可变的MutableMap集合
- hashMapOf()返回可变的HashMap集合
- linkedMapOf()返回可变的LinkedHashMap集合
- SortedMapOf()返回可变的TreeMap集合
var map = mapOf("java" to 1,"c" to 2,"c++" to 3)
//可变map集合
var mutableMapOf = mutableMapOf("java" to 11, "c" to 22, "c++" to 33)
println("mapOf返回的类型${map.javaClass}")
println("mutableMapOf类型${mutableMapOf.javaClass}")
var hashMap = hashMapOf("a" to 1,"b" to 2,3 to "c")
var linkedMap = linkedMapOf("a" to 1,"b" to 2,3 to "c")
var treeMap = sortedMapOf("1" to 1,"2" to 2,"3" to 3)
Kotlin需要使用to指定key-value对，其中to之前的是key,to之后的是value
使用Map的方法
//判断map集合中是否有一对 键的长度大于4 值大于10
var mapAll = map.all { it.key.length > 4 && it.value > 10 }
var mapAny = map.any { it.key.length > 4 && it.value > 10 }
//判断是否存在在map中
println("java" in map)
println("Go" !in map)
//对map进行过滤 要求包含a
println(map.filter { "a" in it.key })
//map映射值
println(map.map { "测试${it.key} 值为${it.value}" })
遍历Map
Map集合由多个key-value组成，因此遍历Map集合即可以通过对key-value对进行遍历，也可以先遍历key,再通过Key来获取对应的value进行遍历
Map也可以直接用for-in循环进行遍历，这时循环变量的类型是Entry
var map = mapOf("java" to 1,"c" to 2,"c++" to 3,"vb" to 100,"docker" to 200,"a" to 4,"Go" to 5)
//key-value对进行遍历
for(en in map.entries){
println("${en.key}${en.value}")
}
//先遍历map的key再通过key获取value
for(key in map.keys){
println("${key}${map.get(key)}")
}
//直接使用for-in遍历
for ((key,value) in map) {
println(key)
println(value)
}
//lambda foreach遍历
map.forEach({ println("${it.key}value:${it.value}") })
可变的Map
mutableMapOf()、hashMapOf()、linkedMapOf()、sortedMapOf()函数返回的集合都是可变的
可变的Map为操作key-value提供了如下的方法：
clear():清空所有的key-value
put(key:K,value:V)存储key-value对
putAll(from:Map<out K,V>):批量放入多个key-value对
remove(key:K)删除key-value对
set(key,value) => map[key]=value
var mutableMap = mutableMapOf("java" to 1,"c" to 2,"c++" to 3,"vb" to 100,"docker" to 200,"a" to 4,"Go" to 5)
mutableMap.put("Erlang",1000)
mutableMap.remove("Erlang")
mutableMap["hahha"]=22
println(mutableMap)
网友评论