scala学习之scala中的集合类型

最新推荐文章于 2024-05-26 19:11:57 发布

airleaya

最新推荐文章于 2024-05-26 19:11:57 发布

阅读量526

点赞数 1

分类专栏：大数据学习笔记文章标签： java 数据结构列表 scala 集合

本文链接：https://blog.csdn.net/airleaya/article/details/112623455

版权

大数据学习笔记专栏收录该内容

36 篇文章 1 订阅

订阅专栏

scala学习

集合

scala的集合有三大类：序列Seq、集Set、映射Map。所有的集合都拓展自Iterable特质
对于几乎所有的集合类，scala都同时提供了可变和不可变的版本，分别位于如下包：
- 不可变集合：scala.collection.immutable
  - 对于不可变集合，其对象不可修改，每次修改都是返回一个新对象。
- 可变集合： scala.collection.mutable
  - 对于可变集合，其对象是可以修改的，每次修改就是直接对其对象进行修改，不会创建新的对象
- 不可变集合继承图：
- 可变集合继承图：

数组

不可变数组(Array)

定长数组的定义方法：val arr1 = new Array[Int](10)

new是定义的关键字
Int指定的可存放数据的类型，如果希望存放任意数据类型，则指定Any
后面括号里的10表示数组的大小，确定后不可变化

object TestArray {
  def main(args: Array[String]): Unit = {
    // 数组定义
    val arr01 = new Array[Int](10)
    println(arr01.length)

    // 数组赋值
    //  修改某个元素的值
    arr01(2) = 10
    //   采用方法的形式给数组赋值
    arr01.update(0,1)

    //  查看数组
    //   通过mkString方法转化为字符串
    println(arr01.mkString(","))
    //   普通的遍历
    for (i <- arr01){
      println(i)
    }
    //   简化后的遍历 通过array类自带的高等函数foreach
    def printx(elem:Int) : Unit = {
      println(elem)
    }
    arr01.foreach(printx)

    //  增加元素（因为是不可变的数组，所以其实是产生了新的数组
    val arr02 = arr01 :+ 5
    for (i <- arr02) {
      println(i)
    }
  }
}

另一种定义的方式：val arr1 = Array(1,2,3)

这种方式本质上是调用了apply方法创建数组对象

object TestArray {
  def main(args: Array[String]): Unit = {
    val arr1 = Array(1,2,3,"123")
    for (i <- arr1){
      println(i)
    }
  }
}

可变数组（ArrayBuffer）

定义可变数组：val arr1 = ArrayBuffer[Int](1,2,3)

ArrayBuffer需要引入scala.collection.mutable.ArrayBuffer
ArrayBuffer是有序的集合，可以通过append方法增加元素，支持可变参数。

object TestArrayBuffer {
  def main(args: Array[String]): Unit = {
    // 创建并初始化可变数组
    val arr1 = ArrayBuffer[Any](1,2,3,'a',"ab")

    // 遍历数组
    for (i <- arr1){
      println(i)
    }

    // 追加元素
    //  在最后位子追加
    arr1.append("end")
    //  向指定位置插入
    arr1.insert(0,10,11)
    println(arr1.mkString(","))
    // 修改元素
    arr1(1) = "change"

    println(arr1.mkString(","))
  }
}

可变数组与不可变数组之间的转换：
- 可以直接调用toArray或toBuffer方法进行转换
- 这两个方法都是返回一个新的数组，其本身并不会发生变化

多维数组

定义一个多维数组：val arr = Array.ofDim[Type](x,y)

创建一个包含x个一维数组的二维数组，每个一维数组长度为y

object TestArrayBuffer {
  def main(args: Array[String]): Unit = {
    val arrs = Array.ofDim[Int](3,4)
    arrs(1)(1) = 2

    // 遍历二维数组
    for(i <- arrs){
      for (j <- i){
        print(j + ",")
      }
      println()
    }
  }
}

集合（List）

不可变集合（List）

创建集合语句：val list:List[Int] = List(1,2,3,4)

注意这是不可变集合，其中的所有添加数据的操作本质都为返回一个新数组

object TestList {
  def main(args: Array[String]): Unit = {
    // List默认为不可变集合
    // 创建
    val list = List(1,2,3,4,5)
    // 空集合Nil
    // 通过::拼接数据组成数组，末尾放一个空集合Nil
    val list1 = 1::2::3::4::Nil
    // list增加数据
    //  ::符号从右向左运算
    val list2 = 6::7::8::list
    println(list2.mkString(","))
    // 将数据添加到第一个元素的位置
    val list3 = list.+:(6) // 等效于 6::list
    println(list3.mkString(","))
    //集合间合并
    val list4 = list2:::list3
    println(list4.mkString(","))
    // 通过下标随机访问
    println(list(2))
    // 遍历
    list.foreach(println)
  }
}

可变集合（ListBuffer）

案例，此处可直接向集合中添加元素而不需要创建新的集合对象

object TestList {
  def main(args: Array[String]): Unit = {
    //  创建可变集合
    val listBuffer = ListBuffer(1,2,3,4,5)

    //向集合中添加数据
    listBuffer.+=(2)

    //打印
    listBuffer.foreach(println)
  }
}

集合（Set）

默认情况下，Scala使用的是不可变集合，如果你想使用可变集合，需要引用 scala.collection.mutable.Set 包
set中的数据是无序且不可重复的

不可变Set

object TestSet {
  def main(args: Array[String]): Unit = {
    // 创建新集合
    val set = Set(1,2,3,4,5)

    // 数据不可重复
    val set1 = Set(1,1,2,3,4,5,5,5,5)

    // 遍历集合set
    set1.foreach(println)
  }
}

可变Set（mutable.Set）

import scala.collection.mutable.Set
object TestSet {
  def main(args: Array[String]): Unit = {
    // 创建mutable.Set
    val set = Set(1,2,3)

    // 向集合中添加元素
    set += 8
    println(set)

    // 添加数据并返回一个新Set
    val ints = set.+(9)
    println(ints)
    println(set)

    // 删除数据
    set -= 8
    println(set)
  }
}

集合Map

与java中的map相似，scala中的map也是一个散列表，它存储的内容为k-v映射。
在scala中，不可变的map是有序的，可变map是无序的

不可变map

object TestMap {
  def main(args: Array[String]): Unit = {
    // 创建不可变集合map
    val map = Map("a"->1, "b"->2)

    // 访问数据
    // 通过get访问map集合中的数据的话，会返回特殊的选项：
    // 有值时为：Some  无值时为：None
    for (key <- map.keys){
      println(key+": "+map.get(key).get)
    }
    println(map.get("c"))
    
    // 如果key不存在，返回0
    println(map.get("c").getOrElse(0))
    println(map.getOrElse("c",0))

    // 遍历
    map.foreach((kv) => {println(kv)})
  }
}

可变map（导入mutable包）

import scala.collection.mutable.Map
object TestMap {
  def main(args: Array[String]): Unit = {
    // 创建map集合
    val map = Map("a"->1,"b"->2)

    // 向集合中增加数据
    map.+=("c"->3)

    // 将数值4添加到集合，并把集合中原值返回
    println(map.put("a", 4).get)
    println(map)

    // 删除数据
    map.-=("a","b")
    println(map)

    // 修改数据
    map.update("c",12)
    println(map)

    // 遍历
    map.foreach((kv)=>{println("key:"+kv._1+"\tvalue:"+kv._2)})
  }
}

元组

我们可以把元组理解为一个容器，可以存放各种相同或不同类型的数据。简单来说，将多个无关的数据封装为一个整体，这个整体就是元组

元组最大只能有22个元素
map中的键值对其实就是元组，对于这种元素个数为2的元组，称之为对偶

object TestTuple {
  def main(args: Array[String]): Unit = {
    // 声明元组的方法： (元素1，元素2，元素3)
    val tuple = (1,'a',2.345,"678",true)
    // 访问元组可以直接通过._顺序号访问
    println(tuple._1)
    println(tuple._2)
    println(tuple._3)
    println(tuple._4)
    println(tuple._5)

    // 通过索引访问数据：
    println(tuple.productElement(2))
    // 迭代访问元组的数据
    for ( i <- tuple.productIterator){
      println(i)
    }
  }
}