Scala集合体系——数组、映射、元组

集合是一种用来存储各种对象和数据的容器

Scala集合分为可变和不可变的集合，不可变集合可以安全的并发访问

• 可变集合可以在适当的地方被更新或拓展，这意味着你可以修改，添加，移除一个集合的元素
• 不可变集合，相比之下，永远不会改变。不过，仍然可以模拟添加，移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变

Scala集合两个主要的包：

• 不可变集合：scala.collection.immutable
• 可变集合：scala.collection.mutable
• Scala默认采用不可变集合

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

定长数组Array

数据的构建

• 使用new关键字创建一个定长数组

val array = new Array[Int](30) //长度为30的整型数组,所有元素初始化为0

• 直接使用Array创建并初始化一个数组

val sArr = Array("hello","world") //长度为2的Array[String],类型是推断出来的,所以不需要new

数组的赋值

​ 数组名(index) = 值

sArr(0) = "Hello Tom" //使用()而不是[]来访问元素

获取数组元素

​ 数组名(index)

val result = sArr(1)

可变数组ArrayBuffer

对于长度按需要变化的数组，Java有ArrayList，Scala中的等效数据结构为ArrayBuffer

ArrayBuffer是一种mutable的数据容器，相对于Array来说，最大的的区别结束可以自由增删元素，ArrayBuffer构建完毕后，还可以转换为immutable的Array容器

Array和ArrayBuffer的转换

• Array与ArrayBuffer的转换

定长数组转换成变长数组

val ab = a.toBuffer

变长数组转换成定长数组

val a = array.toArray

• 数组的遍历

全遍历常用遍历

for(i <- array) println(i)

条件遍历

for(i <- array if i!= 2) println(i)

foreach

array.foreach(a => println(a))

内置常见函数

求和

Array(1,7,9).sum

求最大值

ArrayBuffer.max

排序

//升序
val b = ArrayBuffer(1,7,9,2)
val bSorted = b.sorted //1,2,7,9
b.sortWith(_<_).foreach(println(_))
//降序
b.sortWith(_>_).foreach(println(_))

显示数组内容

println(b.mkString("And")) //分隔符
println(b.mkString("<",".",">")) //<1.7.9.2>  指定前缀、分隔符、后缀

Map

在Scala中，把哈希表这种数据结构叫做映射

Map是一个对偶，映射的k-v键值对的集合，在一个map中可以包含若干组k-v映射关系，前提条件是k不能重复

Scala中的Map存储的内容是键值对（key-value），Scala中不可变的Map是有序的，可变的Map是无序的。

Scala中，有可变Map（scala.collection.mutable.Map）和不可变Map（sclaa.collection.immutable.Map）

不可变映射

val personAge = Map("Alice"->20,"Job"->18)

上述代码构造出一个不可变的Map[String,Int]，其值不能被改变

也可以用此方法创建Map

val personAges = Map(("Alice"->20),("Marry"->18))

注：->用来创建元组，“sa”->1 即 (“Alice”,20)

val personMap = Map[String,Int]("zs"->13,"ls"->14)
    val key = "ww"
    if (personMap.contains(key)) {
      val optionAge: Option[Int] = personMap.get(key)
      println(optionAge.get)

      println(personMap(key))
    }else{
      println("no key")
      println(personMap.getOrElse(key,-1)) //默认值
    }
    //personMap("ww") = 16    不可以
    println(personMap)
    println(personMap.drop(1)) //drop删除 返回一个新的集合 原来的不变

可变映射

如果想要一个可变映射，则用

val personAge = scala.collection.mutable.Map("Alice"->20,"Job"->18)

如果想从一个空的映射开始，需要选定一个映射实现并给出类型参数

val personAge = new scala.collection.mutable.HashMap[String,Int]

在Scala中，映射是对偶的集合，对偶简单地说就是两个值构成的组，这两个值并不一定是同一个类型的

遍历

		val ks = nameMap.keys
    for (key <- ks){
      val value = nameMap(key)
      println(key + "--->" + value)
    }
//Scala推荐的方式1
    for ((k,v) <- nameMap) {
      println(k + "->" + v)
    }
//Scala推荐的方式2
    for (kv <- nameMap) {
      println(kv._1 + "-->" + kv._2)
    }
//Scala推荐的方式3
    nameMap.foreach(kv => {
      println(kv._1 + "-->" + kv._2)
    })

元组Tuple

映射是键/值对的集合，对偶足元组（Tuple）的最简单形态，元组是不同类型的值的聚集。元组的值是通过将单个的值包含在圆括号中构成的。例如 (1,3.14,“abc”)是一个元组，类型为Tuple3[Int,Double,java.lang.String]

• 获取元组元素

val t = (1,3.14,"abc")
println(t._1 + "\t" + t._2 + "\t" + t._3)

val (first,second,third,fourth) = t
println(first + " " + second + third + fourth)

println("New York".partition(_.isUpper))

• 遍历元素

t.productIterator.foreach(x => println(x))

**注意：**和数组或字符串中的位置不同，元组的各组元从1开始，而不是0。可以把t._2写成t _2，即用空格而不是句点，但不能写成t_2

zip拉链操作

zip操作，就是将两个单列的集合，组合成双列的集合，集合中的每一组元素就是上述学习过的tuple。

val province = Array("河南","山东","陕西","福建","四川")
val capital = Array("郑州","济南","西安","福州")

val pcs:Array[(String,String)] = province.zip(capital) // 多余的自动裁剪
for (pc <- pcs){
  val p = pc._1
  val c = pc._2
  println(s"province:${p}, capital:${c}")
}

val pcAll:Array[(String,String)] = province.zipAll(capital,"","")  // 多余的根据提供的内容自填充	for (pc <- pcAll){
 	val p = pc._1
  val c = pc._2
  println(s"province:${p}, capital:${c}")
}