Scala数据结构笔记

集合（collection）

Scala优先使用不可变集合，所有集合都扩展自Iterable。

主要分三类：

序列（Seq，List）：有顺序的；

集（Set）：无序的；

映射（Map）：Key/Value。

下图转自scala官网：

scala.collection：

scala.collection.immutable：

scala.collection.mutable：

 

数组（）

定长数组：

1. val nums = new Array[Int](10)
2. val a1=Array(1,2,3)

scala> val nums = new Array[Int](10)
nums: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

scala> val a1=Array(1,2,3)
a1: Array[Int] = Array(1, 2, 3)

变长数组：

1. val b = ArrayBuffer[Int]()
2. val a1=ArrayBuffer(1,2,3)

scala> val b = ArrayBuffer[Int]()
b: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

scala> val a1=ArrayBuffer(1,2,3)
a1: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)

多维数组：

通过数组的数组完成，使用ofDim方法

scala> val matrix = Array.ofDim[Double](2,3)
matrix: Array[Array[Double]] = Array(Array(0.0, 0.0, 0.0), Array(0.0, 0.0, 0.0))

scala> matrix(1)(2)=18.88

scala> matrix
res20: Array[Array[Double]] = Array(Array(0.0, 0.0, 0.0), Array(0.0, 0.0, 18.88))

映射：

映射是键/值对偶的集合。

eg.构造

//构造不可变映射
scala> val ages = Map("VaVa" -> 20,"Jony J" ->24)
ages: scala.collection.immutable.Map[String,Int] = Map(VaVa -> 20, Jony J -> 24)

//构造可变映射
scala> val ages = scala.collection.mutable.Map("VaVa" -> 20,"Jony J" ->24)
ages: scala.collection.mutable.Map[String,Int] = Map(VaVa -> 20, Jony J -> 24)

//构造空映射
scala> val ages1 = new scala.collection.mutable.HashMap[String,Int]
ages1: scala.collection.mutable.HashMap[String,Int] = Map()

//对偶元祖
scala> val ages2 = Map(("VaVa",20),("Jony J",24))
ages2: scala.collection.immutable.Map[String,Int] = Map(VaVa -> 20, Jony J -> 24)

//通过key取value
scala> ages("VaVa")
res69: Int = 20

//检查映射中是否有指定的键
scala> ages.contains("aa")
res74: Boolean = false

//get返回的是option对象，要么是Some，要么是None
scala> ages.get("Jony J").get
res90: Int = 24

scala> ages.get("Jony J")
res91: Option[Int] = Some(24)


scala> ages.get("VaVa")
res88: Option[Int] = None

//如果映射中没有值，会抛出异常，所以需要进行判断
scala> ages.get("VaVa").get
java.util.NoSuchElementException: None.get
  at scala.None$.get(Option.scala:366)
  at scala.None$.get(Option.scala:364)
  ... 28 elided

//判断
scala> val vavaAge = if (ages.contains("VaVa")) ages("VaVa") else 0
vavaAge: Int = 0

//简便方法
scala> val vavaAge = ages.getOrElse("VaVa",0)
vavaAge: Int = 0

eg.更新映射的值

更新可变映射

//更新vava的年龄
scala> ages("VaVa") = 25

scala> ages
res76: scala.collection.mutable.Map[String,Int] = Map(VaVa -> 25, Jony J -> 24)

//新增映射中的值
scala> ages("Tizzy T") = 22

scala> ages
res78: scala.collection.mutable.Map[String,Int] = Map(VaVa -> 25, Jony J -> 24, Tizzy T -> 22)

//根据Key删除Value
scala> ages -= "VaVa"
res79: ages.type = Map(Jony J -> 24, Tizzy T -> 22)

不能更新不可变映射，但是可以获取一个包含所需要的更新的新映射

//构建一个不可变映射
scala> val address = Map("VaVa" -> "Shanghai","Jony J" -> "NanJing")
address: scala.collection.immutable.Map[String,String] = Map(VaVa -> Shanghai, Jony J -> NanJing)
//构建一个新的映射，实现更新不可变映射
scala> val newAddr = address + ("VaVa" -> "BeiJing")
newAddr: scala.collection.immutable.Map[String,String] = Map(VaVa -> BeiJing, Jony J -> NanJing)

迭代映射

//for循环中的模式匹配
scala> for((k,v) <- ages)
     | yield (k,v)
res80: scala.collection.mutable.Map[String,Int] = Map(Jony J -> 24, Tizzy T -> 22)

//keySet函数
scala> ages.keySet
res85: scala.collection.Set[String] = Set(Jony J, Tizzy T)

//values函数
scala> ages.values
res86: Iterable[Int] = HashMap(24, 22)

scala> for (v <- ages.values) println(v)
24
22

ps：如果想要按照插入的顺序访问所有的键，可以使用LinkedHashMap

scala> val address = scala.collection.mutable.LinkedHashMap("VaVa" -> "Shanghai","Jony J" -> "NanJing")
address: scala.collection.mutable.LinkedHashMap[String,String] = Map(VaVa -> Shanghai, Jony J -> NanJing)

元祖

概念：元祖是不同类型的值的聚集。

scala> val t = (666,3.14,"Hello")
t: (Int, Double, String) = (666,3.14,Hello)

访问组元，两种方法

元祖下标从1开始，非0

scala> t._1
res92: Int = 666

scala> import scala.language.postfixOps
import scala.language.postfixOps

scala> t _2
res94: Double = 3.14

//把第二个元素赋值给pai
scala> val pai = t._2
pai: Double = 3.14

一般我们使用模式匹配获取元祖中的组元

scala> val (one,two,three) = t
one: Int = 666
two: Double = 3.14
three: String = Hello

scala> val (one,two,_) = t
one: Int = 666
two: Double = 3.14

scala> val (one,_,three) = t
one: Int = 666
three: String = Hello

拉链操作

scala> val symbols = Array("<","-",">")
symbols: Array[String] = Array(<, -, >)

scala> val counts = Array(2,5,2)
counts: Array[Int] = Array(2, 5, 2)

scala> val pairs = symbols.zip(counts)
pairs: Array[(String, Int)] = Array((<,2), (-,5), (>,2))

scala> for((s,n) <- pairs) print (s*n)
<<----->>