scala 基本介紹與用法（二）

目錄

十三、數組

定長數組

變長數組

添加/修改/刪除元素

遍歷數組

數組常用算法

十四、元組

定義元組

訪問元組

十五、列表

十六、可變列表

可變列表操作

十七、列表常用操作

1.判斷列表是否爲空

2.拼接兩個列表

3.獲取列表的首個元素和剩餘部分

4.反轉列表

5.獲取列表前綴和後綴

6.扁平化(壓平)

7.拉鍊與拉開

8.轉換字符串

9.生成字符串

10.並集

11.交集

12差集

十八、Set

不可變集

可變集

十九、映射

不可變Map

可變Map

二十、Map基本操作

二十一、iterator迭代器

---

 

十三、數組

scala中，有兩種數組，一種是定長數組，另一種是變長數組

定長數組

• 定長數組指的是數組的長度是不允許改變的
• 數組的元素是可以改變的

// 通過指定長度定義數組
val/var 變量名 = new Array[元素類型](數組長度)
​
// 用元素直接初始化數組
val/var 變量名 = Array(元素1, 元素2, 元素3...)

• 在scala中，數組的泛型使用[]來指定
• 使用()來獲取元素

scala> val a = new Array[Int](100)
a: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
​
scala> a(0) = 110
​
scala> println(a(0))
110

變長數組

變長數組指的是數組的長度是可變的，可以往數組中添加、刪除元素

創建變長數組，需要提前導入ArrayBuffer類import scala.collection.mutable.ArrayBuffer

語法

創建空的ArrayBuffer變長數組，語法結構：

• val/var a = ArrayBuffer[元素類型]()

創建帶有初始元素的ArrayBuffer

• val/var a = ArrayBuffer(元素1，元素2，元素3....)

//長度爲0的整型變長數組
val a = ArrayBuffer[Int]()
//包含"hadoop", "storm", "spark"元素的變長數組
scala> val a = ArrayBuffer("hadoop", "storm", "spark")
a: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hadoop, storm, spark)

添加/修改/刪除元素

• 使用+=添加元素
• 使用-=刪除元素
• 使用++=追加一個數組到變長數組

// 定義變長數組
scala> val a = ArrayBuffer("hadoop", "spark", "flink")
a: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hadoop, spark, flink)

// 追加一個元素
scala> a += "flume"
res10: a.type = ArrayBuffer(hadoop, spark, flink, flume)

// 刪除一個元素
scala> a -= "hadoop"
res11: a.type = ArrayBuffer(spark, flink, flume)

// 追加一個數組
scala> a ++= Array("hive", "sqoop")
res12: a.type = ArrayBuffer(spark, flink, flume, hive, sqoop)

遍歷數組

可以使用以下兩種方式來遍歷數組：

• 使用for表達式直接遍歷數組中的元素
• 使用索引遍歷數組中的元素

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

scala> for(i<-a) println(i)
1
2
3
4
5

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

scala> for(i <- 0 to a.length - 1) println(a(i))
1
2
3
4
5

scala> for(i <- 0 until a.length) println(a(i))
1
2
3
4
5

0 until n——生成一系列的數字，包含0，不包含n

0 to n ——包含0，也包含n

數組常用算法

以下爲常用的幾個算法：

• 求和——sum方法
• 求最大值——max方法
• 求最小值——min方法
• 排序——sorted方法

// 升序排序
scala> a.sorted
res53: Array[Int] = Array(1, 2, 4, 4, 10)

// 降序
scala> a.sorted.reverse
res56: Array[Int] = Array(10, 4, 4, 2, 1)

十四、元組

元組可以用來包含一組不同類型的值。例如：姓名，年齡，性別，出生年月。元組的元素是不可變的。

定義元組

使用括號來定義元組

val/var 元組 = (元素1, 元素2, 元素3....)

使用箭頭來定義元組（元組只有兩個元素）

val/var 元組 = 元素1->元素2

scala> val a = ("zhangsan", 20)
a: (String, Int) = (zhangsan,20)

scala> val a = "zhangsan" -> 20
a: (String, Int) = (zhangsan,20)

訪問元組

使用_1、_2、_3....來訪問元組中的元素，_1表示訪問第一個元素，依次類推

scala> val a = "zhangsan" -> "male"
a: (String, String) = (zhangsan,male)

// 獲取第一個元素
scala> a._1
res41: String = zhangsan

// 獲取第二個元素
scala> a._2
res42: String = male

十五、列表

列表是scala中最重要的、也是最常用的數據結構。List具備以下性質：

• 可以保存重複的值
• 有先後順序

在scala中，也有兩種列表，一種是不可變列表、另一種是可變列表

定義

不可變列表就是列表的元素、長度都是不可變的。

語法

val/var 變量名 = List(元素1, 元素2, 元素3...)

使用Nil創建一個不可變的空列表

val/var 變量名 = Nil

使用::方法創建一個不可變列表

val/var 變量名 = 元素1 :: 元素2 :: Nil

使用::拼接方式來創建列表，必須在最後添加一個Nil

 

創建一個不可變列表，存放以下幾個元素（1,2,3,4）

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

使用Nil創建一個不可變的空列表

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

使用::方法創建列表，包含-2、-1兩個元素

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

十六、可變列表

可變列表就是列表的元素、長度都是可變的。

要使用可變列表，先要導入import scala.collection.mutable.ListBuffer

• 可變集合都在mutable包中
• 不可變集合都在immutable包中（默認導入）

定義

使用ListBuffer[元素類型]()創建空的可變列表，語法結構：

val/var 變量名 = ListBuffer[Int]()

使用ListBuffer(元素1, 元素2, 元素3...)創建可變列表，語法結構：

val/var 變量名 = ListBuffer(元素1，元素2，元素3...)

 

創建空的整形可變列表

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

創建一個可變列表，包含以下元素：1,2,3,4

scala> val a = ListBuffer(1,2,3,4)
a: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4)

可變列表操作

1. 獲取元素（使用括號訪問(索引值)）
2. 添加元素（+=）
3. 追加一個列表（++=）
4. 更改元素（使用括號獲取元素，然後進行賦值）
5. 刪除元素（-=）
6. 轉換爲List（toList）
7. 轉換爲Array（toArray）

示例

1. 定義一個可變列表包含以下元素：1,2,3
2. 獲取第一個元素
3. 添加一個新的元素：4
4. 追加一個列表，該列表包含以下元素：5,6,7
5. 刪除元素7
6. 將可變列表轉換爲不可變列表
7. 將可變列表轉換爲數組

// 導入不可變列表
scala> import scala.collection.mutable.ListBuffer
import scala.collection.mutable.ListBuffer
// 創建不可變列表
scala> val a = ListBuffer(1,2,3)
a: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)
// 獲取第一個元素
scala> a(0)
res19: Int = 1
// 追加一個元素
scala> a += 4
res20: a.type = ListBuffer(1, 2, 3, 4)
// 追加一個列表
scala> a ++= List(5,6,7)
res21: a.type = ListBuffer(1, 2, 3, 4, 5, 6, 7)
// 刪除元素
scala> a -= 7
res22: a.type = ListBuffer(1, 2, 3, 4, 5, 6)
// 轉換爲不可變列表
scala> a.toList
res23: List[Int] = List(1, 2, 3, 4, 5, 6)
// 轉換爲數組
scala> a.toArray
res24: Array[Int] = Array(1, 2, 3, 4, 5, 6)

十七、列表常用操作

1.判斷列表是否爲空

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)
​
scala> a.isEmpty
res51: Boolean = false

2.拼接兩個列表

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
res52: List[Int] = List(1, 2, 3, 4, 5, 6)

3.獲取列表的首個元素和剩餘部分

scala> val a = List(1,2,3)
a: List[Int] = List(1, 2, 3)
​
scala> a.head
res4: Int = 1
​
scala> a.tail
res5: List[Int] = List(2, 3)

4.反轉列表

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

5.獲取列表前綴和後綴

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

scala> a.take(3)
res56: List[Int] = List(1, 2, 3)

scala> a.drop(3)
res60: List[Int] = List(4, 5)

6.扁平化(壓平)

扁平化表示將列表中的列表中的所有元素放到一個列表中。

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

scala> a.flatten
res0: List[Int] = List(1, 2, 3, 4, 5)

7.拉鍊與拉開

• 拉鍊：使用zip將兩個列表，組合成一個元素爲元組的列表
• 拉開：將一個包含元組的列表，解開成包含兩個列表的元組

scala> val a = List("zhangsan", "lisi", "wangwu")
a: List[String] = List(zhangsan, lisi, wangwu)

scala> val b = List(19, 20, 21)
b: List[Int] = List(19, 20, 21)

scala> a.zip(b)
res1: List[(String, Int)] = List((zhangsan,19), (lisi,20), (wangwu,21)）

scala> res1.unzip
res2: (List[String], List[Int]) = (List(zhangsan, lisi, wangwu),List(19, 20, 21))

8.轉換字符串

toString方法可以返回List中的所有元素

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)
​
scala> println(a.toString)
List(1, 2, 3, 4)

9.生成字符串

mkString方法，可以將元素以分隔符拼接起來。默認沒有分隔符

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)
​
scala> a.mkString
res7: String = 1234
​
scala> a.mkString(":")
res8: String = 1:2:3:4

10.並集

union表示對兩個列表取並集，不去重

scala> val a1 = List(1,2,3,4)
a1: List[Int] = List(1, 2, 3, 4)
​
scala> val a2 = List(3,4,5,6)
a2: List[Int] = List(3, 4, 5, 6)
​
// 並集操作
scala> a1.union(a2)
res17: List[Int] = List(1, 2, 3, 4, 3, 4, 5, 6)
​
// 可以調用distinct去重
scala> a1.union(a2).distinct
res18: List[Int] = List(1, 2, 3, 4, 5, 6)

11.交集

intersect表示對兩個列表取交集

scala> val a1 = List(1,2,3,4)
a1: List[Int] = List(1, 2, 3, 4)
​
scala> val a2 = List(3,4,5,6)
a2: List[Int] = List(3, 4, 5, 6)
​
scala> a1.intersect(a2)
res19: List[Int] = List(3, 4)

12差集

diff表示對兩個列表取差集，例如： a1.diff(a2)，表示獲取a1在a2中不存在的元素

scala> val a1 = List(1,2,3,4)
a1: List[Int] = List(1, 2, 3, 4)
​
scala> val a2 = List(3,4,5,6)
a2: List[Int] = List(3, 4, 5, 6)
​
scala> a1.diff(a2)
res24: List[Int] = List(1, 2)

十八、Set

Set(集)是代表沒有重複元素的集合。Set具備以下性質：

• 元素不重複
• 不保證插入順序

scala中的集也分爲兩種，一種是不可變集，另一種是可變集。

不可變集

語法

創建一個空的不可變集，語法格式：

val/var 變量名 = Set[類型]()

給定元素來創建一個不可變集，語法格式：

val/var 變量名 = Set(元素1, 元素2, 元素3...)

示例一

定義一個空的不可變集

scala> val a = Set[Int]()
a: scala.collection.immutable.Set[Int] = Set()

示例二

定義一個不可變集，保存以下元素：1,1,3,2,4,8

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

基本操作

• 獲取集的大小（size）
• 遍歷集（和遍歷數組一致）
• 添加一個元素，生成一個Set（+）
• 拼接兩個集，生成一個Set（++）
• 拼接集和列表，生成一個Set（++）

示例

// 創建集
scala> val a = Set(1,1,2,3,4,5)
a: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)
​
// 獲取集的大小
scala> a.size
res0: Int = 5
​
// 遍歷集
scala> for(i <- a) println(i)
​
// 刪除一個元素
scala> a - 1
res5: scala.collection.immutable.Set[Int] = Set(5, 2, 3, 4)
​
// 拼接兩個集
scala> a ++ Set(6,7,8)
res2: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 8, 4)
​
// 拼接集和列表
scala> a ++ List(6,7,8,9)
res6: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 9, 2, 7, 3, 8, 4)

可變集

可變集合不可變集的創建方式一致，只不過需要提前導入一個可變集類。

手動導入：import scala.collection.mutable.Set

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

// 添加元素
scala> a += 5
res25: a.type = Set(1, 5, 2, 3, 4)
​
// 刪除元素
scala> a -= 1
res26: a.type = Set(5, 2, 3, 4)

十九、映射

Map可以稱之爲映射。它是由鍵值對組成的集合。在scala中，Map也分爲不可變Map和可變Map。

不可變Map

語法

val/var map = Map(鍵->值, 鍵->值, 鍵->值...) // 推薦，可讀性更好
val/var map = Map((鍵, 值), (鍵, 值), (鍵, 值), (鍵, 值)...)

scala> val map = Map("zhangsan"->30, "lisi"->40)
map: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 30, lisi -> 40)
​
scala> val map = Map(("zhangsan", 30), ("lisi", 30))
map: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 30, lisi -> 30)

// 根據key獲取value
scala> map("zhangsan")
res10: Int = 30

可變Map

定義語法與不可變Map一致。但定義可變Map需要手動導入import scala.collection.mutable.Map

scala> val map = Map("zhangsan"->30, "lisi"->40)
map: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30)
​
// 修改value
scala> map("zhangsan") = 20

二十、Map基本操作

1. 獲取值(map(key))
2. 獲取所有key（map.keys）
3. 獲取所有value（map.values）
4. 遍歷map集合
5. getOrElse
6. 增加key,value對
7. 刪除key

scala> val map = Map("zhangsan"->30, "lisi"->40)
map: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30)
​
// 獲取zhagnsan的年齡
scala> map("zhangsan")
res10: Int = 30
​
// 獲取所有的學生姓名
scala> map.keys
res13: Iterable[String] = Set(lisi, zhangsan)
​
// 獲取所有的學生年齡
scala> map.values
res14: Iterable[Int] = HashMap(40, 30)
​
// 打印所有的學生姓名和年齡
scala> for((x,y) <- map) println(s"$x $y")
lisi 40
zhangsan 30
​
// 獲取wangwu的年齡，如果wangwu不存在，則返回-1
scala> map.getOrElse("wangwu", -1)
res17: Int = -1
​
// 新增一個學生：wangwu, 35
scala> map + "wangwu"->35
res22: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30, wangwu -> 35)
​
// 將lisi從可變映射中移除
scala> map - "lisi"
res23: scala.collection.mutable.Map[String,Int] = Map(zhangsan -> 30)

二十一、iterator迭代器

scala針對每一類集合都提供了一個迭代器（iterator）用來迭代訪問集合

使用迭代器遍歷集合

• 使用iterator方法可以從集合獲取一個迭代器
• 迭代器的兩個基本操作
• hasNext——查詢容器中是否有下一個元素
• next——返回迭代器的下一個元素，如果沒有，拋出NoSuchElementException
• 每一個迭代器都是有狀態的
• 迭代完後保留在最後一個元素的位置
• 再次使用則拋出NoSuchElementException
• 可以使用while或者for來逐個返回元素

示例

1. 定義一個列表，包含以下元素：1,2,3,4,5
2. 使用while循環和迭代器，遍歷打印該列表

scala> val ite = a.iterator
ite: Iterator[Int] = non-empty iterator
​
scala> while(ite.hasNext) {
    | println(ite.next)
    | }

示例

1. 定義一個列表，包含以下元素：1,2,3,4,5
2. 使用for 表達式和迭代器，遍歷打印該列表

scala> val a = List(1,2,3,4,5)
a: List[Int] = List(1, 2, 3, 4, 5)
​
scala> for(i <- a) println(i)