scala (4) 可變數組和不可變數組

在scala中數組分為不可變長數組（在immutable包下）和可變長數組（在mutable包下）

不可變長數組指的是長度不可變，但是數組中角標對應的元素的值是可變的

可變數組指的是長度和數組中角標對應的元素都是可變的。

object ArrayDemo {
  def main(args: Array[String]): Unit = {
    /**
      * 不可變數組一旦初始化，數組的長度就是不可變的，不能往數組中添加任
      * 何元素
      */
    val arr = Array[Int](1, 2, 3, 4, 5)

    // 如果數組中,有不同類型的元素,那么這個數組的類型就是這些元素的公共父類型 Any
    val arr1: Array[Any] = Array(1, 2, "leo")

    // 創建了一個數組,給數組的初始化長度為5,每個角標的初始長度和泛型的初始值一致，也就是 0
    val arr2 = new Array[Int](5)

    // 創建一個數組,數組的長度是 1 ,數組的元素是 5
    val arr3 = Array(5)

    // ++ 運算符合並兩個數組,原來的數組並沒有改變,只是生成了個新的數組。
    val arr4 = arr ++ arr2

    /**
      * 可變長數組
      */
    val buffer1 = ArrayBuffer[Int]()
    buffer1 += 1
    buffer1 ++= arr
    buffer1 ++= ArrayBuffer(6, 7, 8) // 添加數組

    // 更改指定角標的值
    buffer1(1) = 11

    // append 方式添加
    buffer1.append(12, 13, 14)
    buffer1 -= 12
    println(buffer1) // ArrayBuffer(1, 11, 2, 3, 4, 5, 6, 7, 8, 13, 14)

    // 移除數組  如果要移除的元素不存在,不會報錯
    buffer1 --= Array(1, 2, 15)
    println(buffer1) //  ArrayBuffer(11, 3, 4, 5, 6, 7, 8, 13, 14)

    // 移除指定下表對應的元素
    buffer1.remove(5)

    //  從指定角標開始移除指定個元素
    buffer1.remove(3, 2)
  }
}

 

 /**
      * 數組的常用方法
      */
    val arr = Array(1, 2, 3, 4, 5)

    // 最大值
    println(arr.max)
    // 最小值
    println(arr.min)
    //maString 拼接
    println(arr.mkString(""))   // 12345
    println(arr.mkString(","))  // 1，2，3，4，5
    println(arr.mkString("[", ",", "]")) //[1,2,3,4,5]

/**
      * 數組的轉換操作
      */
    val intarr = Array(1,2,3,12,5,7)

     intarr.map((x: Int)=> x * 2)
          .sortBy((x: Int)=> x)  //排序
          .reverse     //  將數組反轉
          .foreach((x:Int)=>println(x))

    intarr.map(_ * 2).sortBy(x =>x).reverse.foreach(println(_))

    var  strarr = Array("hello world","hello china")

    strarr.map(x => {
     val fields =  x.split(" ")
      fields
    }).flatten.foreach(println(_))

    strarr.flatMap((x: String)=>{x.split(" ")}).foreach(println(_))

 相關：

1、foreach
foreach和map相似，只不過它沒有返回值，foreach只要是為了對參數進行作用。

比如 names.foreach{name=>println(name)}

2、flatten
flatten可以把嵌套的結構展開. 

scala> List(List(1,2),List(3,4)).flatten
res0: List[Int] = List(1, 2, 3, 4)

3、flatmap
flatMap結合了map和flatten的功能。接收一個可以處理嵌套列表的函數，然后把返回結果連接起來。

scala> List(List(1,2),List(3,4)).flatMap(x=>x.map(x=>x*2))
res5: List[Int] = List(2, 4, 6, 8)