Scala 簡明速學03 集合 Array和ArrayBuffer

Scala 簡明速學03 集合 Array和ArrayBuffer

Array

Scala中Array代表長度不可變的數組。

Array的初始化

數組初始化時，長度就固定了，其元素同時進行初始化，分配內存空間。

   
object ArrayTest {

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

        val a1 = new Array[Int](3) //指定範型參數和長度
        println(a1.mkString(",")) //0,0,0 Int型數組初始值爲0

        val a2 = new Array[String](3)
        println(a2.mkString(",")) //null,null,null 引用型數組初始值爲null

        //使用Array.apply()方法創建並初始化數組
        val a3 = Array("a", "b", "c")//元素類型由編譯器自動推斷
        println(a3.mkString(",")) //a,b,c
    }
}

Array的遍歷

可以使用下標，增強for循環,foreach方法對數組進行遍歷。

object ArrayTest {

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

        val a1 = new Array[Int](3) //指定範型參數和長度
        println(a1.mkString(",")) //0,0,0 Int型數組初始值爲0

        val a2 = new Array[String](3)
        println(a2.mkString(",")) //null,null,null 引用型數組初始值爲null

        //使用Array.apply()方法創建並初始化數組
        val arr = Array("a", "b", "c", "d") //元素類型由編譯器自動推斷
        println(arr.mkString(",")) //a,b,c,d


        //使用下標進行遍歷
        for (i <- 0 until arr.length) {
            println(arr(i))
        }

        //使用下標且跳躍遍歷
        for (i <- 0 until(arr.length, 2)) {
            println(arr(i))
        }

        //倒序使用下標遍歷
        for (i <- (0 until arr.length).reverse) {
            println(arr(i))
        }

        //使用增強for循環進行遍歷
        for (a <- arr) {
            println(a)
        }

        //使用foreach遍歷
        arr.foreach(println(_))
        arr.foreach((a) => {
            println(a)
        })
    }
}

ArrayBuffer

Scala中一般使用ArrayBuffer描述變長數組。類似於Java中的ArrayList。
ArrayBuffer提供了運算符重載函數方便操作,並且可以與Array相互轉換。

object ArrayBufferTest {
    def main(args: Array[String]): Unit = {
        val arrBuf = ArrayBuffer("a", "b", "c")
        //+=方法，可以添加一個或多個元素
        arrBuf += "d"
        println(arrBuf) //(a, b, c, d)
        arrBuf += ("e", "f", "g")
        println(arrBuf) //(a, b, c, d, e, f, g)
        //++= 添加另一個集合
        val arrBuf2 = arrBuf ++= ArrayBuffer("1", "2", "3")
        println(arrBuf) //(a, b, c, d, e, f, g, 1, 2, 3)
        //+=,++=操作都是對集合本身進行操作,並返回集合自身
        arrBuf2(0) = "0"
        println(arrBuf) //(0, b, c, d, e, f, g, 1, 2, 3)


        //insert(n:Int,elems:A*)方法,在指定索引處插入一個或多個元素
        arrBuf.insert(3, "x", "y")
        //remove(n:Int,count:Int)方法，在指定索引處刪除一個或多個元素
        arrBuf.remove(1, 2)

        //ArrayBuffer與Array的相互轉換
        val arr = Array(1, 2)
        //Array轉爲ArrayBuffer
        var arrBuff = arr.toBuffer
        println(arrBuff) //ArrayBuffer(1, 2)

        //ArrayBuffer轉爲Array
        arrBuff = ArrayBuffer(3, 4)
        val arrByBuffer = arrBuff.toArray
        println(arrByBuffer.mkString(",")) //3,4
    }
}

ArrayBuffer的遍歷

ArrayBuffer的遍歷與Array相同，可以使用下標，增強for循環，foreach方法進行遍歷。

        //ArrayBuffer的遍歷
        val ints = ArrayBuffer(1, 2, 3, 4)

        //使用下標遍歷
        for (i <- 0 until ints.length) {
            println(ints(i))
        }
        //使用下標並跳躍遍歷
        for (i <- 0 until(ints.length, 2)) {
            println(ints(i))
        }

        //增強for循環遍歷
        for (i <- ints) {
            println(i)
        }
        //foreach方法遍歷
        ints.foreach(println(_))
        ints.foreach((i) => {
            println(i)
        })

yield生成器

Scala提供了yield關鍵字來實現生成器。

object YieldGenerator {
    def main(args: Array[String]): Unit = {
        val arr1 = Array(1, 2, 3)
        val arr2 = for (a <- arr1) yield a * a
        println(arr2.mkString(","))

        val arrBuf1 = ArrayBuffer(1, 2, 3)
        val arrBuf2 = for (a <- arrBuf1 if a % 2 != 0) yield a * a * a
        println(arrBuf2)
    }
}

map()方法生成

Scala提倡使用函數式編程進行轉換，例如使用filter方法進行過濾，map方法進行生成和轉換。

object MapGenerateTest {

    def main(args: Array[String]): Unit = {
        val ints = Array(1, 2, 3, 4)
        val doubles = ints.filter(_ % 2 == 0).map(math.pow(_, 2))
        println(doubles.mkString(","))
        val arrBuf = ArrayBuffer(1, 2, 3, 4)
        val arrBuf2 = arrBuf.filter(_ % 2 != 0).map(3 * _)
        println(arrBuf2)
    }

}