Scala從入門到放棄（三）Scala的數組、映射、元組和集合

1.數組

1.1定長數組和變長數組

object ArrayDemo {
  def main(args: Array[String]): Unit = {
    //初始化一個長度爲8的定長數組，其數組元素均爲0
    val arr1 = new Array[Int](8)
    //直接打印定長數組，內容爲數組的hashcode值
    println(arr1)
    //將數組轉換成數組緩衝，就能夠看到原數組中的內容了
    //toBuffer會將數組轉成數組緩衝
    println(arr1.toBuffer)

    //注意：若是new ，至關於調用了數組的apply方法，直接爲數組賦值
    //初始化一個長度爲1的定長數組
    val arr2 = Array[Int](10)
    println(arr2.toBuffer)
    println(arr2(0)) //至關於只是填入了Array

    //定義一個長度爲3的定長數組
    val arr3 =Array("hadoop","storm","spark")
    //使用（）來訪問元素
    println(arr3(1)) //運行結果:storm 下標從0開始


    println("==================變長數組=====================")

    val ab = ArrayBuffer[Int]()
    //向數組緩衝的尾部追加一個元素
    //+=尾部追加元素
    ab+=1
    //追加多個元素
    ab+=(2,3,4,5)
    //追加一個數組 ++=
    ab ++= Array(6,7)
    //追加一個數組緩衝
    ab ++=ArrayBuffer(8,9)

    //打印數組緩衝ab
    println(ab)
    //下標爲 0~1之間插入 0
    ab.insert(1,0,3,5,7,9) //運行結果:在下標爲1的位置插入0 3 5 7 9
    //刪除數組某個位置的元素用remove 後面的2 爲remove 下標爲8  9 兩個元素 遊標
    ab.remove(8,2)
    println(ab)

  }

}

運行結果

1.2 遍歷數組

• 加強for循環
• 好用的until會生成腳標， 0 until 10 包含0不包含10
  

println("==================遍歷數組=====================")

    //初始化一個數組
    val array1 = Array(1,2,3,4,5,6,7,8)
    //加強for循環
    for (i <- array1)
      print(i+"\t")
    println()

    //好用的until會生成一個Range
    //reverse是將前面生成的Range反轉
    for (i <- (0 until array1.length).reverse)
      print(i+"\t")

1.3 數組轉換

yield 關鍵字將原始的數組進行轉換會產生一個新的數組，原始的數組不變

object ArrayYieldDemo {
  def main(args: Array[String]): Unit = {
    //定義一個數組
    val arr =Array(1,2,3,4,5,6,7,8,9)
    //將偶數取出乘以10後再生成一個新的數組
    val res = for(e <- arr if e % 2==0 ) yield e * 10
    println(res.toBuffer)

    //更高級的寫法,用着更爽
    //filter是過濾器，接受一個返回值boolean的函數
    //map至關於將數組中的每個元素取出來，應用傳進去的函數

    val r = arr.filter(_ % 2 ==0).map(_*10)
    println(r.toBuffer)
  }
}

1.4 經常使用數組的算法

在Scala中，數組上的某些方法對數組進行相應的操做很是方便！

2 映射（Map）

在Scala中，把哈希表這種數據結構叫作映射

2.1 構建映射

2.2 獲取和修改映射中的值

好用的getorElse

注意：在Scala中，有兩個Map，一個是immutable包下的Map，該Map中的內容不可變，另外一個是mutable包下的Map，該Map中的內容可變

注意：一般咱們在建立一個集合時會用val這個關鍵字修飾一個變量（至關於java中的final）,那麼就意味着變量的引用不可變，該引用的內容是否是可變的，取決於這個引用指向的集合的類型

2.3 將對偶的集合轉換成映射

3 元組

映射是k/v對偶的集合，對偶是元組的最簡單的形式，元組能夠裝着多個不一樣類型的值

3.1 建立元組

3.2 獲取元組中的值

3.3拉鍊操做

zip命令能夠將多個值綁定在一塊兒（有點python 風~）

注意：若是兩個數組的元素個數不一致，拉鍊操做後生成的數組的長度爲較小的那個數組的元素的個數

4 集合

Scala的集合有三大類：序列Seq、集Set、映射Map，全部的集合都擴展自Iterable特質
在Scala中集合有可變（mutable）和不可變（immutable）兩種類型，immutable 類型的集合初始化後就不能改變了（注意與val修飾的變量進行區分）

4.1 序列

不可變的序列 import scala.collection.immutable._
在Scala中列表要麼爲空（Nil表示空列表）要麼是一個head元素加上一個tail列表
9::List（5，2）::操做符是將給定的頭和尾建立一個新的列表
注意： ::操做符是右結合的，如9 ::5 ::2 ::Nil 至關於 9::(5::(2::Nil))

object ImmutListDemo {
  def main(args: Array[String]): Unit = {
    //建立一個不可變的集合
    val lst1 = List(1,2,3)
    //將0插入到lst1的前面生成一個新的list
    val lst2 = 0::lst1
    val lst3 = lst1.::(0)
    val lst4 = 0+:lst1
    val lst5 = lst1.+:(0)

    //將一個元素添加到lst1的後面產生一個新的集合
    val lst6 = lst1 :+3

    val lst0 = List(4,5,6)

    //將2個list合併成一個新的List
    val lst7 = lst1 ++ lst0

    //將lst1插入到lst0前面生成一個新的集合
    val lst8 = lst1 ++: lst0

    //將lst0插入到lst1前面生成一個新的集合
    val lst9 = lst1. :::(lst0)
    println(lst9)
  }

}

4.2 Set

4.3 Map