Scala 之数组

可变数组与不可变数组

import scala.collection.mutable.ArrayBuffer



  // 不可变数组。 长度不可变，但是元素的值可变
object Demo1 {


  def main(args: Array[String]): Unit = {

    // 不可变数组定义方式
    // 未初始化有默认值 Int  =>  0
    val  arr1 : Array[Int] = new Array[Int](5)
    val  arr2 : Array[Int] = Array(2,2,2,2,2)
    val  arr3 = Array(3,3,3,3,3)


    //  对元素值改变。不会创建新数组
    arr1(0) = 3
    arr1.update(4,5)
    println(arr1.mkString(","))


    //数组遍历
    for(i<- 0 until arr1.length)      println(arr1(1))
    for(ele <- arr1)                        println(ele)

    val iterator = arr1.iterator
    while(iterator.hasNext)    println(iterator.next())

    arr1.foreach(x => println(x))
    arr1.foreach(println(_))
    // 函数体只有一句，并且使用了已经存在函数，且参数是一一对应，那么此时参数列表可以省略
    arr1.foreach(println)

    //数组扩容   创建新数组。
    val r1 = arr1 :+ 9
    val r2 = arr1.+:(9)

    // +: 的: 要对着变量。否则就得 .+: 调用
    val r3 = 8 +: arr1 :+8 :+ 8

    println("---------------"+arr1.mkString("/"))
    println(r3.mkString("-"))

    //数组与数组的合并  ++ ++: :++ 产生新数组，都是在数组后拼接
    val v1 = arr1 ++ arr2
    val v2 = arr1.concat(arr3)
    //运行结果为  3|0|0|0|5|3|3|3|3|3   val v1 = arr1 ++ arr2 这里并不对arr1产生影响 。
    println(v2.mkString("|"))


    //创键范围内固定步长数组，含头不含尾
    val v3 =  Array.range(0,10,2)
    println(v3.mkString(","))

    //创建数组，并用指定逻辑产生的数据填充
    //   def fill(n: Int)(elem: => T): Array[T] = ???    柯理化函数  传名函数
    // ({})  这种形式， （） 或 {} 可省略其一
    val v4 = Array.fill(6)({
      (Math.random() * 100).toInt
    })
    println(v4.mkString(","))

    // 数组翻转
    val v5 = v4.reverse
    println(v5.mkString(","))

    println("---------------------------------------------------------------------")


    //创建可变数组   是没有默认值的，必须初始化
    val a1 = new ArrayBuffer[Int]
    // 0
    println(a1.length)

    //a1(0) = 3   报错   0 is out of bounds (min 0, max -1)   数组无元素
    a1.+=(1)
    a1 += 1

    //指定初始长度， 但是也必须先 += 初始化元素 才可以 a2()访问
    val a2 = new ArrayBuffer[Int](3)

    val a3 =  ArrayBuffer[Int](3,3,3,3,3,3)

    println(a1)
    a1 += 2
    0 +=: a1
    a1.append(2)
    a1.prepend(0)
    println(a1)
    println(a3)

    val array1 =  ArrayBuffer(1, 1, 3, 3, 1, 1)
    array1.insert(1,2)
    array1.update(0,0)
    array1.remove(array1.length-1)

    // 删除第一个3
    array1 -= 3
    //ArrayBuffer(0, 2, 1, 3, 1)
    println(array1)

    // BufferArray 与 Array 的转换。  .toArray  .toBuffer

  }
}

练习：猴子报数。15只猴子围成一圈报数，报到数字7的猴子被淘汰，下一只猴子从1重新报数，最后剩余的是哪只猴子？

package com.fesco.array

object MonkeyExec {

  def main(args: Array[String]): Unit = {

    // 定义数组，表示15只猴子
    // 用true表示猴子的还活着，用false表示猴子被淘汰
    val monkeys = Array.fill(15)(true)
    // 定义变量来记录还剩余的猴子数量
    var n = 15
    // 定义变量来记录报数
    var i = 1
    // 定义变量来记录下标
    var index = 0
    // 只要剩余的猴子数量>1那么就需要继续报数
    while (n > 1) {
      // 先判断这只猴子是否存活
      if (monkeys(index)) {
        // 判断这只猴子是否会被淘汰
        if (i == 7) {
          // 这只猴子被淘汰
          monkeys(index) = false
          // 剩余猴子数量-1
          n -= 1
          // 下一只猴子重新报数
          i = 0
        }
        // 报数+1
        i += 1
      }
      // 下一只猴子准备
      index += 1
      if (index == monkeys.length) index = 0
    }
    println(monkeys.mkString(", "))
  }

}

二维数组

// 二维数组中的一维数组的长度可以不一致
val array1 = new Array[Array[Int]](3)
array1(0) = new Array[Int](5)
array1(1) = Array[Int](1, 2, 3, 4, 5)

//ofDim 方法可定义一至五维数组
// 二维数组，每个数组长度为5  。  这种方式定义的每个一维数组长度要一致
val array2 = Array.ofDim[Int](2, 5)

val array3 = Array(Array(1, 1, 1, 1, 1), Array(1, 1, 1, 1, 1), Array(1, 1, 1, 1, 1), Array(1, 1, 1, 1, 1), Array(1, 1, 1, 1, 1))

// 输出的不是1 ，而是 () 。 赋值运算符的返回值是Unit
// println(array3(0)(0) = 1)


//    杨辉三角形
//    1
//    1 1
//    1 2 1
//    1 3 3 1
//    1 4 5 4 1


val arr = new Array[Array[Int]](5)
// 遍历数组
for (i <- 0 until 5) {
  // 初始化第i行一维数组
  arr(i) = new Array[Int](i + 1)
  // 填充元素
  for (j <- 0 to i) {
    // 每一行第一个或者最后一个元素是1
    if (j == 0 || j == i) arr(i)(j) = 1
    else arr(i)(j) = arr(i - 1)(j) + arr(i - 1)(j - 1)
  }
  println(arr(i).mkString("\t"))
}