【scala】3.數組相關操做

簡介

在本章中，咱們將會學到如何在scala中操做數組。

一、定長數組

// 初始化長度爲10的定長數組，每個元素的值爲0
val nums = new Array[Int](10)
// nums: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

// 初始化長度爲10的定長數組，每個元素的值爲null
scala> val str2 = new Array[String](10)
str2: Array[String] = Array(null, null, null, null, null, null, null, null, null, null)


scala> val num3 = Array(1,2,3)
num3: Array[Int] = Array(1, 2, 3)

scala> num3(0) = 4

scala> num3
res5: Array[Int] = Array(4, 2, 3)

已經提供初始值的狀況下，就不須要new操做符了。

在JVM中，Scala的Array以Java數組的方式實現。

二、變長數組

Java中有ArrayList，C++有vector，而Scala中爲ArrayBuffer。

// 首先導入包
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

scala> val a = ArrayBuffer[Int]()
a: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

scala> a += 1
res0: a.type = ArrayBuffer(1)

scala> a(0)
res2: Int = 1

scala> a += (2,3,4,5)
res4: a.type = ArrayBuffer(1, 2, 3, 4, 5)

// +=  追加元素
// ++= 追加集合
scala> a ++= Array(2,3,4)
res7: a.type = ArrayBuffer(1, 2, 3, 4, 5, 2, 3, 4)

// trimEnd 移除最後的5個元素
scala> a.trimEnd(5)

scala> a
res9: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)

以上都是基於尾部的操做，是比較搞笑的操做方式。也能夠在任意位置進行操做。

// 不用指定類型（類型推斷）
scala> val a = ArrayBuffer(1,1,1)
// ArrayBuffer(1, 1, 1)

// 在下標2處插入100
scala> a.insert(2,100)
// ArrayBuffer(1, 1, 100, 1)

// 插入多個值
scala> a.insert(0,200,300,400)
// ArrayBuffer(200, 300, 400, 1, 1, 100, 1)

// 移除元素
scala> a.remove(0)
// ArrayBuffer(300, 400, 1, 1, 100, 1)

// 移除多個元素，第二個參數的意思是移除多少個元素
scala> a.remove(0,3)
// ArrayBuffer(1, 100, 1)

可變與不可變數組之間的轉換

scala> a.toArray
res8: Array[Int] = Array(1, 100, 1)

scala> res8.toBuffer
res9: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 100, 1)

三、遍歷數組與數組緩衝

遍歷數組與數組緩衝的代碼都是同樣的，不像java和C++同樣須要區別對待。

scala> for(i <- 0 until res8.length) println(s"$i : ${res8(i)}")
0 : 1
1 : 100
2 : 1

scala> for(i <- 0 until res9.length) println(s"$i : ${res9(i)}")
0 : 1
1 : 100
2 : 1
-------------------------------
// 從新建立一個集合
scala> val b = Array(1,2,3,4)
b: Array[Int] = Array(1, 2, 3, 4)


// 跳步爲2的遍歷
scala> for(i <- 0 until b.length by 2) println(b(i))
1
3

// 尾端遍歷
scala> for(i <- (0 until b.length).reverse) println(b(i))
4
3
2
1

// 直接獲取數組元素遍歷
scala> for(ele <- b) println(ele)
1
2
3
4

0 until b.length至關於取0到length-1。

四、數組轉換

// yield
scala> val c = Array(1,2,3,4)
c: Array[Int] = Array(1, 2, 3, 4)

scala> val result = for (ele <- c) yield 2 * ele
result: Array[Int] = Array(2, 4, 6, 8)

// 或者使用map
scala> val result2 = c.map(ele => ele * 2)
result2: Array[Int] = Array(2, 4, 6, 8)

五、經常使用算法

scala> val a = Array(1,2,4,3,5)
a: Array[Int] = Array(1, 2, 4, 3, 5)

// 一些經常使用操做
scala> a.sum
res28: Int = 15

scala> a.min
res30: Int = 1

scala> a.max
res31: Int = 5

// 排序
scala> a.sorted
res37: Array[Int] = Array(1, 2, 3, 4, 5)

// 指定方式排序(sortWith方法只可適用於變長數組)
scala> val s = ArrayBuffer(1,2,4,3,5)
s: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 4, 3, 5)

scala> s.sortWith(_ > _)
res39: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(5, 4, 3, 2, 1)

六、打印數組元素

scala> a.mkString(",")
res0: String = 1,2,3,4,5

// 重載方法，設置兩邊的字符
scala> a.mkString("<",",",">")
res1: String = <1,2,3,4,5>

七、解讀Scaladoc

八、多維數組

和Java同樣，都是經過數組的數組實現多維數組。ofDim方法。

scala> val matrix = Array.ofDim[Double](3,4)
matrix: Array[Array[Double]] = Array(Array(0.0, 0.0, 0.0, 0.0), Array(0.0, 0.0, 0.0, 0.0), Array(0.0, 0.0, 0.0, 0.0))

scala> matrix(0)(0)=1

scala> matrix
res4: Array[Array[Double]] = Array(Array(1.0, 0.0, 0.0, 0.0), Array(0.0, 0.0, 0.0, 0.0), Array(0.0, 0.0, 0.0, 0.0))

九、與Java的互操做

val command = ArrayBuffer("ls","-al")
val pb = new ProcessBuilder(command) // Scala到Java的轉換

val cmd: Buffer[String] = pb.command() // Java到Scala的轉換

L、練習

package com.zhaoyi.ch3

import java.util.TimeZone

import scala.util.Random

object Practice {

  // 練習1：編寫一段代碼，將a設置爲n個隨機整數組成的數組，要求隨機數介於[0,n)之間。
  def exercise1(n: Int): Array[Int] ={
    val random = new Random()
    // scala.collection.immutable.IndexedSeq[Int]
    val result = for (i <- 0 to n) yield random.nextInt(n)
    result.toArray
  }

  // 練習2：編寫一個循環，將整數數組中的相鄰的元素置換。例如，Array(1,2,3,4,5)，通過置換以後變爲(2,1,4,3,5)
  def exercise2(arr: Array[Int]): Array[Int] ={
    for (i <- 0 until arr.length - 1 by 2){
      // 相鄰元素交換之
      val temp = arr(i);
      arr(i) = arr(i + 1);
      arr(i + 1) = temp;
    }
    arr
  }

  // 練習3：重複前一個練習，不過這一次生成一個新的值交換過的數組，使用 for/yield
  def exercise3(arr: Array[Int]): Array[Int] ={
    val newArr = for (i <- 0 until arr.length) yield {
      // 若是當前是置換對的第二個元素，那麼當前位置的元素必定是舊數組的上一個元素
      if(i % 2 == 1){
        arr(i-1)
      } else{// 若這是置換對的第一個元素，那麼他的值須要考慮兩種狀況：後面有沒有元素：有的話，返回後面一個元素；沒有的話，返回本身便可
        if(i == arr.length - 1) arr(i) else arr(i + 1)
      }
    }
    newArr.toArray
  }

  // 練習4：給定一個整數數組，產出一個新的數組，包含原數組中的全部正值，以原有的順序輸出；以後的元素全部的0和負值，以原有的順序排列。
  def exercise4(arr: Array[Int]): Array[Int] ={
    arr.filter(num => num > 0).map(a => a) ++ arr.filter(num => num <= 0).map(a => a)
  }

  // 練習5：如何計算Array[Double]的平均值
  def exercise5(arr: Array[Double]): Double ={
    arr.sum / arr.length
  }

  // 練習6：如何從新組織Array[Int]的元素將他們以反序排列？對於ArrayBuffer[Int]又該怎麼作呢？
  // 解答：Array[Int]能夠直接調用sorted方法排序；而對於ArrayBuffer，則須要使用sortWith

  // 練習7：給定一個數組，產出數組中的全部值，去掉重複項。
  def exercise7(arr:Array[Int]): Array[Int] = {
    arr.distinct
  }

  // 練習8：給定一個緩衝數組，移除該數組除第一次出現的負數之外的全部負數。
  def exercise8(arr:Array[Int]): Array[Int] = {
    var first = true;
    arr.filter(num => {
      if(num >= 0 ) true
      else {
        if(first) {
          first = false
          true
        }else false
      }
    });
  }

  // 練習9：跳過

  // 練習10：建立一個由java.util.TimeZone.getAvailableIds返回的時區集合，判斷條件是他們在美洲，去掉America/前綴並排序
  def exercise10(): Unit = {
    val prefix = "America/";
    val timeZone = TimeZone.getAvailableIDs();
    val AmericaZones = for (zone <- timeZone if zone.startsWith(prefix)) yield {
      // 去掉前綴America/
      zone.substring(prefix.length);
    }
    val soredZone = AmericaZones.sorted
    soredZone.foreach(z => println(z));
  }


  def main(args: Array[String]): Unit = {
    println("exercise 1(n = 10): " + exercise1(10).mkString(","))
    println("exercise 2(Array(1,2,3,4,5)): " + exercise2(Array(1,2,3,4,5)).mkString(","))
    println("exercise 3(Array(1,2,3,4,5)): " + exercise3(Array(1,2,3,4,5)).mkString(","))
    println("exercise 4(Array(-1,2,-3,4,5,0)): " + exercise3(Array(-1,2,-3,4,5,0)).mkString(","))
    println("exercise 5(Array(1,2,3,4,5,6,7,8,9,10)) mean is : " + exercise5(Array(1,2,3,4,5,6,7,8,9,10)))

    println("exercise 7(Array(1,1,2,2,2,3,3,4)) distinct is: " + exercise7(Array(1,1,2,2,2,3,3,4)).mkString(","))

    println("exercise 8(Array(5,4,3,2,1,0,-1,-2,-3,1,2,-1,-2)): " + exercise8(Array(5,4,3,2,1,0,-1,-2,-3,1,2,-1,-2)).mkString(","))

    println("exercise 10: " + exercise10())

  }
}