Scala入門到放棄——數組（四）

七、數組操作

• 概念上類似於Java中的數組，一個特定類型的元素集合

數組的初始化

package array

object Array01 {
  def main(args: Array[String]): Unit = {
    // 數組聲明
    // a1數組的長度爲10 泛型爲Int
    val a1 = new Array[Int](10)
    val a2 = new Array[String](5)

    // 指定數組 元素並初始化
    val a3 = Array[Long](10,20,30)

    val a4 = Array(1.0,2.0,3.0)

    // 使用：長度 length  下標index【0 ~ length-1】
    // 訪問數組元素使用 變量名(下標)
    // 數組默認值：整數爲 0  小數爲0.0  boolean false null
    println(a1(0))
    println(a2(4))
    println(a3(1))
    println(a4(2))
      
    // 遍歷 傳統方式
    for (n <- 0 until (a4.length)) {
      println(a4(n))
    }

    for (n <- a4) {
      println(n)
    }

    for( n <- a4.indices){ // Range(0,1,2)
      println(a4(n))
    }
  }
}

數組的使用

• 長度 length
• 下標 index

val a1 = Array(1, 2, 3, 4, 5)
// 傳統方式
for (n <- 0 until (a1.length)) {
  println(a1(n))
}
// 推薦方式
for (n <- a1.indices) {
  println(a1(n))
}

// 跳躍遍歷(步長2)
for (n <- a1.indices by 2) {
  print(a1(n) +"\t")
}

排序

/**
  * 冒泡排序
  * 2 1 5 0 3
  * 第一輪：
  *   1 2 5 0 3
  *   1 2 5 0 3
  *   0 2 2 1 3
  *
  *
  */
package array

/**
  * 冒泡排序
  */
object Array02 {
  def main(args: Array[String]): Unit = {
    val a1 = Array(3, 1, 5, 4, 10, 0)
    //    for (m <- 0 until (a1.length)) {
    //      for (n <- 0 until (a1.length - m - 1)) {
    //        if (a1(n) > a1(n + 1)) {
    //          var tmp = a1(n)
    //          a1(n) = a1(n + 1)
    //          a1(n + 1) = tmp
    //        }
    //      }
    //    }

    // 多重循環  + if守衛  
    for (m <- 0 until (a1.length); n <- 0 until (a1.length - m - 1) if a1(n) > a1(n + 1)) {
      val tmp = a1(n)
      a1(n) = a1(n + 1)
      a1(n + 1) = tmp
    }

    for (n <- a1) {
      println(n)
    }
  }
}

ArrayBuffer

可變數組，數組支持自動擴容

• 類似於ArrayList集合

import scala.collection.mutable.ArrayBuffer

object ArrayBuffer01 {
  def main(args: Array[String]): Unit = {
    val a1 = new ArrayBuffer[Byte]()
    // 注意： += 語法是給ArrayBuffer添加元素
    a1 += 1
    a1 += 2
    // 一次性添加多個元素
    a1 += (3,4,5)
    // 注意： ++= 將數組中的所有元素添加到ArrayBuffer中
    a1 ++= Array[Byte](6,7,8)
    // 從末尾截斷指定個數的元素
    a1.trimEnd(3)

    // 從下標5 添加元素 6，7，8
    a1.insert(5,6,7,8)

    // 跳躍遍歷
    for ( i <- 0 until(a3.length,2) ) {
      print(a3(i) +"\t")
    }
  }
}

Array和ArrayBuffer相互轉換

val a1 = new ArrayBuffer[Byte]()
// 轉爲數組
val a2 = a1.toArray
a2(2) = 0

// 轉爲ArrayBuffer
val a3 = a2.toBuffer

println(a1)
println(a3)

其它操作

import scala.util.Sorting

object Array04 {
  def main(args: Array[String]): Unit = {
    val a1 = Array(5,4,3,2,1)
    println(a1.sum) //15
    println(a1.max) //5
    println(a1.min) //1

    println(a1.mkString) //54321
    println(a1.mkString(",")) //5,4,3,2,1
    println(a1.mkString("<",",",">")) //<5,4,3,2,1>

    //println(a1.sorted.mkString) // 排序
    Sorting.quickSort(a1) //快速排序
    println(a1.mkString)
  }
}

多維數組

定義

// 二維數組 有三個一維數組，每個一維中包含四個元素
val arr = Array.ofDim(3,4)

使用

package com.baizhi.array

/**
  * 多維數組
  */
object MultiplyBuffer01 {
  def main(args: Array[String]): Unit = {
    val arr = Array.ofDim[Int](3, 4)
    for (m <- arr) {
      print(m.mkString(","))
      println()
    }

    // 二維數組賦值
    arr(2)(1) = 100
    for (m <- arr) {
      print(m.mkString(","))
      println()
    }
  }
}

算法案列：移除第一個負數後的所有數

• 測試數據val a1=Array(1,2,3,4,5,-5,-4,-3)
• 預期結果val a2=Array(1,2,3,4,5,-5)

package array

object Array05 {
  def main(args: Array[String]): Unit = {
    // val a1=Array(1,2,3,4,5,-5,-4,-3)
    // val a2=Array(1,2,3,4,5,-5)

    val a1 = Array(1, 2, 3, 4, 5, -5, -4, -3)
    var first = true
    var position = 0
    for (n <- a1.indices) {
      if (first || a1(n) >= 0) {
        if(a1(n) <0 ){
          first = false
          position = n
        }
      }
    }

    println(position)

    val ab = a1.toBuffer
    ab.trimEnd(a1.length - position-1)
    println(ab)
  }
}