scala學習之第三天：數組的特性與使用技巧

1、數組

Scala數組與Scala序列是兼容的 - 在需要Seq[T]的地方可由Array[T]代替。最后，Scala數組支持所有的序列操作。

隱式轉換

方法1：通過scala.collection.mutable.WrappedArray將數組轉換成序列

/* ---示例代碼----*/

scala> val va=Array(1,2,3)
va: Array[Int] = Array(1, 2, 3)
scala> val seq1:Seq[Int] = va
seq1: Seq[Int] = WrappedArray(1, 2, 3)

/* ---示例代碼----*/

 

方法2：通過scala.collection.mutable.ArrayOps類將數組添加到ArrayOps對象中，ArrayOps支持序列的所有方法

/* ---示例代碼----*/

scala> val va=Array(1,2,3)
va: Array[Int] = Array(1, 2, 3)
scala> va.reverse
res2: Array[Int] = Array(3, 2, 1)

/* ---示例代碼----*/

 

方法2實現原理

數據在調用序列方法時會做隱式轉換，通過調用implicit def genericArrayOps[T](xs: Array[T]): ArrayOps[T]方法，將數據添加到ArrayOps對象中

/* ---示例代碼----*/

scala> val va=Array(1,2,3)
va: Array[Int] = Array(1, 2, 3)
scala> intArrayOps(va)
res3: scala.collection.mutable.ArrayOps[Int] = [I(1, 2, 3)
scala> res3.reverse
res5: Array[Int] = Array(3, 2, 1)

scala> val ops:collection.mutable.ArrayOps[Int] = va
ops: scala.collection.mutable.ArrayOps[Int] = [I(1, 2, 3)
scala> ops.reverse
res0: Array[Int] = Array(3, 2, 1)


/* ---示例代碼----*/

 

數組泛型

沒看懂

 

2、字符串

字符串不是直接序列，但可以轉換成序列，與數據的轉換方式類似，只是類型分別為WrappedString和scala.collection.immmutable.StringOps 

 

3、容器的等價性

a、不同范疇的容器總是不能相等，即使有相同的元素也不相等，如：Set(1,2,3)與List(1,2,3)不等價。

b、同范疇下的容器相等的條件：具有相同元素並且元素具有相同順序。如：List(1,2,3)==Vector(1,2,3) ,HashSet(1,2,3)==TreeSet(3,2,1)

可變容器做HashMap的key時，這是一個陷阱

/* ---示例代碼----*/

scala> val s = Set(1,2,3)
s: scala.collection.immutable.Set[Int] = Set(1, 2, 3)
scala> val s1 = List(1,2,3)
s1: List[Int] = List(1, 2, 3)
scala> s == s1
res6: Boolean = false

scala> var ss = collection.immutable.TreeSet(1,2,3)
ss: scala.collection.immutable.TreeSet[Int] = TreeSet(1, 2, 3)
scala> var ss1 = collection.immutable.HashSet(1,2,3)
ss1: scala.collection.immutable.HashSet[Int] = Set(1, 2, 3)
scala> ss ==ss1
res7: Boolean = true

scala> import collection.mutable.{HashMap,ArrayBuffer}
import collection.mutable.{HashMap, ArrayBuffer}
scala> val buf = ArrayBuffer(1,2,3)
buf: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)
scala> val map = HashMap(buf -> 5)
map: scala.collection.mutable.HashMap[scala.collection.mutable.ArrayBuffer[Int],Int] = Map(ArrayBuffer(1, 2, 3) -> 5)
scala> map(buf)
res8: Int = 5
scala> buf(0) += 2
scala> map(buf)
java.util.NoSuchElementException: key not found: ArrayBuffer(3, 2, 3)
/* ---示例代碼----*/

 

4、懶加載實現原理

容器中自帶一些方法，對容器給入的參數進行加工處理轉換成新的容器，稱這些方法為轉換器。如（map,filter,++）。

實現轉換器有兩種途徑，一個叫緊湊法，另一個叫懶惰法（lazy）或松弛法。

緊湊法，就是一個容器及其所有單元構造成這個轉換器（transformers）。

惰性法（lazy），就是一個容器及其所有單元僅僅是構造了結果容器的代理，並且結果容器的每個單元都是按單一需求構造的。

注：這兩個概念不太好理解

個人理解：

緊湊法：就是每調一次方法就會立即執行並返回結果，然后再繼續執行下一個方法。

惰性法：每次調用方法時只返回一個結果的代理，這個結果並沒有真正處理數據，只有執行到最的一個強制性方法時，才會真正去執行。

/* ---示例代碼----*/

scala> val v =Vector(1 to 10: _*)
v: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
scala> v map (_ + 1) map(_* 2)
res11: scala.collection.immutable.Vector[Int] = Vector(4, 6, 8, 10, 12, 14, 16, 18, 20, 22)

scala> val vv = v.view
vv: scala.collection.SeqView[Int,scala.collection.immutable.Vector[Int]] = SeqView(...)
scala> val vvv = vv map(_+2) map(_*2)
vvv: scala.collection.SeqView[Int,Seq[_]] = SeqViewMM(...)
scala> vvv.force
res12: Seq[Int] = Vector(6, 8, 10, 12, 14, 16, 18, 20, 22, 24)

/* ---示例代碼----*/