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