(四)Scala集合

1.Scala 集合概述

Scala有三類集合：序列Seq、Set、映射Map。
Scala中，幾乎全部的集合，都提供可變和不可變兩個版本。

通常，咱們根據集合所在的包來區分是可變集合仍是不可變集合。

• scala.collection.immutable 不可變集合
• scala.collection.mutable 可變集合

2.Scala 集合

2.1 數組

2.1.1 不可變數組

object Scala_Coll {
  def main(args: Array[String]): Unit = {
    // Scala 數組 - 不可變
    // 1. 建立數組對象
    // 方式一
    // new Array[String](5) 編譯後會生成java的數組代碼
    val array = new Array[String](5)
    // 方式二
    val array1 = Array(1,2,3,4)

    // 2. 打印數組
    println(array) // 輸出結果 [Ljava.lang.Object;@4cdbe50f
    // 3.數組賦值，Scala下標索引使用小括號
    array(0) = "張三"
    array(1) = "李四"
    array(2) = "王五"
    array(3) = "趙六"
    // 4.採用update方式修改數組的值
    array.update(4,"哈哈")
    // 5.查看數組
    println(array.mkString(","))
    // 6.遍歷數組- 方式1
    for(i<-array){
      println(i)
    }
    // 7.遍歷數組 - 方式2
    //  array.foreach(i => println(i)) 精簡爲
    array.foreach(println)

    /////// 數組操做 ///////
    // 1)添加數組元素，不可變數組添加數組元素後，返回一個新的數組，自己不會發生改變
    // :+ 添加元素到尾部
    val arr1 = array :+ 5
    // +: 添加元素到首部
    val arr2 = arr1.+:(5)
    // ++ 添加數組
    val arr3 = arr1 ++ arr2
    
  }
}

2.1.2 可變數組

import scala.collection.mutable.ArrayBuffer

object Scala_Coll {
  def main(args: Array[String]): Unit = {
    // 1.聲明可變數組：scala.collection.mutable.ArrayBuffer
    // 方式1
    val arr1 = new ArrayBuffer[Int]()
    // 方式2
    val arr2 = ArrayBuffer(1,2,3,4)

    // 2.增長數據
    arr1.append(4,5,6,7)
    println(arr1.mkString(","))

    // 3.修改數據
    arr1.update(1,10)
    println(arr1.mkString(","))

    // 4.刪除數據
    arr1.remove(1,2) //從索引位置1開始刪除2個數據
    println(arr1.mkString(","))

    // 5.查詢數據
    println(arr1(1))

    // 6.遍歷集合
    arr1.foreach(println)

    // 7. ++ 運算符會產生新的集合數組
    val arr3 = arr1 ++ arr2
    println(arr3.mkString(","))

    // 8. ++= 運算符則更新以前集合，並不產生新的數組
    arr1 ++= arr2
    println(arr1.mkString(","))
    
  }
}

2.1.3 可變數組和不可變數組的互相轉換

import scala.collection.mutable.ArrayBuffer

object Scala_Coll {
  def main(args: Array[String]): Unit = {
    val arr1 = Array(1,2,3,4)
    // 將不可變數組arr1轉換爲可變數組
    val arr2 = arr1.toBuffer
    // 將可變數組arr2轉換爲不可變數組
    val arr3 = arr2.toArray

  }
}

2.2 Seq集合

2.2.1 不可變list

object Scala_Coll {
  def main(args: Array[String]): Unit = {
    // 不可變list
    // 1.聲明對象
    val list = List(1, 2, 3, 4)
    // 2.增長元素，返回新的list
    val list1 = list :+ 1
    // 3.遍歷list
    list1.foreach(println)
    // 4.空集合Nil
    // 通常用於增長數據
    val list2 = 1 :: 2 :: 3 :: 4 :: Nil
    println(list2.mkString(","))

    // 添加集合
    val list3 = 1 :: 2 :: 3 :: list1 :: Nil
    println(list3.mkString(",")) // 輸出結果 1,2,3,List(1, 2, 3, 4, 1)

    // 咱們須要將list1的元素做爲一個一個的個體使用，也就是扁平化操做
    val list4 = 1 :: 2 :: 3 :: list1 ::: Nil
    println(list4.mkString(",")) // 輸出結果 1,2,3,1,2,3,4,1

    // 5.鏈接集合
    val list5 = List.concat(list3, list4)
    list5.foreach(println)

    // 6.建立一個指定重複數量的列表
    val list6 = List.fill[String](3)("Hello")
    list6.foreach(println)

  }
}

2.2.2 可變list

import scala.collection.mutable.ListBuffer

object Scala_Coll {
  def main(args: Array[String]): Unit = {
    // 1.可變list
    var list1 = new ListBuffer[Int]
    // 2.增長數據
    list1.append(1,2,3,4)
    val list2 = list1 :+ 5
    list1+=5
    println(list1.mkString(","))
    println(list2.mkString(","))
    val list3 = list1 ++ list2
    println(list3.mkString(","))

    // 3.修改數據
    list1.update(1,10)
    println(list1(1))

    // 4.刪除數據
    list1.remove(1,2)
    println(list1.mkString(","))
    // 5.獲取數據
    println(list1(1))

  }
}

2.2.3 可變list和不可變list的相互轉換

import scala.collection.mutable.ListBuffer

object Scala_Coll {
  def main(args: Array[String]): Unit = {
    // 建立一個不可變集合
    var list = List(1,2,3,4) 
    // 將不可變集合轉變爲可變集合
    val buffer = list.toBuffer
    // 將可變集合buffer轉變爲不可變集合
    val list1 = buffer.toList
  }
}

2.3 Map映射

2.3.1 不可變Map

import scala.collection.mutable.ListBuffer

object Scala_Coll {
  def main(args: Array[String]): Unit = {
    // 1.建立Map 兩種方式
    val map1 = Map("a"->"張三","b"->"李四","c"->"王五")
    val map2 = Map(("a","張三"),("b","李四"),("c","王五"))
    println(map1)
    println(map2)

    // 2.添加數據
    val map3 = map1 + ("d" -> "張三丰")
    println(map3)

    // 3.刪除數據
    val map4 = map3 - "d"
    println(map4)

    // 4.修改數據
    val map5 = map4.updated("b", "黃蓉")
    println(map5)

    // 5.遍歷
    map5.foreach(println)

    // 6.獲取指定key的值
    val str = map5.apply("a")
    println(str)

    // 7.獲取可能存在的key值
    val maybeString:Option[String] = map5.get("a")
    println(maybeString.get) // 若是是從None值獲取會發生異常
    println(maybeString.getOrElse(-1)) // 若是獲取到返回值，獲取不到返回默認值

    // 更加簡潔的用法
    val value = map5.getOrElse("d", -1)
    println(value)
    
  }
}

2.3.2 可變Map

import scala.collection.mutable

object Scala_Coll {
  def main(args: Array[String]): Unit = {
    // 聲明可變Map
    val map1 = mutable.Map("a" -> "郭靖", "b" -> "黃蓉")
    val map2 = mutable.Map(("a","楊過"),("b","小龍女"))

    // 添加數據
    map1.put("c","郭襄")
    val map3 = map1 + ("d" -> "郭芙")
    map1 += ("d"->"郭芙")

    // 修改數據
    map1.update("d","郭破虜")
    map1("d") = "郭芙"

    // 刪除數據
    map1.remove("d")
  }
}

2.4 元組

object Scala_Coll {
  def main(args: Array[String]): Unit = {
    // 元組能夠當作是容納元素的容器，最多能夠容納22個元素
    // 聲明一個元組
    val tuple = (1, "a", "張三丰", 18)

    // 元組中的數據能夠經過數據的順序來訪問
    println(tuple._1)
    println(tuple._2)
    println(tuple._3)
    println(tuple._4)

    // 元組遍歷
    val iterator = tuple.productIterator
    while (iterator.hasNext){
      println(iterator.next())
    }

    // 對偶元組:只有兩個元素,也能夠叫鍵值對
    val map = Map(("a", "張三丰"), ("b", "張翠山")) //這種聲明方式，裏面就是對偶元組
  }
}