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)