#6 kotlin集合类型Array,List,Map

大部分的语言的集合类型都大同小异，不过看到kotlin里面集合分成了可变类型集合和不可变类型集合。它们之间用处不同，可以相互进行转换，具体使用哪一种，这个在以后的实际使用中再去了解。

1. 数组 Array

fun main() {
    
    // Array is immutable
      val en = arrayOf(2, 4, "10", 8) // 任意类型数据
    // val en2: Array<Int> = intArrayOf(2, 3, 4, 5);
    val intArray = intArrayOf(2, 3, 4, 5); // IntArray 类型
    val longArray: LongArray = longArrayOf(10, 23, 34, 90) // LongArray类型

    
    val sa = arrayOf("h", "e", "l")  
    // size property
    println("the length of sa is: ${sa.size}")
    
    // methods
    // first last isEmpty contains
    println("first item of sa: ${sa.first()} or ${sa[0]}")
    println("last item of sa: ${sa.last()}")
    println("sa is empty? ${sa.isEmpty()}")
    println("sa has 'l'? ${sa.contains("l")}")
    
    // indexOf 查找某个元素 未找到返回-1
    println("f is at index of ${sa.indexOf("f")}")
    
    // slice 截取数组部分
    var partSa = sa.slice(0..1)
    println("partSa is $partSa")
    for (ch in partSa) {
        println("ch in partSa $ch")
    }
    
    // drop dropLast
    val removeFirstOne = sa.drop(1)
    println("removeFirstOne: $removeFirstOne")
    val removeLastOne = sa.dropLast(1)
    println("removeLastOne: $removeLastOne")
}

可以看出

• 数组的初始化方式为： arrayOf()
• 不同类型的数组类型
  • IntArray
  • BooleanArray 等等类型
• 常见的一些方法，和js中的lodash库提供的方法名类似
  • size: 获取数组长度
  • first | last | isEmpty | contains 等常用方法
  • indexOf | slice | drop | dropLast

关于 IntArray 这种数据类型，和其它语言中的Int类似，但是这种写法我是第一次见，可以参考：

• kotlin 基本数据类型 - csdn

1. List

注意这个和上面的array的区别，array一般是不可变数据类型。另外这个分为可变list集合(MutableList | ArrayList)和不可变list集合(List)

fun mutableListMethod() {

  val names = listOf("kobe", "jordan")

  // 可变list 可先声明 后操作
  val teamNames = mutableListOf<String>()

  teamNames.addAll(names)

  println("now teamNames are : $teamNames")

  teamNames.add("Durant")
  teamNames.add("Harden")
}
   
// 可变示例
fun mutableExample() {
  var name = ArrayList<String>()
  name.add("sam")
  name.add("brook")

  fun printNames(names: ArrayList<String>) {
    println(names)
    // 可变类型List 使用 removeAt
    // 不可变List 不能使用移除方法
    names.removeAt(0)
  }
  printNames(name)
  println("after remove fist one of names: $name")
}

// 不可变示例
fun immutableExample() {
  var name = ArrayList<String>()
  name.add("sam")
  name.add("brook")

  // 此处使用List<String>
  fun printNames(names: List<String>) {
    println(names)
  }
  printNames(name)
  println("after remove fist one of names: $name")
}

ArrayList 相当于一个可变集合。

知识点：

• 初始化方式
  • listOf() | mutableListOf()
  • listOf<String>() 指定特定类型的键值类型
• 属性：
  • removeAt(someIndex): 可变类型list，移除某个索引位置元素
  • add(item): 可变类型list，添加某个item
  • addAll(someOtherList) : 将其它list全部添加进去

1. 字典Map

这个就是其它语言中的字典，写法有点不一样，同样也分为了可变Map，和不可变Map

fun mapMethod() {
  var namesAndScores = mapOf(
    "Anna" to 2,
    "Louis" to 23,
    "Lily" to 7
  )
  // 如果map里面不存在该key 则返回null
  println("lily's score is ${namesAndScores["Lily"]}")
  println("the count of namesAndScores: ${namesAndScores.count()}")


  // 可变map
  val mutableMap = mutableMapOf(
    "name" to "Bot",
    "age" to 12,
    "grade" to "3A2B"
  )

  // 添加新的key-value
  mutableMap["gender"] = "male"

  // remove 移除某个key-value
  mutableMap.remove("age")

  for ((key, value) in mutableMap) {
    println("$key : $value")
  }

  // 枚举所有键或值
  // mutableMap.values & mutableMap.keys
  for (value in mutableMap.values) {
    println("the value in mutableMap is $value")
  }

}

mapMethod()

fun printLocation(person: Map<String, Any>) {
    val state = if (person.containsKey("state")) person["state"] else ""
    val city = if (person.containsKey("city")) person["city"] else ""

    println("person lives in $city, $state")
}

val person = mapOf(
  "city" to "LA",
  "state" to "CA"
)

printLocation(person)

知识点：

• 初始化方式

  • mapOf() | mutableMapOf()
  • mapOf<String, String>() 指定特定类型的键值类型

• 属性：

  • count(): 获取map长度
  • remove(someKey): 通过key值移除某个key-value
  • values | keys : 获取map中的所有值或者keys
  • containsKey(someKey): 是否包含某个key

• 键值对的写法

  • key to value， 其中 to 是关键词

此文只是粗略的认识一下kotlin中的集合类型，还有 Set 集合类型，未讲到，这个基本和JS中的 Set 类型类似。

初步印象，有几点疑惑：

• 为什么要把数组和list进行区分
• 还有就是ArrayList，List，IntArray... wtf
• 为什么要分为可变类型集合和不可变类型集合

大致觉得是不同类型的集合效率不同，但是个人感觉增加了复杂度😝

对于集合的基础知识，掘金上有一篇文章写的挺好的：

• Kotlin——高级篇（四）：集合（Array、List、Set、Map）基础 - Jetictors

2019年07月26日00:54:34