scala学习之scala中的集合类型

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)
      }
    }
  }