Scala數組

在scala中的數組和JAVA中的數組都是定長的，一旦初始化就不可改變（Scala數據底層是直接變成JAVA的數組）

Array

定義即初始化，並分配空間

//聲明類型和長度 
val arr = new Array[Int](10)
arr: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

//直接使用構造函數構建(調用apply函數) 
val arr1 = Array("123", 1)
arr1: Array[Any] = Array(123, 1)

ArrayBuffer(JAVA無):由ArrayList實現？

相似於JAVA中的ArrayList(ArrayList數組實現，每次中間插入刪除慢，而LinkedList[火車]由對象實現，查找慢)，變長數組

1.定義

import scala.collection.mutable.ArrayBuffer

var arrBuf = ArrayBuffer[Int]()
arrB: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

2.寫入

// 尾部追加 += **奇葩語法又來了**,其實就是定義了+=函數
arrBuf += 1
arrBuf += (1,2,3,4,5,6)

//追加整個數組
arrBuf ++= Array(1,2,3)

//源碼
def +=:(elem: A): this.type = {
def ++=:(xs: TraversableOnce[A]): this.type = {

//指定位置追加(index,args: _*)
arrBuf.insert(3,args)

3.刪除

//尾部刪除,刪除指定長的元素
arrBuf.trimEnd(3)

//指定位置刪除(index,lenth)
arrBuf.remove(2)
arrBuf.remove(2,3)

Array和ArrayBuffer轉換

B.toArray()
A.toBuffer()

數組遍歷

• arr[]
• arrBuf()

1.加強for循環

for (e <- arrBuf){
    println(e)
}

2.for until（無上界限）

//for (i <- arrBuf.indices){            //新API

//全遍歷（從0開始）
for (i <- 0 until arrBuf.length){
  println(arrBuf(i))
}

//基數遍歷（從0開始）
for (i <- 0 until (arrBuf.length,2)){
  println(arrBuf(i))
}

//偶數遍歷（從1開始）
for (i <- 1 until (arrBuf.length,2)){
  println(arrBuf(i))
}

//逆序(新API)
for (i <- arrBuf.indices.reverse){
  println(arrBuf(i))
}

常見操做

//求和
arr.sum

//最大，最小
arr.max
arr.min

//克隆
arr.clone()

//排序
util.Sorting.quickSort(arr)

//mkstring(組裝字符串)
arr.mkString                //res0: String = 56783456
arr.mkString(",")           //res1: String = 5,6,7,83,4,5,6
arr.mkString("<",",",">")   //res2: String = <5,6,7,83,4,5,6>

//toString
arr.toString                //res0: String = [I@6f8cf218

//hashCode
arr.hashCode()              //res0: Int = 1556830203

使用yield和函數式編程實現數組轉換

yield轉換

//轉換後類型與原類型相同，原值不變
for (a <- arr) yield a*a

//增減if守護過濾
for (a <- arr if a%2 == 0) yield a*a

函數式編程

//使用filter做爲過濾器
arr.filter(_ % 2 == 0).map(_ * 2)       // _表示佔位符，第一個表示Array裏的每個元素，第二個表示過濾後的一個元素

//能夠將()變成{}，不經常使用
arr.filter{_ % 2 == 0}.map{_ * 2}

算法實戰

import scala.collection.mutable.ArrayBuffer

/*
刪除第一個負數以後的負數
 */
var arr = ArrayBuffer[Int](1, 2, 3, 4, -1, -2, -4, 5)
var foundFirstNegative = false
var index = 0
var arr_length = arr.length

////不能夠用for由於刪了就少了，就會出現之後的幾遍就不能比較了
//for (i <- arr.indices) {
//  if (arr(i) > 0) {

/*
//低效率版,remove頻繁移動數組，當數組全是負數時，複雜度爲O((n+n^2)/2)
while (index < arr_length) {
  if (arr(index) > 0) {
    index += 1
  } else {
    if (foundFirstNegative) {
      arr.remove(index)
      arr_length -= 1
    } else {
      foundFirstNegative = true
      index += 1
    }
  }
}
arr.mkString
*/

//高效率版，把留下的index作標誌，一次性刪除其餘的，最壞的狀況，複雜度爲O(n)
//這裏的if守衛，剛開始的時候都能放行，當找到第一個負數以後就把別的負數攔在門外了
val keepIndexArr = for (i <- arr.indices if !foundFirstNegative || arr(i) >= 0) yield {
  if (arr(i) < 0) {
    foundFirstNegative = true
  }
  i
}
//先裝
for (i <- keepIndexArr.indices) {
  arr(i) = arr(keepIndexArr(i))
}
//後刪
arr.trimEnd(arr_length - keepIndexArr.length)
print(arr.mkString)