scala（六）：集合-数组、列表list、set集合、map集合、元组

一个人的牛牛

于 2022-10-24 23:36:40 发布

阅读量510

点赞数 3

分类专栏： Scala 文章标签： 1024程序员节 scala 后端大数据

本文链接：https://blog.csdn.net/qq_55906442/article/details/127457313

版权

Scala 专栏收录该内容

11 篇文章 2 订阅

订阅专栏

集合简介

（1）Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。

（2）对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本，分别位于以下两个包。

不可变集合：scala.collection.immutable

可变集合： scala.collection.mutable

不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而不会对原对象进行修改。类似于java中的String对象。

可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象。类似于java中StringBuilder对象。

（3）Set、Map是Java中也有的集合；Seq在Java中没有，List归属到Seq了，因此这里的List和Java不是同一个概念。

（4）经典的数据结构比如Queue和Stack被归属到LinearSeq(线性序列)。

（5）Scala中的Map体系有一个SortedMap，说明Scala的Map可以支持排序。

（6）IndexedSeq和LinearSeq的区别：

1）IndexedSeq是通过索引来查找和定位，因此速度快，比如String就是一个索引集合，通过索引即可定位。

2）LinearSeq是线型的，即有头尾的概念，这种数据结构一般是通过遍历来查找。

数组

不可变数组

（1）定义数组方式一

定义：val arr1 = new Array【Int】（10）

1）new是关键字；

2）[Int]是指定存放的数据类型，如果存放任意数据类型，则指定Any；

3）(10)，表示数组的大小，确定后就不可变化；

案例：

object InvarArray {
  def main(args: Array[String]): Unit = {
    //1数组定义
    val arr01 = new Array[Int](10)
    println(arr01.length)
    //2数组赋值
    //修改某个元素的值
    arr01(2) = 12
    //采用方法的形式给数组赋值
    arr01.update(3,24)
    //3遍历数组
    //查看数组
    println(arr01.mkString(","))
    //普通遍历
    for (i <- arr01) {
      println(i)
    }
    //简化遍历
    def print(e : Int) : Unit = {
      println(e)
    }
    arr01.foreach(print)
    arr01.foreach(println)
    //4增加元素.由于创建的是不可变数组，增加元素，其实是产生新的数组
    println(arr01)
    val A : Array[Int] = arr01 :+ 5
    println(A)
  }
}

（2）定义数组方式二

val arr01 = Array(1,2)

1）在定义数组时直接赋初始值。

2）使用apply方法创建数组对象。

案例：

    var arr02 = Array(1,3,"jeffry",12,15)
    println(arr02.length)
    for (i <- arr02) {
      println(i)
    }

可变数组

val arr03 = ArrayBuffer[Any](1,4,7,9)

（1）[Any]存放任意数据类型。

（2）(1,4,7,9)初始化好的4个元素。

（3）ArrayBuffer需要引入scala.collection.mutable.ArrayBuffer。

案例：

import scala.collection.mutable.ArrayBuffer

object VarArray {
  def main(args: Array[String]): Unit = {
    //1创建并赋值可变数组
    val arr03 = ArrayBuffer[Any](1,4,7,9)
    println(arr03.length)
    println(arr03.mkString(","))
    //访问元素
    println(arr03(2))
    arr03(2) = 2
    println(arr03(2))
    println("===============")
    //遍历数组
    for (i <- arr03) {
      println(i)
    }
    println("arr03.hash=" + arr03.hashCode())
    println("===============")
    //增加元素
    //追加数据
    arr03 += 4
    println(arr03)
    //向数组最后追加数据
    arr03.append(2,3)
    println(arr03)
    //向指定的位置插入数据
    arr03.insert(0,6,8)   //在0位添加6,8
    println(arr03)
    //在前面添加
    arr03.prepend(11,22)  //在前面添加11,22
    println(arr03)
    println("===============")
    //删除元素
    arr03.remove(1)   //删除1位元素
    println(arr03)
    arr03.remove(0,5)   //删除0位后5个元素
    println(arr03)
    arr03 -= 9  // 删除arr03的9的元素
    println(arr03)
    println("=============")
    //修改元素
    arr03(1) = 2
    arr03(3) = 2
    println(arr03)
  }
}

不可变数组和可变数组的转换

arr1.toBuffer //不可变数组转可变数组

arr2.toArray //可变数组转不可变数组

（1）arr1.toBuffer返回结果才是一个可变数组，arr1本身没有变化。

（2）arr2.toArray返回结果才是一个不可变数组，arr2本身没有变化。

案例：

object InvarAndVar {
  def main(args: Array[String]): Unit = {
    //创建空的可变数组
    val arr04 = ArrayBuffer[Int]()
    //追加值
    arr04.append(1,2,3,4,5,6)
    println(arr04)
    //可变=》不可变
    val newArr = arr04.toArray
    println(newArr)
    //不可变-=》可变
    val newArr02 = newArr.toBuffer
    println(newArr02)
    newArr02.append(7,8,9)
    println(newArr02)

  }
}

多维数组

定义：

val arr = Array.ofDim[Double](3,4)

说明：二维数组中有三个一维数组，每个一维数组中有四个元素。

案例：二维数组

object MuArray {
  def main(args: Array[String]): Unit = {
    //1.创建二维数组
    val array = Array.ofDim[Int](2, 3)
    //2.写入数据
    array(0)(2) = 19
    array(1)(0) = 20
    println(array.mkString(","))
    //3.访问二维数组,遍历
    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()
    }
    //以下操作一样，写法不同
    println("============")
    array.foreach(line => line.foreach(println))
    array.foreach(_.foreach(println))
  }
}

列表List

不可变list

object ListArray {
  def main(args: Array[String]): Unit = {
    //创建list集合，List默认为不可变集合
    //方法一
    val list: List[Int] = List(1, 2, 3, 4)
    println(list)
    //方法二,::方法
    val listt1 = 9 :: 8 :: 7 :: 6 :: Nil
    println(listt1)
    //遍历List
    list.foreach(println)
    //List增加数据
    //方法一
    val list1 = 6 +: list //在前面添加6
    val list2 = list1 :+ 7  //在后面添加7
    println(list2)
    //方法二
    val listt2 = listt1.::(11)  //在前面添加11
    val listt3 = 22 :: listt2  //在前面添加22
    println(listt3)
    //集合间合并：将一个整体拆成一个一个的个体，称为扁平化
    val list3 = list2 ::: listt3
    println(list3)
    val list4 = list2 ++ listt3
    println(list4)
  }
}

可变list

import scala.collection.mutable.ListBuffer

object ListArray2 {
  def main(args: Array[String]): Unit = {
    //创建list集合，List默认为不可变集合
    val listBuffer: ListBuffer[Int] = ListBuffer(1, 2, 3, 4)
    println(listBuffer)
    println("=============")
    //添加元素
    listBuffer += 11
    listBuffer.append(22)
    println(listBuffer)
    listBuffer.insert(0,10)  //在0位前添加10这个元素
    println(listBuffer)
    println("=============")
    //遍历打印
    listBuffer.foreach(println)
    println("=============")
    //修改元素
    listBuffer(1) = 20
    listBuffer.update(2,30)
    println(listBuffer)
    println("=============")
    //删除元素
    listBuffer -= 30 //删除30
    println(listBuffer)
    listBuffer.-=(20)  //删除20
    println(listBuffer)
    listBuffer.remove(0)  //删除0位元素
    println(listBuffer)
  }
}

set集合

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

不可变set

object SetArray {
  def main(args: Array[String]): Unit = {
    //set默认不可变，数据无序
    //创建集合
    val set: Set[Int] = Set(1, 2, 3, 4)
    println(set)
    val set1: Set[Int] = Set(5, 6, 7, 8,5,6)  //数据不可以重复
    println(set1)
    //遍历打印
    set.foreach(println)
    println("===========")
    for (i <- set) {
      println(i)
    }
  }

}

可变set

import scala.collection.mutable

object SetArray2 {
  def main(args: Array[String]): Unit = {
    //创建可变集合
    val set: mutable.Set[Int] = mutable.Set(1,2,3,4)
    println(set)
    //添加元素
    set += 5
    val set1 = set.+(6)
    println(set1)
    //删除元素
    set1 -= 5
    println(set1)
    val set2 = set1.-(6)
    println(set2)
    //遍历打印
    set2.foreach(println)
    println("=============")
    //打印
    println(set2.mkString(","))
  }

}

Map集合

Scala中的Map和Java类似，也是一个散列表，它存储的内容也是键值对（key-value）映射。

不可变map

object MapArray {
  def main(args: Array[String]): Unit = {
    //创建不可变集合map
    val map: Map[String, Int] = Map("a" -> 1, "b" -> 2, "c" -> 3, "d" -> 4)
    println(map)
    //访问数据
    for (e <- map.keys) {
      //使用get访问map集合的数据，会返回特殊类型Option(选项):有值（Some），无值(None)
      println(e + "=" + map.get(e).get)
    }
    //如果key不存在，返回0
    println(map.get("e").getOrElse(0))
    println(map.getOrElse("e",0))
    //循环打印
    map.foreach((kv) => {println(kv)})
  }

}

可变map

import scala.collection.mutable

object MapArray2 {
  def main(args: Array[String]): Unit = {
    //创建可变集合map
    val map: mutable.Map[String, Int] = mutable.Map("a" -> 1, "b" -> 2, "c" -> 3)
    println(map)
    //添加元素
    map += "d" -> 4
    println(map)
    //将数值10添加到集合，并把集合中原值1返回
    val maybeInt: Option[Int] = map.put("a", 10)
    println(maybeInt.getOrElse(0))  //key存在返回key值
    //删除元素
    map -= ("b","c")
    println(map)
    //修改数据
    map.update("d",20)
    map("a") = 30
    println(map)
    //打印
    map.foreach((kv) => {println((kv))})
  }
}

元组

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

注：元组中最大有22个元素。

object TupleTest {
  def main(args: Array[String]): Unit = {
    //声明元组：（元素1，元素2，元素3，元素4……）
    val tuple1 : (String,Int,String,Boolean) = ("jeffry",20,"题目",true)
    println(tuple1)
    //访问元组
    println(tuple1._1)
    println(tuple1._2)
    println("==============")
    //跳过索引访问数据
    println(tuple1.productElement(0))
    println(tuple1.productElement(1))
    println("==============")
    //通过迭代器访问数据
    for (e <- tuple1.productIterator) {
      println(e)
    }
    println("==============")

    //Map中的键值对其实就是元组,只不过元组的元素个数为2，称之为对偶
    val map = Map("a" -> 1, "b" -> 2, "c" -> 3)
    map.foreach(tuple => {println(tuple._1) + "=" + tuple._2})
  }

}

一个人的牛牛

关注

3
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
scala（六）：集合-数组、列表list、set集合、map集合、元组

（1）Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。（2）对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本，分别位于以下两个包。不可变集合：scala.collection.immutable可变集合： scala.collection.mutable不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而不会对原对象进行修改。类似于java中的String对象。
复制链接

扫一扫