scala学习(数组，元组)

1. 数组相关操作

• 如果需要一个长度不变的数组，可以用Scala中的Array，提供初始值时不要使用new

val nums = new Array[Int](10) //10个整数的数组，所有元素初始化为0
val s = Array("hello","world") //提供初始值时，不需要使用new

• 对于长度按需要变化的数组，可以使用Scala中的ArrayBuffer

import scala.collection.mutable.ArrayBuffer
val a = new ArrayBuffer[Int]      //一个空的缓冲数组，准备存放整数
b += 1                            //用+=在缓冲数组尾部添加元素
b += (1,2,3)                      //在尾端添加多个元素，用括号括起来
b ++= Array(8,13,21)              //用++=操作符追加任何集合
b.trimEnd(5)                      //移除最后5个元素
b.insert(2,6)                     //在下标为2元素之前插入6，这种操作并不高效
b.remove(2)                       //移除下标为2的元素
b.remove(2,3)                     //移除下标为2的元素以及他后面的2个元素，一共3个元素

• 有时需要构建一个Array，但不知道最终需要装多少元素，可以先构建一个缓冲数组，然后调用b.toArray。调用a.toBuffer可以将一个数组a转化成一个缓冲数组
• 遍历数组和缓冲数组，可以用相同的代码处理这两种数据结构

 for (i <- 0 until a.length){
    ...
 }

如果想要每两个元素一跳

 for (i <- 0 until (a.length，2)){
    ...
 }

如果要从数组的尾端开始

 for (i <- (0 until a.length).reverse){
    ...
 }

• 数组转换，从一个数组或缓冲数组出发，以某种方式对它进行转换是很简单的。这些转换动作不会修改原始数组，而是产生一个全新的数组。

 val a = Array(2,3,5,7,11)
 val result = for (i <- a) yield 2 * i //result是Array(4,6,10,14,22)

for (...) yield循环创建了一个类型与原始集合相同的新集合。从数组出发，得到的是另一个数组，从缓冲数组出发，得到的是另一个缓冲数组
- 常用算法
sum方法,元素类型必须是数值类型

Array(1,7,2,9).sum  //ArrayBuffer同样适用

max和min方法：输出数组或缓冲数组中最大和最小的元素,元素必须支持比较操作
sorted方法：将数组或缓冲数组排序并返回经过排序的数组或缓冲数组，不会修改原始版本。sortWith方法，可以提供比较函数

val b = ArrayBuffer(1,7,2,9)
val bSorted = b.sorted        //bSorted是ArrayBuffer(1,2,7,9)
val bDec = b.sortWith(_ > _)  //ArrayBuffer(9,7,3,1)

• 显示数组和缓冲数组的内容，可以用mkString方法，它允许你指定元素之间的分隔符

val a = Array(1,2,7,9)
a.mkString(" and ") //"1 and 2 and 7 and 9"

• 多维数组，通过数组的数组来实现，Double的二维数组类型为Array[Array[Double]],构造这样一个数组可以用ofDim方法

val matrix = Array.ofDim[Double](3,4) //3行，4列

2. 映射与元组

• 映射是键/值 对偶 的集合，对偶是一个n = 2的元组
• 构造映射
  不可变的Map[String,Int]

val scores = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)
val scores = Map(("Alice" , 10) , ("Bob" , 3) , ("Cindy" , 8))

可变映射

val scores = scala.collection.mutable.Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)

• 用()来查找某个键对映的值

val bobsScore = scores("Bob")

如果映射并不包含请求中是用的键，则会抛出异常

• 检查映射中是否有某个指定的键，可以用contains方法
• 更新映射中的值。在可变映射中，你可以更新某个映射的值，或者添加一个新的映射关系

scores("Bob") = 10                   //更新键"Bob"对应的值，假设scores是可变的
scores("Fred") = 7                   //增加新的键/值对偶到scores
scores += (("Bob", 10) , ("Fred",7)) //增加多个关系用+=操作符
scores -= "Alice"                    //移除某个键和对应的值用-=操作符

对于不可变映射

val newScores = scores + (("Bob",10) , ("Fred",1)) //更新Bob，增加Fred
scores = scores - "Alice"                          //移除某个键

• 迭代映射
  遍历映射中所有的键值对偶

for ((k,v) <- 映射) {
    处理k和v
}

访问键或值

scores.keySet   //一个类似Set("Bob" , "Alice")的集
scores.values   

反转一个映射

for ((k,v) <- 映射) yield (v,k)

• 元组(tuple)
  元组的值是通过将单个的值包含在圆括号中构成的，例如：

val t = (1,3.14,"Fred")  //类型为Tuple(Int,Double,java.lang.String)

用_1,_2,_3访问其组元，元组的个组元从1开始

• 元组可以用于函数需要返回不止一个值的情况
• zip方法将多个值绑在一起

val symbols = Array("<","-",">")
val counts =Array(2,10,1)
val pair = symbols.zip(counts)  //输出Array(("<",2),("-",10),(">",2))