Scala 簡明速學04 集合-Map

Scala 簡明速學04 集合-Map

Map

Scala中Map提供鍵值對集合。

Map的初始化

Scala中的Map分爲可變Map與不可變Map。不可變Map初始化後不可更改其元素。

object MapInitTest {
    def main(args: Array[String]): Unit = {
        //默認創建不可變map
        val lakers = Map("Lebron" -> 23, "Rondo" -> 9, "Ball" -> 2)
        println(lakers)
        println(lakers("Rondo")) //訪問map
        //不可變Map，初始化後不可修改，不可以添加元素，也不可以修改元素
        //lakers("Kuzma") = 0//添加操作
        //lakers("Rando") = -1//修改操作

        //創建可變的Map
        val lakers2 = scala.collection.mutable.Map("Lebron" -> 23, "Rondo" -> 9)
        lakers2("Kuzma") = 0
        println(lakers2)

        //使用元組語法初始化Map
        val lakers3 = Map(("Zubac", 40), ("Ingram", 14), ("McGee", 7))
        println(lakers3)

        //創建一個元素爲空的Map
        var lakers4 = new mutable.HashMap[String, Int]()
        lakers4.put("Chandler", 5)
        lakers4.+=("Beasley" -> 11)
        println(lakers4)
    }
}

Map的基本操作

對於可變Map,進行增刪改查操作。

object MapBasicOpt {
    def main(args: Array[String]): Unit = {
        val lakers = scala.collection.mutable.Map("Lebron" -> 23, "Rondo" -> 9)
        try {
            //獲取元素,如果獲取的元素不在集合中，會拋出異常
            val player = lakers("Tatum")
            println(player)
        } catch {
            case e: NoSuchElementException => e.printStackTrace()
        }

        //檢查元素是否存在
        println(lakers.contains("Lebron"))

        //給定默認值獲取元素
        println(lakers.getOrElse("Tatum", -1))

        //添加元素
        lakers("Stephenson") = 6
        //添加多個元素
        lakers += ("Hart" -> 3, "Pope" -> 1)

        //更新元素
        lakers("Rondo") = -1

        //刪除元素
        lakers.remove("Tatum")

    }
}

對於不可變Map,增刪改查的操作不會改變原有Map,而是返回一個新的Map。

object MapBasicOpt2 {
    def main(args: Array[String]): Unit = {
        val lakers = Map("Lebron" -> 23)
        //增加元素,返回新集合
        val lakers2 = lakers + ("Rondo" -> 9, "Ball" -> 2)
        //刪除元素，返回新集合
        val lakers3 = lakers2 - "Ball" - "Rondo"
        //更新元素，返回新集合
        val lakers4 = lakers3.updated("Lebron", 6)
    }
}

Map的遍歷

可以使用增強for循環,foreach方法對Map進行遍歷。

object MapIterate {
    def main(args: Array[String]): Unit = {
        val lakers = Map("Lebron" -> 23, "Ball" -> 2, "Kuzma" -> 0)

        //增強for循環,遍歷key,value
        for ((k, v) <- lakers) println(k, v)
        //增強for循環,遍歷value
        for ((_, v) <- lakers) println(v)
        //增強for循環,遍歷key
        for ((k, _) <- lakers) println(k)


        //只遍歷Map的key
        for (k <- lakers.keySet) println(k)

        //只遍歷Map的value
        for (v <- lakers.values) println(v)

        //使用foreach遍歷Map
        lakers.foreach(e => println(e._1, e._2))

        //生成新Map,並反轉Key與Value,使用增強for循環
        val lakers2 = for ((k, v) <- lakers) yield (v, k)

        //生成新Map,並反轉Key與Value,使用foreach
        val lakers3 = lakers.map(e => (e._2, e._1))


    }
}

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)
    }

}