scala day2

3.数组

3.1固定长度数组Array
a: 定义固定长度数组方法
方法一：使用new
例如：

// An array of ten integers, all initialized with zero
 val nums = new Array[Int](10)
 // A string array with ten elements, all initialized with null
 val a = new Array[String](10)

方法二：使用aaply()方法，缩写为Array("111","222")
对于有初始值的数组 则不能new
例如：

 val s = Array("Hello", "World")

b: 固定长度数组的访问使用（），而不是[]
c:固定长度Array数组类型的实现就是对应JAVA 中的Array的实现

3.2 变长数组ArrayBuffer
a:定义使用ArrayBuffer

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

   // ArrayBuffer(1)
   // Add an element at the end with +=
     b += 1
   // ArrayBuffer(1, 1, 2, 3, 5)
   // Add multiple elements at the end by enclosing them in parentheses
    b += (1, 2, 3, 5)
  // ArrayBuffer(1, 1, 2, 3, 5, 8, 13, 21)
  // You can append any collection with the ++= operator
   b ++= Array(8, 13, 21)

    // ArrayBuffer(1, 1, 2)
    // Removes the last five elements
     b.trimEnd(5)

b:在变长的buffer 的数组的末尾添加或者删除元素的花销基本为O(1)
在数组中间做插入和删除操作，涉及到元素的移位，因此是有花销的
例如：

 // ArrayBuffer(1, 1, 6, 2)
// Insert before index 2
  b.insert(2, 6)
  // ArrayBuffer(1, 1, 7, 8, 9, 6, 2)
  // You can insert as many elements as you like
   b.insert(2, 7, 8, 9)
   // ArrayBuffer(1, 1, 8, 9, 6, 2)
   b.remove(2)
   // ArrayBuffer(1, 1, 2)
   // The second parameter tells how many elements to remove
    b.remove(2, 3)

c:和定长数组Array之间通过toArray 以及toBuffer 转化

3.3 遍历
a:通过for循环
for (i <- 0 until a.length){
println(i + ": " + a(i))
}

不需要index,直接访问数组元素，
for(elem<=a) {
print(elem)
}
3.4 数组转变
for (...) yield 生成一个新的Array或者ArrayBuffer 类型
例如：

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

加上条件：

    for (elem <- a if a % 2 == 0) yield 2 * elem

3.5 通用算法
sort sum max min

3.6 多维数组
方法一：

val matrix = Array.ofDim[Double](3, 4) // Three rows, four columns
//To access an element, use two pairs of parentheses:
matrix(row)(column) = 42

方法二：

 val triangle = new Array[Array[Int]](10)
for (i <- 0 until triangle.length)
triangle(i) = new Array[Int](i + 1)

3.7 与java 互相操作
使用 scala.collection.JavaConversion 隐式转化方法 将scala转成java
例如：

 
 import
scala.collection.JavaConversions.bufferAsJavaList
import scala.collection.mutable.ArrayBuffer
// Scala to Java
val command = ArrayBuffer("ls", "-al", "/home/cay")
val pb = new ProcessBuilder(command) 

将java 转化成scala

import scala.collection.JavaConversions.asScalaBuffer
import scala.collection.mutable.Buffer
// Java to Scala
// You can’t use ArrayBuffer—the wrapped object is only guaranteed to be a Buffer
val cmd : Buffer[String] = pb.command() 

4.Map和Tuples（元组）

4.1 构造Map
a:构造immutable Map

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

b:构造mutable Map

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

c:初始化一个空Map,则需要使用Map的实现对象

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

d:Pair 可以用 ->或者（） 形式表示
例如：

 "Alice" -> 10 
  ("Alice", 10)

4.2 访问Map中的数据
a: 直接使用(key)的方式访问
例如:

 val bobsScore = scores("Bob") // Like scores.get("Bob") in Java
[b]如果scores中 含有“Bob”这个Key,则返回相应的value.否则抛出异常[/b]

b:避免异常改进

  
 val bobsScore = if (scores.contains("Bob")) scores("Bob") else 0
    上述形式的组合可以用如下的方法 
  val bobsScore = scores.getOrElse("Bob", 0)

c:map.get(key) 返回的是Option类型。
Option 类型要么是一些Value,要么就是none

4.4 更新Map的值
a:更新mutable Map
//为键“Bob”更新新的值
scores("Bob") = 10
//添加一对新的键值对
scores("Fred") = 7
//添加多个键值对
scores += ("Bob" -> 10, "Fred" -> 7)
//删除一对键值
scores -= "Alice"

b:更新immutable Map
将immutable Map + 新的键值对

  val newScores = scores + ("Bob" -> 10, "Fred" -> 7)  

得到新的immutable Map,同时也更新了Bob 的值

从一个immutable Map中删除一个key为“Alice"的键值对，生成新的immutable Map对象

 scores = scores - "Alice"

c：Map上迭代
c1:for ((k, v) <- map) process k and v
c2:或者keySet 或者values,例如：

 scores.keySet // A set such as Set("Bob", "Cindy", "Fred", "Alice")
for (v <- scores.values) println(v)

c3:反转Map:

  for ((k, v) <- map) yield (v, k)

4.5 构造 immutable SortedMaps

 val scores = scala.collection.immutable.SortedMap("Alice" -> 10,
"Fred" -> 7, "Bob" -> 3, "Cindy" -> 8)

说明：在scala中没有mutable tree map

4.6 与java 交互
import scala.collection.JavaConversions.mapAsScalaMap
[b]
将java 转成 scala:[/b]

 
val scores: scala.collection.mutable.Map[String, Int] =new   java.util.TreeMap[String, Int]

import scala.collection.JavaConversions.propertiesAsScalaMap
val props: scala.collection.Map[String, String] = System.getProperties()

[b] 将scala object 转成 java[/b]

import scala.collection.JavaConversions.mapAsJavaMap
import java.awt.font.TextAttribute._ // Import keys for map below
val attrs = Map(FAMILY -> "Serif", SIZE -> 12) // A Scala map
val font = new java.awt.Font(attrs) // Expects a Java map

4.7 Tuple元组
a:Tuple指的是values 聚合，例如:

 
 (1, 3.14, "Fred") 是一个类型为(Int, Double,   java.lang.String)
  的Tuple

b:Tuple的访问
b.1 通过 _1, _2, _3 访问Tuple中的每个组件，
例如：

 val t = (1, 3.14, "Fred")
  val second = t._2 

注意：Tuple的访问是从1开始的
b.2 tuple设置值，例如

 Sets first to 1, second to 3.14, third to "Fred"
 val (first, second, third) = t 

You can use a _ if you don’t need all components:
val (first, second, _) = t

b.3元组的使用
对于一个函数返回多个值 时非常使用

4.8 Zipping 压缩
将不同集合中的元素 根据对应位置，组合成一个bundle (Tuple),形成一个大集合，之后对这个新的集合进行操作。
例如：

 
val symbols = Array("<", "-", ">")
val counts = Array(2, 10, 2)
val pairs = symbols.zip(counts)

输出如下结果：
Array(("<", 2), ("-", 10), (">", 2))

使用情况二：转成Map
keys.zip(values).toMap