Scala 高阶:集合内容汇总(上篇)

Posted 百思不得小赵

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Scala 高阶:集合内容汇总(上篇)相关的知识,希望对你有一定的参考价值。

@TOC

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

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

不可变和可变:

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

二、数组(Array)

不可变数组

如何定义?

val array = new Array[Int](10)
  • 集合类型大多都支持泛型,语法是[Type],不同于java的&lt;Type&gt;
  • [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("--"))
  
  • 第二种创建方式使用 apply 方法创建数组对象
  • 添加元素时在前,对象在前,在后,对象在后。
  • 访问元素使用()运算符,通过apply/update方法实现,源码中的实现只是抛出错误作为存根方法(stab method),具体逻辑由编译器填充。

    可变数组

    如何定义?

 val arr = new ArrayBuffer[Int]()
  • [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

可变与不可变集合转换

  • 不可变数组转可变数组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)

多维数组
定义:

  val array = Array.ofDim[Int](2, 3)

举个栗子:


    // 创建二维数组
    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))

三、列表(List)

不可变List

如何定义?

val list: List[Int] = List(1,2,3,4,3)
  • List 默认为不可变集合,数据有序且可重复
  • sealed修饰的一个抽象的密封类。提供了一个约束,打包密封在当前文件内,当前类的子类不能定义在文件之外。
  • 本身是一个抽象类,不能使用new对象的方式,使用半生对象的apply方法进行创建
  • 遍历集合
    list.foreach(println)
  • 访问元素
    println(list(1))
  • 添加元素 +: :+首尾添加元素,Nil空列表,::添加元素到表头
    val list2 = list.+:(10)
    val list3 = list :+ 20

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

可变ListBuffer

如何定义?

    import scala.collection.mutable

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

四、Set集合

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

不可变Set

如何创建?

 val set1 = Set(12,78,90,56,78,12,34,23)
  • 默认为不可变的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)

可变Set

如何创建?

    val set1 = mutable.Set(12,78,90,56,78,12,34,23)
  • 添加元素: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)

五、Map集合

不可变Map

如何创建?

 val map1: Map[String, Int] = Map("a" -> 13, "b" -> 21, "hello" -> 80)
  • 默认为不可变的Map。
  • 元素key -&gt; 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"))

可变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,......)
  • 元组中最大能有22个元素,Tuple1定义到了Tuple22
  • 访问元组:_顺序号
  • 通过索引访问元素tuple.productElement(index)
  • 遍历元组:for (elem &lt;- 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)
  

本次Scala集合内容汇总的上篇到这里就结束了,内容篇幅较长,干货满满,希望对大家学习Scala语言有所帮助!!!

以上是关于Scala 高阶:集合内容汇总(上篇)的主要内容,如果未能解决你的问题,请参考以下文章

Scala 高阶:集合内容汇总(下篇)

scala 目录

Scala集合概述:IterableSeqMap

Scala函数式编程之集合操作总结

从零学scala集合模式匹配和样例类

scala04.数据结构(重点)