一、Collection

文件地址：https://www.w3cschool.cn/scaladevelopmentguide

// 定義整型 List
val x = List(1,2,3,4)

// 定義 Set
val x = Set(1,3,5,7)

// 定義 Map
val x = Map("one" -> 1, "two" -> 2, "three" -> 3)

// 創(chuàng)建兩個(gè)不同類型元素的元組
val x = (10, "tom")

// 定義 Option
val x:Option[Int] = Some(5)

1. List

創(chuàng)建列表

scala> val days = List("Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday")
days: List[String] = List(Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday)

創(chuàng)建空列表

val l = Nil
l: scala.collection.immutable.Nil.type = List()

scala> val l = List()
l: List[Nothing] = List()

用字符串創(chuàng)建列表

scala> val l = "Hello" :: "Hi" :: "Hah" :: "WOW" :: "WOOW" :: Nil
l: List[String] = List(Hello, Hi, Hah, WOW, WOOW)

用“:::”疊加創(chuàng)建新列表

scala> val wow = l ::: List("WOOOW", "WOOOOW")
wow: List[String] = List(Hello, Hi, Hah, WOW, WOOW, WOOOW, WOOOOW)

通過(guò)索引獲取列表值

scala> l(3)
res0: String = WOW

獲取值長(zhǎng)度為3的元素?cái)?shù)目

scala> l.count(s => s.length == 3)
res1: Int = 2

返回去掉l頭兩個(gè)元素的新列表

scala> l.drop(2)
res2: List[String] = List(Hah, WOW, WOOW)
 
scala> l
res3: List[String] = List(Hello, Hi, Hah, WOW, WOOW)

返回去掉l后兩個(gè)元素的新列表

scala> l.dropRight(2)
res5: List[String] = List(Hello, Hi, Hah)
 
scala> l
res6: List[String] = List(Hello, Hi, Hah, WOW, WOOW)

判斷l(xiāng)是否存在某個(gè)元素

scala> l.exists(s => s == "Hah")
res7: Boolean = true

濾出長(zhǎng)度為3的元素

scala> l.filter(s => s.length == 3)
res8: List[String] = List(Hah, WOW)

判斷所有元素是否以“H”打頭

scala> l.forall(s => s.startsWith("H"))
res10: Boolean = false

判斷所有元素是否以“H”結(jié)尾

scala> l.forall(s => s.endsWith("W"))
res11: Boolean = false

打印每個(gè)元素

scala> l.foreach(s => print(s + ' '))
Hello Hi Hah WOW WOOW

取出第一個(gè)元素

scala> l.head
res17: String = Hello

取出最后一個(gè)元素

scala> l.last
res20: String = WOOW

剔除最后一個(gè)元素，生成新列表

scala> l.init
res18: List[String] = List(Hello, Hi, Hah, WOW)

剔除第一個(gè)元素，生成新列表

scala> l.tail
res49: List[String] = List(Hi, Hah, WOW, WOOW)

判斷列表是否為空

scala> l.isEmpty
res19: Boolean = false

獲得列表長(zhǎng)度

scala> l.length
res21: Int = 5

修改每個(gè)元素，再反轉(zhuǎn)每個(gè)元素形成新列表

scala> l.map(s => {val s1 = s + " - 01"; s1.reverse})
res29: List[String] = List(10 - olleH, 10 - iH, 10 - haH, 10 - WOW, 10 - WOOW)

生成用逗號(hào)隔開(kāi)的字符串

scala> l.mkString(", ")
res30: String = Hello, Hi, Hah, WOW, WOOW

反序生成新列表

scala> l.reverse
res41: List[String] = List(WOOW, WOW, Hah, Hi, Hello)

按字母遞增排序

scala> l.sortWith(_.compareTo(_) < 0)
res48: List[String] = List(Hah, Hello, Hi, WOOW, WOW)

2. Set

Scala Set(集合)是沒(méi)有重復(fù)的對(duì)象集合，所有的元素都是唯一的。
Scala 集合分為可變的和不可變的集合。
默認(rèn)情況下，Scala 使用的是不可變集合，如果你想使用可變集合，需要引用 scala.collection.mutable.Set 包。
默認(rèn)引用 scala.collection.immutable.Set。

創(chuàng)建Set

scala> val a=Set(1,1,2,3)
a: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

添加元素

scala> a+(4)
res119: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)
scala> a++List(5,6)
res121: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3)

注意： 雖然可變Set和不可變Set都有添加或刪除元素的操作，但是有一個(gè)非常大的差別。對(duì)不可變Set進(jìn)行操作，會(huì)產(chǎn)生一個(gè)新的set，原來(lái)的set并沒(méi)有改變，這與List一樣。 而對(duì)可變Set進(jìn)行操作，改變的是該Set本身，與ListBuffer類似。

需要注意的是，加了一些元素之后，對(duì)于a是否會(huì)變化。主要到scala.collection.immutable
初始化

scala> val  mutableSet =Set(1,2,3)
mutableSet: scala.collection.mutable.Set[Int] = Set(1, 2, 3)

加元素

scala> mutableSet+(4)
res141: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)
scala> mutableSet
res142: scala.collection.mutable.Set[Int] = Set(1, 2, 3)
scala> mutableSet.add(4)
res143: Boolean = true
scala> mutableSet
res144: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)

刪除元素

scala> mutableSet-(4)
res146: scala.collection.mutable.Set[Int] = Set(1, 2, 3)
scala> mutableSet
res147: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)
scala> mutableSet.remove(4)
res148: Boolean = true
scala> mutableSet
res149: scala.collection.mutable.Set[Int] = Set(1, 2, 3)

3. Map

Map(映射)是一種可迭代的鍵值對(duì)（key/value）結(jié)構(gòu)。
所有的值都可以通過(guò)鍵來(lái)獲取。
Map 中的鍵都是唯一的。
Map 也叫哈希表（Hash tables）。
Map 有兩種類型，可變與不可變，區(qū)別在于可變對(duì)象可以修改它，而不可變對(duì)象不可以。
默認(rèn)情況下 Scala 使用不可變 Map。如果你需要使用可變集合，你需要顯式的引入 import scala.collection.mutable.Map 類
在 Scala 中 你可以同時(shí)使用可變與不可變 Map，不可變的直接使用 Map，可變的使用 mutable.Map。

// 空哈希表，鍵為字符串，值為整型
var A:Map[Char,Int] = Map()

// Map 鍵值對(duì)演示
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

示例：
···
object Test {
def main(args: Array[String]) {
val colors = Map("red" -> "#FF0000",
"azure" -> "#F0FFFF",
"peru" -> "#CD853F")

  val nums: Map[Int, Int] = Map()

  println( "colors 中的鍵為 : " + colors.keys )
  println( "colors 中的值為 : " + colors.values )
  println( "檢測(cè) colors 是否為空 : " + colors.isEmpty )
  println( "檢測(cè) nums 是否為空 : " + nums.isEmpty )

}
}
···

4. Seq序列

創(chuàng)建Seq:

val s1 = Seq(1,2,3,4,5)
val s2 = Seq(6,7,8,9,10)
// 獲取某個(gè)下標(biāo)的值

索引和長(zhǎng)度

scala> val s1=Seq(1,2,3)
s1: Seq[Int] = List(1, 2, 3)

scala> s1(1)
res0: Int = 2

scala> print(s1(1))
2
// 是否包括該下標(biāo)，下標(biāo)從0開(kāi)始
scala> s1.isDefinedAt(1)
res2: Boolean = true

// seq長(zhǎng)度，結(jié)果:res0: Int = 5
s1.length
    
// seq長(zhǎng)度比n大則返回+1，比n少則返回-1，=n則返回0
s1.lengthCompare(5)
    
// 返回0--(s1.length-1) 的Range
// 結(jié)果: res0: scala.collection.immutable.Range = Range 0 until 5
s1.indices

查詢下標(biāo)

     //查詢?cè)?所在的下標(biāo)
     //結(jié)果 res0: Int = 0
     s1.indexOf(1)
     //查找該元素的最后一個(gè)索,res0: Int = 2
     val s3 = Seq(1,2,2,4,5,2,2,4)
     s3.lastIndexOf(2)
     //右邊seq在左邊seq的開(kāi)始匹配索引
     //結(jié)果:res0: Int = 1
     val s4 = Seq(2,2,4)
     s3.indexOfSlice(s4)
     ////右邊seq在左邊seq的最后匹配索引
     //結(jié)果:res0: Int = 5
     s3.lastIndexOfSlice(s4)
     //查找第一個(gè)滿足條件的索引
     //結(jié)果:res0: Int = 3
     s3.indexWhere(_ > 2)
     //從seq(n)開(kāi)始，連續(xù)滿足條件的個(gè)數(shù)
     //結(jié)果:res0: Int = 2
     s3.segmentLength(_ > 2,3)
     //從seq(0)開(kāi)始，連續(xù)滿足條件的個(gè)數(shù)
     //res0: Int = 8
     s3.prefixLength(_ > 0)

添加

    //把n加入到集合在頭部
    //結(jié)果：res0: Seq[Int] = List(6, 1, 2, 3, 4, 5)
    6 +: s1

    //把n加到集合后面
    //結(jié)果:res0: Seq[Int] = List(1, 2, 3, 4, 5, 6)
    s1 :+ 6

    //第一個(gè)參數(shù)len,第二個(gè)參數(shù)value,如果集合長(zhǎng)度達(dá)<len,則將集合擴(kuò)展到len,并用value填充。否則什么都不做
    //結(jié)果:res0: Seq[Int] = List(1, 2, 3, 4, 5, 2, 2)
    s1 padTo (7,2)

更新

    // 從下標(biāo)為2[index]的元素開(kāi)始，用集合s2所有元素替換掉1[n]個(gè)數(shù)。
    // 結(jié)果:res0: Seq[Int] = List(1, 2, 6, 7, 8, 9, 10, 4, 5)
    s1.patch(2,s2,1)
    // 更新下標(biāo)i的值
    // 結(jié)果:res0: Seq[Int] = List(1, 2, 10, 4, 5)
    s1.updated(2,10)

排序

     val s3 = Seq(4,2,5,8,3,0)
    //按自然升序排
    //結(jié)果:res0: Seq[Int] = List(0, 2, 3, 4, 5, 8)
    s3.sorted
    //按自定義函數(shù)排序
    //結(jié)果:res0: Seq[Int] = List(8, 5, 4, 3, 2, 0)
    s3.sortWith((x,y) => x > y)
    //從大到小,結(jié)果:res0: Seq[Int] = List(8, 5, 4, 3, 2, 0)
    s3.sortBy(x => -x)
    //從小到大，結(jié)果:res0: Seq[Int] = List(0, 2, 3, 4, 5, 8)
    s3.sortBy(x => x)

反轉(zhuǎn)

    //把集合反轉(zhuǎn)，結(jié)果:res0: Seq[Int] = List(5, 4, 3, 2, 1)
    s1.reverse
    //返回反轉(zhuǎn)后的集合迭代器
    //結(jié)果:54321
    val it = s1.reverseIterator
    while (it.hasNext) {
      print(it.next())
    }
    //反轉(zhuǎn)集合，按指定函數(shù)進(jìn)行map
    //結(jié)果:res0: Seq[Int] = List(6, 5, 4, 3, 2)
    s1.reverseMap(x => x + 1)

比較

    val s3 = Seq(1,2,3)
    //判斷是否以另一個(gè)集合開(kāi)始,元素和順序一致
    //結(jié)果:res0: Boolean = true
    s1.startsWith(s3)

    //判斷是否以另一個(gè)集合結(jié)尾，元素和順序一致
    //結(jié)果:res0: Boolean = true
    val s4 = Seq(3,4,5)
    s1.endsWith(s4)

    //判斷集合是否包含某個(gè)元素
    //結(jié)果:res0: Boolean = true
    s1.contains(2)

    //判斷是否包含另一個(gè)集合的連續(xù)字段
    //結(jié)果:res0: Boolean = true
    s1.containsSlice(s3)

    //判斷兩個(gè)集合長(zhǎng)度，按下標(biāo)遍歷，滿足輸入函數(shù)的返回true，不滿足的返回false
    //結(jié)果:res0: Boolean = true
    val s5 = Seq(1,2,3,4,5)
    s1.corresponds(s5)((x,y)=>x == y)

多集合操作

     val s3 = Seq(0,1,2,3,4)
     //獲取兩個(gè)集合的交集
     //結(jié)果:res0: Seq[Int] = List(1, 2, 3, 4)
     s1.intersect(s3)
     //獲取第一個(gè)集合有，第二個(gè)集合沒(méi)有的
     //結(jié)果:res0: Seq[Int] = List(5)
     s1.diff(s3)
     //兩個(gè)集合合并
     //結(jié)果：res0: Seq[Int] = List(1, 2, 3, 4, 5, 0, 1, 2, 3, 4)
     s1.union(s3)
     //集合去重
     //結(jié)果:res0: Seq[Int] = List(1, 2, 3, 4)
     val s4 = Seq(1,1,2,3,2,3,4)
     s4.distinct

可變集合 添加

// 必須導(dǎo)入mutable包
import scala.collection.mutable

scala> import scala.collection.mutable
import scala.collection.mutable

scala> val buffer = mutable.Buffer(1,2,3,4,5)
buffer: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4, 5)

    val buffer = mutable.Buffer(1,2,3,4,5)
    val b2 = mutable.Buffer(7,8)
    //向buffer增加一個(gè)元素
    //結(jié)果:res0: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 6)
    buffer += 6

    //向buffer增加幾個(gè)元素
    //結(jié)果:res0: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 7, 8, 9)
    buffer += (7,8,9)

    //添加集合
    //結(jié)果:res0: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 7, 8)
    buffer ++= b2

    //把元素放在集合頭部
    //結(jié)果:res0: scala.collection.mutable.Buffer[Int] = ArrayBuffer(6, 1, 2, 3, 4, 5)
    6 +=: buffer

    //把集合放buffer頭部
    //結(jié)果:res0: scala.collection.mutable.Buffer[Int] = ArrayBuffer(7, 8, 1, 2, 3, 4, 5)
    b2 ++=: buffer
    //在下標(biāo)i，插入元素
    //結(jié)果:1210345
    buffer.insert(2,10)
    //從下標(biāo)開(kāi)始插入整個(gè)數(shù)組
    //結(jié)果:12789345
    val arr = Array(7,8,9)
    buffer.insertAll(2,arr)

可變集合 刪除

     val s3 = Seq(0,1,2,3,4)
     //獲取兩個(gè)集合的交集
     //結(jié)果:res0: Seq[Int] = List(1, 2, 3, 4)
     s1.intersect(s3)
     //獲取第一個(gè)集合有，第二個(gè)集合沒(méi)有的
     //結(jié)果:res0: Seq[Int] = List(5)
     s1.diff(s3)
     //兩個(gè)集合合并
     //結(jié)果：res0: Seq[Int] = List(1, 2, 3, 4, 5, 0, 1, 2, 3, 4)
     s1.union(s3)
     //集合去重
     //結(jié)果:res0: Seq[Int] = List(1, 2, 3, 4)
     val s4 = Seq(1,1,2,3,2,3,4)
     s4.distinct

Scala的Seq將是Java的List，Scala的List將是Java的LinkedList。

5. range()

scala> (1 to 10).toList
res3: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

6. Tuple元組

元組是不同類型的值的集合

    // 簡(jiǎn)單Tuple
    val t = ("yxj", 30) // Tuple2
    println(t._1) // 訪問(wèn)Tuple中的數(shù)據(jù)，從1開(kāi)始，帶上下劃線
    println(t._2)
 
    val student = new Tuple3(1, "yxj", 30) // Tuple3
    println(student)
 
    //zip操作
    val names = Array("t", "tt", "ttt")
    val ages = Array(10, 20, 30)
    val nameAges = names.zip(ages)
    println(nameAges) // [Lscala.Tuple2;@13deb50e
    println(nameAges.mkString(",")) // (t,10),(tt,20),(ttt,30)
 
    // 增強(qiáng)for循環(huán)
    for ((name, age) <- nameAges) {
      println("name=" + name + ",age=" + age)
    }
 
    val students = Array((1, "yxj", 30), (2, "yxj2", 32), (3, "yxj3", 33))
    for ((id, name, age) <- students) {
      println("id=" + id + ",name=" + name + ",age=" + age)
    }

二、Iterator（迭代器）

Scala Iterator（迭代器）不是一個(gè)集合，它是一種用于訪問(wèn)集合的方法。
迭代器 it 的兩個(gè)基本操作是 next 和 hasNext。
調(diào)用 it.next() 會(huì)返回迭代器的下一個(gè)元素，并且更新迭代器的狀態(tài)。
調(diào)用 it.hasNext() 用于檢測(cè)集合中是否還有元素。
讓迭代器 it 逐個(gè)返回所有元素最簡(jiǎn)單的方法是使用 while 循環(huán)：

bject Test {
   def main(args: Array[String]) {
      val it = Iterator("Baidu", "Google", "Runoob", "Taobao")
      
      while (it.hasNext){
         println(it.next())
      }
   }
}

三、集合操作符

:: +: :+ ++ ++: :::

這些符號(hào)全都是連接的作用，將元素與集合、集合與集合相連接。
::操作符是右結(jié)合的，如9 :: 5 :: 2 :: Nil相當(dāng)于9 :: (5 :: (2 :: Nil))。所以:: +: :::這些操作符都是在前面插入（ ++: 除外）。:+ ++ ++:這些是追加、拼接。

scala> val a =  List(1,2,3)
a: List[Int] = List(1, 2, 3)

scala> val b = List(4,5,6)
b: List[Int] = List(4, 5, 6)

scala> a :: b
res20: List[Any] = List(List(1, 2, 3), 4, 5, 6)