Scala 系列（四）—— 數組 Array

1、定長數組

在 Scala 中，若是你須要一個長度不變的數組，可使用 Array。但須要注意如下兩點：

• 在 Scala 中使用 (index) 而不是 [index] 來訪問數組中的元素，由於訪問元素，對於 Scala 來講是方法調用，(index) 至關於執行了 .apply(index) 方法。
• Scala 中的數組與 Java 中的是等價的，Array[Int]() 在虛擬機層面就等價於 Java 的 int[]。

// 10 個整數的數組，全部元素初始化爲 0
scala> val nums=new Array[Int](10)
nums: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

// 10 個元素的字符串數組，全部元素初始化爲 null
scala> val strings=new Array[String](10)
strings: Array[String] = Array(null, null, null, null, null, null, null, null, null, null)

// 使用指定值初始化，此時不須要 new 關鍵字
scala> val a=Array("hello","scala")
a: Array[String] = Array(hello, scala)

// 使用 () 來訪問元素
scala> a(0)
res3: String = hello

2、變長數組

在 scala 中經過 ArrayBuffer 實現變長數組 (又稱緩衝數組)。在構建 ArrayBuffer 時必須給出類型參數，但沒必要指定長度，由於 ArrayBuffer 會在須要的時候自動擴容和縮容。變長數組的構建方式及經常使用操做以下：

import scala.collection.mutable.ArrayBuffer

object ScalaApp {
    
  // 至關於 Java 中的 main 方法
  def main(args: Array[String]): Unit = {
    // 1.聲明變長數組 (緩衝數組)
    val ab = new ArrayBuffer[Int]()
    // 2.在末端增長元素
    ab += 1
    // 3.在末端添加多個元素
    ab += (2, 3, 4)
    // 4.可使用 ++=追加任何集合
    ab ++= Array(5, 6, 7)
    // 5.緩衝數組能夠直接打印查看
    println(ab)
    // 6.移除最後三個元素
    ab.trimEnd(3)
    // 7.在第 1 個元素以後插入多個新元素
    ab.insert(1, 8, 9)
    // 8.從第 2 個元素開始,移除 3 個元素,不指定第二個參數的話,默認值爲 1
    ab.remove(2, 3)
    // 9.緩衝數組轉定長數組
    val abToA = ab.toArray
    // 10. 定長數組打印爲其 hashcode 值
    println(abToA)
    // 11. 定長數組轉緩衝數組
    val aToAb = abToA.toBuffer
  }
}

須要注意的是：使用 += 在末尾插入元素是一個高效的操做，其時間複雜度是 O(1)。而使用 insert 隨機插入元素的時間複雜度是 O(n)，由於在其插入位置以後的全部元素都要進行對應的後移，因此在 ArrayBuffer 中隨機插入元素是一個低效的操做。

3、數組遍歷

object ScalaApp extends App {

  val a = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

  // 1.方式一 至關於 Java 中的加強 for 循環
  for (elem <- a) {
    print(elem)
  }

  // 2.方式二
  for (index <- 0 until a.length) {
    print(a(index))
  }

  // 3.方式三, 是第二種方式的簡寫
  for (index <- a.indices) {
    print(a(index))
  }

  // 4.反向遍歷
  for (index <- a.indices.reverse) {
    print(a(index))
  }

}

這裏咱們沒有將代碼寫在 main 方法中，而是繼承自 App.scala，這是 Scala 提供的一種簡寫方式，此時將代碼寫在類中，等價於寫在 main 方法中，直接運行該類便可。

4、數組轉換

數組轉換是指由現有數組產生新的數組。假設當前擁有 a 數組，想把 a 中的偶數元素乘以 10 後產生一個新的數組，能夠採用下面兩種方式來實現：

object ScalaApp extends App {

  val a = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

  // 1.方式一 yield 關鍵字
  val ints1 = for (elem <- a if elem % 2 == 0) yield 10 * elem
  for (elem <- ints1) {
    println(elem)
  }

  // 2.方式二 採用函數式編程的方式,這和 Java 8 中的函數式編程是相似的，這裏採用下劃線標表示其中的每一個元素
  val ints2 = a.filter(_ % 2 == 0).map(_ * 10)
  for (elem <- ints1) {
    println(elem)
  }
}

5、多維數組

和 Java 中同樣，多維數組由單維數組組成。

object ScalaApp extends App {

  val matrix = Array(Array(11, 12, 13, 14, 15, 16, 17, 18, 19, 20),
    Array(21, 22, 23, 24, 25, 26, 27, 28, 29, 30),
    Array(31, 32, 33, 34, 35, 36, 37, 38, 39, 40))


  for (elem <- matrix) {

    for (elem <- elem) {
      print(elem + "-")
    }
    println()
  }

}

打印輸出以下：
11-12-13-14-15-16-17-18-19-20-
21-22-23-24-25-26-27-28-29-30-
31-32-33-34-35-36-37-38-39-40-

6、與Java互操做

因爲 Scala 的數組是使用 Java 的數組來實現的，因此二者之間能夠相互轉換。

import java.util

import scala.collection.mutable.ArrayBuffer
import scala.collection.{JavaConverters, mutable}

object ScalaApp extends App {

  val element = ArrayBuffer("hadoop", "spark", "storm")
  // Scala 轉 Java
  val javaList: util.List[String] = JavaConverters.bufferAsJavaList(element)
  // Java 轉 Scala
  val scalaBuffer: mutable.Buffer[String] = JavaConverters.asScalaBuffer(javaList)
  for (elem <- scalaBuffer) {
    println(elem)
  }
}

參考資料

1. Martin Odersky . Scala 編程 (第 3 版)[M] . 電子工業出版社 . 2018-1-1
   
2. 凱.S.霍斯特曼 . 快學 Scala(第 2 版)[M] . 電子工業出版社 . 2017-7

更多大數據系列文章能夠參見 GitHub 開源項目： 大數據入門指南