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)
        }
      }
    }
    
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值