Kotlin快速入門（四）——陣列與集合

摘要： 陣列和集合 Kotlin為陣列增加了一個Array 類，因此可以用面向物件的語法使用陣列。 Kotlin自己提供一套集合體系，Kotlin的集合體系拋棄了Java集合體系中的Queue 集合，但增加了可變集合和不可變集合。 ...

陣列和集合

Kotlin為陣列增加了一個Array 類，因此可以用面向物件的語法使用陣列。

Kotlin自己提供一套集合體系，Kotlin的集合體系拋棄了Java集合體系中的Queue 集合，但增加了可變集合和不可變集合。

與Java集合類似的是，依然存在List 、Set 、Map 三種集合型別。

1. 陣列

1. 建立陣列

   arrayOf()
   arrayOfNulls()
   emptyArray()
   Array(size: Int, init: (Int) -> T)
   

   fun main(args: Array<String>) {
   
   // 建立指定元素的陣列
   val arr1 = arrayOf("Java", "Kotlin", "Swift", "Go")
   
   // 建立指定長度，元素為null的陣列
   val arr2 = arrayOfNulls<Double>(4)
   
   // 建立長度為0的空陣列
   val arr3 = emptyArray<String>()
   
   // 建立指定長度，使用Lambda表示式初始化陣列元素的陣列
   // val arr4 = Array(5, { (it * 2 + 97).toChar() })
   
   // 上面提示Lambda argument should be moved out of parentheses
   // 建議把Lambda從括號中提出來
   val arr4 = Array(5) { (it * 2 + 97).toChar() }
   val strArr4 = Array(3) { "JamFF" }
   }

   其中Array<T> 類要求它的元素必須是引用型別，因此如果將基本型別存入，Kotlin會自動裝箱為包裝類的例項，因此Kotlin提供了ByteArray 、ShortArray 等8種基本資料型別的陣列。

   fun main(args: Array<String>) {
   // 基本資料型別的陣列
   val arr1 = Array(5) { it * it }
   // 基本資料型別的陣列
   val arr2 = IntArray(5) { it * it }
   }

2. 獲取和修改陣列元素

   fun main(args: Array<String>) {
   
   val strArr = arrayOf("Java", "Kotlin", "Swift", "Go")
   
   // 兩種獲取陣列元素的方式
   println(strArr.get(1))
   println(strArr[1]) // 推薦
   
   // 兩種方式修改陣列元素
   strArr.set(2, "C")
   strArr[3] = "C++" // 推薦
   println(java.util.Arrays.toString(strArr))
   }

3. 使用for-in 遍歷陣列

   fun main(args: Array<String>) {
   
   val strArr = arrayOf("Java", "Kotlin", "Swift", "Go")
   
   for (str in strArr) {
   println(str)
   }
   }

4. 使用陣列索引

   • 使用陣列size 屬性，建立區間，遍歷索引

     fun main(args: Array<String>) {
     
     val strArr = arrayOf("Java", "Kotlin", "Swift", "Go")
     
     for (i in 0 until strArr.size) {
     println(strArr[i])
     }
     }

   • 使用陣列lastIndex 屬性，建立區間，遍歷索引

     fun main(args: Array<String>) {
     
     val strArr = arrayOf("Java", "Kotlin", "Swift", "Go")
     
     for (i in 0..strArr.lastIndex) {
     println(strArr[i])
     }
     }

   • 使用陣列indices 屬性，不需要額外建立區間物件，效能最好

     fun main(args: Array<String>) {
     
     val strArr = arrayOf("Java", "Kotlin", "Swift", "Go")
     
     for (i in strArr.indices) {
     println(strArr[i])
     }
     }

   • 同時訪問陣列的索引和元素

     fun main(args: Array<String>) {
     
     val strArr = arrayOf("Java", "Kotlin", "Swift", "Go")
     
     for ((index, value) in strArr.withIndex()) {
     println("索引為${index}的元素是：$value")
     }
     }

5. 陣列的常用方法

   fun main(args: Array<String>) {
   
   val arr = arrayOf(2, 4, 5, 6)
   
   // 判斷是否所有元素的平方都大於20
   println(arr.all { it * it > 20 }) // false
   // 判斷是否由一個元素的平方大於20
   println(arr.any { it * it > 20 }) // false
   
   val a1 = arrayOf(3, 4, 5, 6)
   val a2 = arrayOf(3, 4, 5, 6)
   
   // 判斷陣列內每個元素是否相等
   println("a1和a2陣列是否相等：${a1.contentEquals(a2)}")
   
   // 複製陣列
   val b = a1.copyOf(6)
   // 列印陣列元素
   println(b.contentToString()) // [3, 4, 5, 6, null, null]
   
   // 將b陣列的索引為4（包含）到6（不包含）的元素賦值為1
   b.fill(1, 4, 6)
   println(b.contentToString()) // [3, 4, 5, 6, 1, 1]
   
   // 排序
   b.sort()
   println(b.contentToString()) // [1, 1, 3, 4, 5, 6]
   
   // 由於陣列提供了operator修飾的plus()，所以可以使用+
   println((c + d).contentToString())
   // 由於陣列提供了operator修飾的contains()，所以可以使用in
   println("Java" in c)
   }

2. 集合概述

Kotlin的集合類同樣是由連個介面派生：Collection 和Map ，但是區別是Kotlin集合分為可變集合和不可變集合。

Kotlin只提供HashSet 、HashMap 、LinkedHashSet 、LinkedHashMap 、ArrayList 這5個集合實現類，並且他們都是可變集合。不可變集合只能通過函式建立。

3. Set集合

1. 宣告和建立Set 集合

   • setOf() ：不可變的Set 集合。
   • mutableSetOf() ：可變的Set 集合。
   • hashSetOf() ：可變的HashSet 集合。
   • linkedSetOf() ：可變的LinkedHashSet 集合。
   • sortedSetOf() ：可變的TreeSet 集合。

   fun main(args: Array<String>) {
   
   // 不可變的Set集合，在目前Kotlin1.2中返回的是LinkedHashSet，元素的新增順序
   val set = setOf("Java", "Kotlin", "Go")
   // 可變的Set集合，在目前Kotlin1.2中返回的是LinkedHashSet，元素的新增順序
   val mutableSet = mutableSetOf("Java", "Kotlin", "Go")
   // 可變的HashSet集合，不保證元素的順序
   val hashSet = hashSetOf("Java", "Kotlin", "Go")
   // 可變的LinkedHashSet集合，元素的新增順序
   val linkedHashSet = linkedSetOf("Java", "Kotlin", "Go")
   // 可變的TreeSet集合，元素由小到大排序
   val treeSet = sortedSetOf("Java", "Kotlin", "Go")
   }

2. Set 的常用方法

   fun main(args: Array<String>) {
   
   // 不可變的Set集合，在目前Kotlin1.2中返回的是LinkedHashSet，元素的新增順序
   val set = setOf("Java", "Kotlin", "Go")
   
   // 判讀是否所有元素的長度都大於4
   println(set.all { it.length > 4 }) // false
   
   // 判斷是否存在一個元素長度大於四
   println(set.any { it.length > 4 }) // true
   
   // 存在contains()所以可以使用in、!in運算子
   println("Java" in set) // true
   
   // 返回刪除前面兩個元素的集合
   println(set.drop(2)) // [Go]
   
   // 過濾集合元素，要求集合元素包含"li"，如果不存在則返回size為0的集合
   println(set.filter { "li" in it }) // [Kotlin]
   
   // 查詢包含"li"的元素，存在就返回該元素，否則返回null
   println(set.find { "li" in it }) // Kotlin
   println(set.find { "JamFF" in it }) // null
   
   // 查詢某個元素出現的索引位置
   println(set.indexOf("Go")) // 2
   
   // 將集合每個元素對映為新值，返回所有新值組成的Set集合
   println(set.map { "學習$it" }) // [學習Java, 學習Kotlin, 學習Go]
   
   // 獲取最大、最小元素
   println(set.max()) // Kotlin
   println(set.min()) // Go
   
   // 反轉集合順序
   println(set.reversed()) // [Go, Kotlin, Java]
   
   val bSet = setOf("C", "Python", "Kotlin")
   
   // 計算兩個集合的交集
   println(set intersect bSet) // [Kotlin]
   // 計算兩個集合的並集
   println(set union bSet) // [Java, Kotlin, Go, C, Python]
   // 集合相加，相當於並集
   println(set + bSet) // [Java, Kotlin, Go, C, Python]
   // 集合相減，減去他們公共的元素
   println(set - bSet)// [Java, Go]
   }

3. 遍歷Set

   for-in
   forEach()
   setOf()
   

   fun main(args: Array<String>) {
   
   val set = setOf("Java", "Kotlin", "Go")
   // for-in遍歷
   for (str in set) {
   println(str)
   }
   // forEach()遍歷
   set.forEach { println(it) }
   // setOf()是有序的，可以通過索引遍歷
   for (i in set.indices) {
   println(set.elementAt(i))
   }
   }

4. 可變的Set

   1. 新增元素

      fun main(args: Array<String>) {
      
      val set = mutableSetOf("Swift")
      
      set.add("Go")
      set.addAll(setOf("Java", "Kotlin"))
      
      println(set) // [Swift, Go, Java, Kotlin]
      }

   2. 刪除元素

      fun main(args: Array<String>) {
      
      val set = mutableSetOf("Kotlin", "OC", "PHP", "Perl", "Ruby", "Go")
      
      set.remove("PHP")
      set.removeAll(setOf("Ruby", "GO"))
      
      // 保留兩個集合共有的元素
      set.retainAll(setOf("Kotlin", "Python", "C++", "Perl"))
      println(set) // [Kotlin, Perl]
      
      set.clear()
      println(set.count()) // 0
      }

4. List集合

1. 宣告和建立List 集合

   • listOf() ：不可變的List 集合。
   • listOfNotNull() ：不可變的List 集合，會去掉引數中的null 值。
   • mutableListOf() ：可變的MutableList 集合。
   • arrayListOf() ：可變的ArrayList 集合。

   fun main(args: Array<String>) {
   
   // [Kotlin, null, PHP, Go]
   println(listOf("Kotlin", null, "PHP", "Go"))
   
   // [Kotlin, PHP, Go]
   println(listOfNotNull("Kotlin", null, "PHP", "Go"))
   
   val mutableList = mutableListOf("Kotlin", null, "PHP", "Go");
   println(mutableList) // [Kotlin, null, PHP, Go]
   // mutableListOf在Kotlin1.2中，返回的其實也是ArrayList
   println(mutableList.javaClass) // class java.util.ArrayList
   
   // [Kotlin, null, PHP, Go]
   println(arrayListOf("Kotlin", null, "PHP", "Go"))
   }

2. List 的常用方法

   Set 支援的操作，List 一般都能支援，還增加里索引操作集合元素的方法。

   fun main(args: Array<String>) {
   
   val list = listOf("Kotlin", "Java", "PHP", "Go")
   
   for (i in list.indices) {
   println(list[i])
   }
   
   println(list.indexOf("Java")) // 1
   // 獲取List的子集，包左不包右
   println(list.subList(1, 3)) // [Java, PHP]
   }

3. 可變的List

   Set 支援的操作，List 一般都能支援，還增加里索引操作集合元素的方法。

   fun main(args: Array<String>) {
   
   val list = mutableListOf("Kotlin", null, "Go")
   
   list.add(2, "Java")
   
   list.removeAt(1)
   
   list[1] = "Python"
   
   list.clear()
   }

5. Map集合

1. 宣告和建立Map 集合

   • mapOf() ：不可變的Map 集合。
   • mutableMapOf() ：可變的MutableMap 集合。
   • hashMapOf() ：可變的HashMap 集合。
   • linkedMapOf() ：可變的LinkedHashMap 集合。
   • sortedMapOf() ：可變的TreeMap 集合。

   fun main(args: Array<String>) {
   
   val map = mapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
   val mutableMap = mutableMapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
   val hashMap = hashMapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
   val linkedHashMap = linkedMapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
   val treeMap = sortedMapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
   }

2. Map 常用的方法

   fun main(args: Array<String>) {
   
   val map = mapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
   
   println(map.all { it.key.length > 4 && it.value > 80 }) // false
   println(map.any { it.key.length > 4 && it.value > 80 }) // true
   
   println("Java" in map) // true
   println(map.filter { "li" in it.key }) // {Kotlin=92}
   println(map.maxBy { it.key }) // Kotlin=92
   println(map.minBy { it.value }) // Go=78
   
   val mapB = mapOf("Lua" to 67, "Kotlin" to 92, "PHP" to 73)
   println(map + mapB) // {Java=86, Kotlin=92, Go=78, Lua=67, PHP=73}
   println(map - map) // {Java=86, Kotlin=92, Go=78}
   }

   最後的相減沒有搞明白，認為應該輸出{Java=86, Go=78} ，哪怕是寫成map - map ，輸出結果還是{Java=86, Kotlin=92, Go=78} ，希望大神賜教。

3. 遍歷Map

   四種常用的遍歷方式

   fun main(args: Array<String>) {
   
   val map = mapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
   
   for (en in map.entries) {
   println("${en.key}->${en.value}")
   }
   
   for (key in map.keys) {
   println("$key->${map[key]}")
   }
   
   for ((key, value) in map) {
   println("$key->$value")
   }
   
   map.forEach { println("${it.key}->${it.value}") }
   }

4. 可變的Map

   fun main(args: Array<String>) {
   
   val map = mutableMapOf("OC" to 96, "PHP" to 3400,
   "Ruby" to 5600, "Go" to 5600)
   
   map["Swift"] = 9000
   map.put("OC", 8600)// 和上面[]效果一致
   
   map.remove("PHP")
   
   map.putAll(mapOf("Java" to 84, "Python" to 67))
   
   map.clear()
   }

重點

• 陣列
• Set 、List 、Map 三種集合的使用
• Kotlin區別Java存在不可變集合
• Kotlin的集合類較Java有更多的API