Kotlin——集合

时间:2021-6-9 作者:qvyue

Kotlin——集合

Kotlin的集合类由两个接口派生:Collection和Map。Collection和Map是Java集合框架的根接口,Kotlin的集合被分为:可变集合和不可变集合,只有可变集合才能添加、删除、修改元素。不可变集合只能读取元素

Kotlin为Collection接口派生了一个子接口。MutableCollection,该子接口又包含两个子接口:MutableSet和MutableList。这一分支就代表了Kotlin的可变集合。而Collection直接派生的Set、List接口则代表了不可变集合

Kotlin——集合
Collection集合体系
  • 可变集合接口、可变集合类是不可变集合接口、不可变类的子接口或子类
  • 每个接口下都有一个抽象实现类
    Kotlin在JVM平台上并未真正实现HashSet、LinkedHashSet、ArrayList这些类,只是为Java的HashSet、LinkedHashSet、ArrayList指定了一个类型别名而已,这样就直接借用了Java的集合类

Set集合

Kotlin的Set集合和Java的Set集合的功能基本相同,Set集合只是为Collection集合增加了额外的限制:集合元素不允许重复。此外,Set集合与Collection集合提供的方法大致相同

声明和创建Set集合

  • setOf():该函数返回不可变的Set集合。该函数可接受0个或多个参数,这些参数将作为集合的元素
  • mutableSetOf():该函数返回可变的MutableSet集合,该函数可接受0个或多个参数,这些参数将作为集合的元素
  • hashSetOf():该函数返回可变的HashSet集合,该函数可接受0个或多个参数,这些参数将作为集合的元素
  • linkedSetOf():该函数返回可变的LinkedHashSet集合
  • sortedSetOf():该函数返回可变的TreeSet集合
 //创建不可变集合
    var set = setOf("java","Kotlin","Go")
    println(set)
    //创建可变集合
    var mutableSetOf = mutableSetOf("java", "Kotlin", "Go")
    println(mutableSetOf)
    println("setof的返回对象的实际类型${set.javaClass}") //LinkedHashSet
    println("mutableSetOf的返回对象的实际类型${mutableSetOf.javaClass}") //LinkedHashSet
    //创建HashSet集合
    var hashSetOf = hashSetOf("Java", "Kotlin", "Go","Go")
    println(hashSetOf)//不保证元素顺序 但是元素时唯一的
    //创建LinkedHashSet集合
    var linkedSetOf = linkedSetOf("Java", "Kotlin", "Go", "Java")
    println(linkedSetOf) //元素顺序和添加时元素顺序一致
    //创建tree集合
    var sortedSetOf = sortedSetOf("Java", "Kotlin", "Go")
    println(sortedSetOf)//按照元素大小排序,添加元素唯一

使用Set提供的方法

与前面介绍的Array类相似,除Java原生Set的各种方法之外,Kotlin的Set还扩展了大量方法,在Set集合中有很多方法与Array的方法功能相似。

遍历Set

Kotlin也支持使用 for-in循环遍历Set,与遍历数组的方式基本相同

fun traverseCollection() {
    var books = setOf("a","b","c","d")
    for (book in books){
        println(book)
    }
}

for-in循环自动迭代Set的每个元素,当每个元素都被迭代一次后,for-in循环自动结束
Set集合童工了indices方法放回其索引的区间

fun indicesSet() {
    var items = setOf("aa","bb","cc","dd","ee")
    for (i in items.indices) {
        println(items.elementAt(i))
    }
}

可变的Set

使用mutableSetOf()、hashSetOf()、linkedSetOf()、sortedSetOf()函数返回的集合都是可变的

添加元素

Set提供了add(element: E)方法来添加元素

 var languages = mutableSetOf("Swift")
    //使用set add添加元素
    languages.add("object")
    languages.add("Go")
    println(languages)
    println("languages的长度${languages.count()}")

删除元素

Set提供了如下方法来删除元素

  • remove(element:E) 删除指定元素 删除成功返回true
  • removeAll(elements: Collection) 批量删除Set集合中的多个元素
  • retainAll(elements:Collection) 只保留Set集合中与elements集合共有的元素
  • clear() 清空集合
fun removeSetElement() {
    var skills = mutableSetOf("Kotlin", "OC", "PHP", "Java")
    skills.remove("OC")
    skills.removeAll(setOf("PHP","Java"))
    println(skills)
    skills.clear()
    println(skills.count())
}

Set和MutableSet都包含一个iterator()方法,但普通Set的iterator()方法返回的是Iterator对象。该Iterator对象只有hasNext()和next()两个方法,而MutableSet的iterator()方法返回的是MutableIterator对象,该对象除hasNext()和next()两个方法外,还提供一个remove()方法,该方法可用于在遍历时删除元素

fun setIteartor() {
    var guns = mutableSetOf( "AK74U","AK47M","M4A1","AWP")
    var it = guns.iterator()
    while (it.hasNext()) {
        var next = it.next()
        if (next == "M4A1") {
            it.remove()
        }
    }
    println(guns)
}

List集合

与Java类似,List集合的最大特征就是:集合元素允许重复,集合元素顺序有序

声明和创建List集合

  • listOf():创建不可变的List集合
  • listOfNotNull():返回不可变的List集合,该函数会自动去掉传入的一系列参数中的null值,也就是说该函数返回的List集合不包含null值
  • mutableListOf():该函数返回可变的MutableList集合
  • arrayListOf():该函数返回可变的ArrayList集合
fun listCreate() {
    //创建不可变list
    var list1 = listOf(1, 2, 3, 4)
    println(list1)
    //创建不可变不为空list集合
    var listOfNotNull = listOfNotNull(null, "it's", "not", "empry", "list")
    println(listOfNotNull)
    //创建可变集合
    var mutableList = mutableListOf("Java", "Kotlin", "Go")
    println(mutableList)
    println("listOf返回的实际Java类型${list1.javaClass}")
    println("listOfNotNull返回的实际Java类型${listOfNotNull.javaClass}")
    println("mutableListOf返回的实际Java类型${mutableList.javaClass}")
    //创建ArrayList
    var arrayList = arrayListOf("a", "b", "c")
    println(arrayList)
}

使用List提供的方法

List同样提供了与Set相似的集合操作方法,List还提供了Set没有提供的方法

  • get: 访问集合中的元素 等同于[]
  • indexOf: 返回集合元素在List中的索引
  • lastIndexOf:返回集合元素在List中最后一次出现的位置
  • subList:返回List集合的子集合
fun listAPI() {
    var list = listOf("Java", "Android", "Swift", "C++")
    for (i in list.indices) {
        var s = list[i]//等同于 list.get(i)
        println(s)
    }
    //获取指定元素出现的索引值
    var indexOf = list.indexOf("Android")
    println("Android在list中的索引${indexOf}")
    //获取list的子集合
    var subList = list.subList(1, 3)
    println(subList)
}

可变的List

使用mutableListOf()、arrayListOf()函数返回的List集合都是可变集合。
可变集合list支持增加、删除、替换

fun mutableList() {
    //创建可变集合
    var mutableList = mutableListOf("Kotlin", null, "Java", "Android")
    //在索引2处插入ios元素
    mutableList.add(2, "ios")
    println(mutableList)
    //删除索引为0的元素
    mutableList.removeAt(0)
    println(mutableList)
    //删除null
    mutableList.remove(null);
    println(mutableList)
    //替换索引为2的元素为 swift
    mutableList[2] = "swift"
    println(mutableList)
    //清空数据元素
    mutableList.clear()
    print(mutableList.count())
}

Map集合

Kotlin的Map集合同样用于保存key-value:Java不同的是,Kotlin的Map集合也被分为可变和不可变的

声明和创建Map集合

实际上Kotlin并没有真正为JVM平台实现任何Map集合类

  • mapOf():该函数返回不可变的Map集合,该函数可接受0个或多个key-value对,这些key-value对将作为Map的元素
  • mutableMapOf():该函数返回可变的MutableMap集合。
  • hashMapOf():该函数返回可变的HashMap集合
  • linkedMapOf():该函数返回可变的LinkedHashMap集合
  • sortedMapOf():该函数返回可变的TreeMap集合
  //创建不可变的Map集合
    var map = mapOf("java" to "good", "kotlin" to "greate", "c++" to "god")
    println(map)
    //创建可变的map
    var mutableMap = mutableMapOf("a" to 123, "b" to 234, "c" to 345)
    println(mutableMap)
    println(println("mapOf返回的java类型${map}"))
    println("mutableMapOf返回的java类型${mutableMap}")
    //创建HashMap集合
    var hashMap = hashMapOf("h" to 1, "a" to 2, "s" to 3, "h" to 4)
    println(hashMap) //无序map集合
    //创建LinkedHashMap
    var linkedMap = linkedMapOf("kk" to "hh", "aa" to "bb", "cc" to "dd")
    println(linkedMap)//按添加顺序map集合
    //创建treemap集合
    var treemap = sortedMapOf("tree" to null,"map" to "useful")
    println(treemap)//按元素从小到大排序map

kotlin需要使用to指定key-value对,其中to之前的是key to 之后的是value

使用Map的方法

Kotlin对Map集合的扩展的方法与Set集合提供的方法大致相似

遍历Map

Kotlin的Map集合遍历,可以通过遍历key-value对来实现
Kotlin的Map提供了operator修饰的get()方法,因此可通过[]根据key来获取value

 var map = mapOf("Java" to 86, "Kotlin" to 79, "Android" to 70)
    //遍历Map的key-value键值对
    for (en in map.entries) {
        println("key----${en.key},value----${en.value}")
    }
    //先遍历map的key 再通过key获取value
    for (key in map.keys) {
        println("key${key}***value${map.get(key)}")
    }
    //直接使用for in 遍历
    for ((key,value) in map){
        println("key ${key}@@@@@value ${value}")
    }
    

可变的Map

使用mutableMapOf()、hashMapOf()、linkedMapOf()、sortedMapOf()函数返回的集合时可变的 返回的类型依次是 HashMap、LinkedHashMap、TreeMap
创建可变集合后可以对Map集合进行添加、删除、替换

  • clear() 清空所有的key-value对
  • put(key: K,value: V)放入key-value对,若存在则替换
  • putAll(Map):批量放入多个key-value对
  • remove(key:K) 删除key-value对
  • set(key,value):可以使用[]运算符来放入key-value
 //创建可变集合
    var mutableMap = mutableMapOf("OC" to 100,"Android" to 80,"IOS" to 70)
    //以[]放入key-value对
    mutableMap["MAC"] = 200
    println(mutableMap)
    //put放入
    mutableMap.put("python",300)
    //删除key为Android的值
    var removeValue = mutableMap.remove("Android")
    println("删除remove${removeValue}")
    println(mutableMap)
    println("size${mutableMap.size}")
    //清除所有元素
    mutableMap.clear()
    println("size${mutableMap.size}")
声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎发送邮件至:qvyue@qq.com 进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。