Scala集合操作

Seq

数组类型

Array

1. 是什么

   Array是一个长度不可变的序列，在底层是用Java的数组存储，存在于scala.collection.immutable包中，会自动导入

2. 定义

   // 该方法实际调用了的伴生对象的apply方法，从而省去了new关键字
   var arr1 = Array[Int](1, 2, 3, 4, 5)

3. 添加元素（数组长度是不可变的，所以添加元素时会返回一个新的数组）

   // 在尾部添加元素
   var arr2 = arr1 :+ 6
   
   // 在头部添加元素
   var arr3 = -1 +: 0 +: arr2
   
   // 将两个数组相加
   var arr4 = arr2 ++ arr3

ArrayBuffer

1. 是什么

   ArrayBuffer是一个可变的数组，在底层使用Java数组，存在于scala.collection.mutable包中，需要额外导入

2. 定义

   var arr1 = ArrayBuffer[Int](1, 2, 3, 4, 5)
   var arr2 = ArrayBuffer[Int](6, 7, 8, 9, 10)

3. 添加元素（可以直接添加）

   // 在尾部添加元素
   arr1 += 6
   
   // 在头部添加元素
   0 +=: arr1
   
   // 在右边添加数组中所有元素，arr2中的元素会被添加到arr1
   arr1 ++= arr2
   
   // 在左边添加数组中所有元素，arr1中的元素会被添加到arr2
   arr1 ++=: arr2

互相转换

// Array转为ArrayBuffer
var arr1 = Array[Int](1, 2, 3, 4, 5)
var arr2 = arr1.toBuffer

// ArrayBuffer转为Array
var arr1 = ArrayBuffer[Int](1, 2, 3, 4, 5)
var arr2 = arr1.toArray

链表类型

List

1. 是什么

   底层是一个链表，长度不可更改

2. 定义

   // 创建一个空列表
   var list1 = List[Int]()
   var list2 = Nil
   
   // 创建一个有元素的列表
   var list1 = List[Int](1,2,3,4,5)

3. 添加元素

   // 在尾部添加元素
   var list2 = list1 :+ 6
   var list2 = list :: 6
   
   // 在头部添加元素
   var list3 = 0 +: list2
   var list3 = 0 :: list2
   
   // 合并两个列表
   var list4 = list1 ++ list1
   var list4 = list1 ::: list1

ListBuffer

1. 是什么

   底层是一个链表，长度可以更改

2. 定义

   // 创建一个空列表
   var list1 = ListBuffer[Int]()
   
   // 创建一个有元素的列表
   var list1 = ListBuffer[Int](1,2,3,4,5)

3. 添加元素

   // 在尾部添加元素
   list1 += 6
   
   // 在头部添加元素
   0 +=: list1
   
   // 在右边添加列表中所有，arr2中的元素会被添加到arr1
   list1 ++= list2
   
   // 在左边添加列表中所有元素，arr1中的元素会被添加到arr2
   list1 ++=: list2

Set

哈希

immutable.Set

1. 是什么

   底层是一个HashSet，元素无序不重复，长度不可更改

2. 定义

   // 创建一个集合
   var set1 = Set[Int](1,2,3,4,5)

3. 添加元素

   // 添加元素
   var set2 = set1 + 6
   
   // 合并两个列表
   var set2 = set1 ++ set1

mutable.Set

1. 是什么

   底层是一个HashSet，元素无序不重复，长度可更改

2. 定义

   import scala.collection.mutable
   
   // 创建一个集合
   var set1 = mutable.Set[Int](1,2,3,4,5)

3. 添加元素

   // 添加元素
   set1 += 6
   
   // 合并两个集合，将set2中的元素添加到set1中
   set1 ++= set2

Map

哈希

immutable.Map

1. 是什么

   底层是一个HashMap，长度不可更改

2. 定义

   // 创建一个Map，两种方式
   var map1 = Map[String, Int](("a", 97), ("b", 98), ("c", 99))
   var map2 = Map[String, Int]("a"-> 97, "b" -> 98, "c" -> 99)

3. 遍历

   // 按照元组遍历所有元素
   for (kv <- map1) {
       println(kv)
   }
   
   // 输出所有的value
   for ((k, v) <- map1) {
       println(v)
   }
   
   for (kv <- map1) {
       println(kv._2)
   }
   
   // 筛选出value = 98的key，模式匹配
   for ((k, 98) <- map1) {
       println(k)
   }

4. 添加或者更新

   // 添加或更新元素
   var map2 = map1 + ("d" -> 100)
   
   // 将另一个map的元素添加或更新到当前map中
   var map3 = map1 ++ map2

5. 取值

   // 如果有则返回对应值，否则返回0
   map1.getOrElse("a", 0)

mutable.Map

1. 是什么

   底层是一个HashMap，长度可更改

2. 定义

   // 创建一个Map，两种方式
   var map1 = mutable.Map[String, Int](("a", 97), ("b", 98), ("c", 99))
   var map2 = mutable.Map[String, Int]("a"-> 97, "b" -> 98, "c" -> 99)

3. 遍历

   // 按照元组遍历所有元素
   for (kv <- map1) {
       println(kv)
   }
   
   // 输出所有的value
   for ((k, v) <- map1) {
       println(v)
   }
   
   for (kv <- map1) {
       println(kv._2)
   }
   
   // 筛选出value = 98的key，模式匹配
   for ((k, 98) <- map1) {
       println(k)
   }

4. 添加或者更新

   // 添加或更新元素
   map1 += (("d", 100))
   map1 += ("d" -> 100)
   map1("d") = 100
   
   // 将另一个map的元素添加或更新到当前map中
   map1 ++= map2

5. 取值

   // 如果有则返回对应值，否则返回0
   map1.getOrElse("a", 0)
   
   // 如果有则返回对应值，否则返回0，并且当key不存在时会将此kv对添加到map中
   map1.getOrElseUpdate("a", 0)

通用操作

1. 获取头部尾部和最后一个元素

   // 获取第一个元素
   list1.head
   arr1.head
   
   // 获取最后一个元素
   list1.last
   arr1.last
   
   // 获取除了第一个元素之外的其他元素
   list1.tail
   arr1.tail
   
   // 获取除了最后一个元素之外的其他元素
   list1.init
   arr1.init