当前位置：网站首页>Scala Advanced (7): Collection Content Summary (Part 1)

Scala Advanced (7): Collection Content Summary (Part 1)

2022-08-09 13:04:00 【51CTO】

文章目录

一、概述
二、数组（Array）

不可变数组
可变数组

三、列表（List）

不可变List
可变ListBuffer

四、Set集合

不可变Set
可变Set

五、Map集合

不可变Map
可变Map

六、元组

Scala中的集合与Java中的集合相类似,但是又有很多的改变,接下来我们开启Scala集合篇的学习历程吧！

一、概述

在Java中的集合分为三大类：List集合、Set集合、Map集合.其中List集合、Set集合继承自Collection.它们都是接口.
Scala 的集合有三大类：序列 Seq、集 Set、映射 Map,所有的集合都扩展自 Iterable特质.
对于几乎所有的集合类,Scala 都同时提供了可变和不可变的版本,分别位于以下两个包：不可变集合：scala.collection.immutable、可变集合： scala.collection.mutable
不可变集合,就是指该集合对象不可修改,每次修改就会返回一个新对象,而
不会对原对象进行修改.类似于 java 中的 String 对象.
可变集合,就是这个集合可以直接对原对象进行修改,而不会返回新的对象.类似
于 java 中 StringBuilder 对象
Scala中的集合都是引用类型,并不关心指向的对象中的内容,只关心当前指向的对象.
建议：在操作集合的时候,不可变用符号,可变用方法.

不可变集合

<center>整体继承图（来源于网络）

Scala 高阶（七）：Collection content summary（上篇）_元组

Scala中的Set 和 Map集合包含的类与Java相类似,不同的是Seq下面分为IndexedSeq和LinearSeq两个特质.
scala中的String就是java.lang.String,和集合无直接关系,所以是虚箭头,是通过Perdef中的低优先级隐式转换来做到的.经过隐式转换为一个包装类型后就可以当做集合了.
IndexedSeq 是通过索引来查找和定位,因此速度快,比如 String 就是一个索引集合,通过索引即可定位
LinearSeq 是线型的,即有头尾的概念,这种数据结构一般是通过遍历来查找.

可变集合
<center>整体继承图（来源于网络）

Scala 高阶（七）：Collection content summary（上篇）_scala_02

不可变和可变：

不可变指的是对象大小不可变,但是可以修改元素的值,需要注意这一点.而如果用了val不变量存储,那么指向对象的地址也不可变.
不可变集合在原集合上不能进行插入删除数据,只能返回新的集合.

二、数组（Array）

不可变数组

如何定义？

集合类型大多都支持泛型,语法是[Type],不同于java的<Type>.
[Int]是指定可以存放的数据类型,如果希望存放任意数据类型,则指定 Any
(10),表示数组的大小,确定后就不可以变化

代码如下：

object Test01_ImmutableArray {
  def main(args: Array[String]): Unit = {

    // 创建数组
    val array = new Array[Int](10)
    // 另一种方式
    val array2 = Array(10, 21, 65, 33, 78)

    // 访问数组中的元素
    println(array(0))
    println(array(1))
    println(array(2))
    println(array(3))
    
    //  修改值
    array(0) = 12
    array(2) = 23

    println(array(0))
    println(array(1))
    println(array(2))
    println("===============================")

    // 数组遍历
    // 1.普通for循环
    for (i <- 0 until array.length) {
      println(array(i))
    }

    for (i <- array.indices) println(array(i))

    // 2.增强for循环
    for (elem <- array2) println(elem)

    // 3.迭代器
    val iterator = array2.iterator
    while (iterator.hasNext) println(iterator.next())

    // 4.调用foreach方法
    array2.foreach((elem: Int) => println(elem))
    array.foreach(println)

    // 5.转换为String
    println(array2.mkString("--"))

    println("=============================")
    
    // 添加元素
    // 加到数组后面
    val newArray = array2.:+(90)
    println(array2.mkString("--"))
    println(newArray.mkString("--"))

    // 加到数组前面
    val newArray2 = newArray.+:(30)
    println(newArray2.mkString("--"))

    val newArray3 = newArray2 :+ 18
    val newArray4 = 19+:  28 +: newArray3 :+ 87 :+ 98
    println(newArray4.mkString("--"))
  }
}

     
      1.
      2.
      3.
      4.
      5.
      6.
      7.
      8.
      9.
      10.
      11.
      12.
      13.
      14.
      15.
      16.
      17.
      18.
      19.
      20.
      21.
      22.
      23.
      24.
      25.
      26.
      27.
      28.
      29.
      30.
      31.
      32.
      33.
      34.
      35.
      36.
      37.
      38.
      39.
      40.
      41.
      42.
      43.
      44.
      45.
      46.
      47.
      48.
      49.
      50.
      51.
      52.
      53.
      54.
      55.
      56.
      57.
      58.
      59.
      60.
      61.
      62.

第二种创建方式使用 apply 方法创建数组对象
添加元素时：在前,对象在前,：在后,对象在后.
访问元素使用()运算符,通过apply/update方法实现,源码中的实现只是抛出错误作为存根方法（stab method）,具体逻辑由编译器填充.

可变数组

如何定义？

[Int]表示存放整型的数据
()初始化的数据,整型默认为0
ArrayBuffer 需要引入 scala.collection.mutable.ArrayBuffer

代码实操：

    //1. 创建可变数组
    val arr = new ArrayBuffer[Int]()
    // 另一种方式
    val arr2 = ArrayBuffer(10, 21, 17, 9, 28)

    println(arr.mkString("-"))
    println(arr2)

    // 2.访问元素
    println(arr2(0))
    
    // 修改元素
    arr2(0) = 12
    println(arr2(0))

    // 3.向数组添加元素
    // :+ 主要针对不可变数组来添加元素使用的,添加完元素后必须要将其赋给一个新的数组
    val newArray1 = arr :+ 15
    
    println(arr)
    println(newArray1)
    println(arr == newArray1) //  false

    // 可变数组添加元素调用 += 方法,添加完后无需赋给新的数组对象
    // += 向后追加  +=: 向前追加
    arr += 19
    27 +=: arr
    // 推荐使用append() 方法
    // 向后追加
    arr.append(36)
    // 向前添加
    arr.prepend(11, 90, 56)
    // 在指定位置添加  arr.insert(索引位置,可变参数)
    arr.insert(1, 23, 56)

    //直接添加数组
    arr.insertAll(2, arr2)
    //    arr.appendAll()
    //    arr.prefixLength()

    // 4.删除元素
    // 删除某个位置的元素
    arr.remove(3)
    // 从索引位置开始,删除xx个数
    //    arr.remove(0,10)
    arr -= 36

     
      1.
      2.
      3.
      4.
      5.
      6.
      7.
      8.
      9.
      10.
      11.
      12.
      13.
      14.
      15.
      16.
      17.
      18.
      19.
      20.
      21.
      22.
      23.
      24.
      25.
      26.
      27.
      28.
      29.
      30.
      31.
      32.
      33.
      34.
      35.
      36.
      37.
      38.
      39.
      40.
      41.
      42.
      43.
      44.
      45.
      46.

可变与不可变集合转换

不可变数组转可变数组arr1.toBuffer 返回结果才是一个可变数组,arr1 本身没有变化
可变数组转不可变数组arr2.toArray 返回结果才是一个不可变数组,arr2 本身没有变化

举个栗子:

    // 可变数组转为不可变数组
    val array = ArrayBuffer(10, 21, 90)
    val newArray = array.toArray
    println(newArray.mkString("-"))
    println(array)

    // 不可变数组转为可变数组
    val buffer = newArray.toBuffer
    println(buffer)
    println(newArray)

     
      1.
      2.
      3.
      4.
      5.
      6.
      7.
      8.
      9.
      10.

多维数组
定义：

举个栗子：


    // 创建二维数组
    val array = Array.ofDim[Int](2, 3)

    // 访问元素
    array(0)(2) = 19
    array(1)(0) = 26

    // 遍历
    for (i <- 0 until array.length; j <- 0 until array(i).length) {
      println(array(i)(j))
    }
    for (i <- array.indices; j <- array(i).indices) {
      print(array(i)(j) + "\t")
      if (j == array(i).length - 1) println()
    }
    array.foreach(line => line.foreach(println))
    array.foreach(_.foreach(println))

     
      1.
      2.
      3.
      4.
      5.
      6.
      7.
      8.
      9.
      10.
      11.
      12.
      13.
      14.
      15.
      16.
      17.
      18.

三、列表（List）

不可变List

如何定义？

List 默认为不可变集合,数据有序且可重复
sealed修饰的一个抽象的密封类.提供了一个约束,打包密封在当前文件内,当前类的子类不能定义在文件之外.
本身是一个抽象类,不能使用new对象的方式,使用半生对象的apply方法进行创建
遍历集合

访问元素

添加元素 +: :+首尾添加元素,Nil空列表,::添加元素到表头

Nil.::(元素)创建新的列表,29 :: 99 :: 80 :: 43 :: Nil相当于给列表头部一直添加元素,定义一个新列表.
合并连个列表：list1 :: list2将list1整个列表合并到list2.
list1 ::: list2 或者list1 ++ list2 将list1的各个元素合并到list2.++底层也是调用:::

可变ListBuffer

如何定义？

可以使用new对象的方式,也可使用伴生对象的apply方法创建
添加元素 append prepend insert 添加元素到头或尾：+=: +=
合并集合：list1 ++ list2 或者 list1 ++= list2 前者得到新的列表,后者将元素合并到list1
修改元素：list(index) = value 底层调用update方法
删除元素：remove 或者 -=

四、Set集合

默认情况下,Scala 使用的是不可变集合,如果你想使用可变集合,需要引用scala.collection.mutable.Set 包

不可变Set

如何创建？

默认为不可变的Set,数据不可重复且无序.
初始化集合时数据会被去重,可以用做去重操作.
添加元素：set + 元素
合并集合： set1 ++ set2得到新的Set集合
删除元素：set - 元素

代码实操：

    // 1.创建Set
    val set1 = Set(12,78,90,56,78,12,34,23)
    println(set1)

    // 2.添加元素
    val set2 = set1 + 80
    println(set2)

    // 3.合并set
    val set3 = Set(14,25,46,57,68,91)
    val set4 = set2 ++ set3
    println(set2)
    println(set3)
    println(set4)

    // 4.删除元素
    val set5 = set3 - 14
    println(set3)
    println(set5)

     
      1.
      2.
      3.
      4.
      5.
      6.
      7.
      8.
      9.
      10.
      11.
      12.
      13.
      14.
      15.
      16.
      17.
      18.
      19.

可变Set

如何创建？

添加元素：set += 元素调用add()
删除元素：set -= 元素调用remove()
合并两个集合：set1 ++= set2

代码实操：

   // 1.创建Set
    val set1 = mutable.Set(12,78,90,56,78,12,34,23)
    println(set1)

    /// 2.添加元素
    val set2 = set1 + 32
    set1 += 88
    set1.add(30)
    
    // 3.删除元素
    set1 -= 12  
    set1.remove(23)
    
    // 4.合并两个集合
    val set3 = mutable.Set(75,90,56,39,54,51)

    val set4 = set1 ++ set3
    println(set4)
    set1 ++= set3
    println(set1)

     
      1.
      2.
      3.
      4.
      5.
      6.
      7.
      8.
      9.
      10.
      11.
      12.
      13.
      14.
      15.
      16.
      17.
      18.
      19.
      20.

五、Map集合

不可变Map

如何创建？

默认为不可变的Map.
元素key -> value 键值对儿,为二元组类型.

代码实操：

 	// 1.创建Map key -> value 键值对儿
    val map1: Map[String, Int] = Map("a" -> 13, "b" -> 21, "hello" -> 80)
    println(map1)
    println(map1.getClass)

    // 2.遍历元素
    for (elem <- map1) {
      println(elem+"")
    }
    map1.foreach(println)
    // 元组类型 (String, Int)
    map1.foreach((kv: (String, Int)) => println(kv))

    // 3.取Map中所有对Key
    for (key <- map1.keys) {
      println(s"${key} ----> ${map1.get(key)}")
    }

    // 4.访问某一个Key的value
    // 不安全的,报空指针异常
    println(map1.get("a").get)
    println(map1.get("v"))
    // 推荐使用
    println(map1.getOrElse("f", 0))

    println(map1("a"))

     
      1.
      2.
      3.
      4.
      5.
      6.
      7.
      8.
      9.
      10.
      11.
      12.
      13.
      14.
      15.
      16.
      17.
      18.
      19.
      20.
      21.
      22.
      23.
      24.
      25.
      26.

可变Map

类似于不可变的Map,直接上代码实操.

    // 1.创建Map
    val map1: mutable.Map[String, Int] = mutable.Map("a" -> 13, "b" -> 21, "hello" -> 80)
    println(map1)
    println(map1.getClass)

    // 2.添加元素
    map1.put("c",10)
    map1.put("d",21)
    println(map1)

    map1 += (("e",90))
    println(map1)

    // 3.删除元素
    println(map1.remove("e"))
    println(map1.getOrElse("e", 0))

    map1 -= "d"
    println(map1)

    // 4.修改元素
    map1.update("a",21)
    println(map1)

    // 5.合并集合
    val map2: Map[String, Int] = Map("o" -> 9, "y" -> 28, "hello" -> 80)
    // 可变加不可变
    map1 ++= map2
    println(map1)
    println(map2)
    // 不可变加可变
    val map3 = map2 ++ map1
    println(map3)

     
      1.
      2.
      3.
      4.
      5.
      6.
      7.
      8.
      9.
      10.
      11.
      12.
      13.
      14.
      15.
      16.
      17.
      18.
      19.
      20.
      21.
      22.
      23.
      24.
      25.
      26.
      27.
      28.
      29.
      30.
      31.
      32.
      33.

六、元组

元组也是可以理解为一个容器,可以存储相同或者不同类型的数据,换句话说就是将多个无关的数据封装为一个整体.

声明元组的方式：(元素 1,元素 2,元素 3,......)
元组中最大能有22个元素,Tuple1定义到了Tuple22.
访问元组：_顺序号
通过索引访问元素tuple.productElement(index)
遍历元组：for (elem <- tuple.productIterator)

举个栗子：

object Test_Tuple {
  def main(args: Array[String]): Unit = {
    // 1.创建元祖
    val tuple = ("hello", 0, false,'a')
    println(tuple)

    // 2.访问元祖数据
    println(tuple._1)
    println(tuple._2)
    println(tuple._3)
    println(tuple._4)

    println(tuple.productElement(0))

    // 3.遍历元祖
    for (elem <- tuple.productIterator){
      println(elem)
    }

    // 4.嵌套元组
    val mulTuple = (112,32,"aa",("scala",90))
    println(mulTuple._4._2)
  }
}


     
      1.
      2.
      3.
      4.
      5.
      6.
      7.
      8.
      9.
      10.
      11.
      12.
      13.
      14.
      15.
      16.
      17.
      18.
      19.
      20.
      21.
      22.
      23.
      24.
      25.