柚子快報激活碼778899分享：Scala學(xué)習(xí)筆記13: 集合

http://yzkb.51969.com/

目錄

第十三章 集合1- 列表 (List)2- 集 (Set)3- 映射 (Map)4- 數(shù)組 (Array)5- 元組 (Tuple)6- 可變和不可變集合7- 添加或者去除元素8- 化簡、折疊和掃描9- 拉鏈操作10- 迭代器end

第十三章 集合

在Scala中, 集合 (Collections) 是一種重要的數(shù)據(jù)結(jié)構(gòu), 用于存儲和操作一組元素 ;

Scala提供了豐富的集合類庫, 包括可變和不可變的集合類型, 以及各種高階函數(shù)和操作符, 方便對集合進行操作和轉(zhuǎn)換 ;

常見的Scala集合類型包括:

列表 (List) : 有序集合, 元素可重復(fù), 使用 List 關(guān)鍵字定義 ;集 (Set) : 無須集合, 元素不重復(fù), 使用 Set 關(guān)鍵字定義 ;映射 (Map) : 鍵值對集合, 鍵不重復(fù), 值可重復(fù), 使用 Map 關(guān)鍵字定義 ;數(shù)組 (Array) : 定長可變集合, 使用 Array 關(guān)鍵字定義 ;元組 (Tuple) : 不同類型元素的有序集合, 使用 (value1, value2, …) 定義 ;

1- 列表 (List)

在Scala中, 列表 (List) 是一種不可變的有序集合, 允許元素重復(fù) ;

列表是基于鏈表結(jié)構(gòu)實現(xiàn)的, 每個列表都由一個頭部元素和一個指向剩余元素列表的尾部組成 ;

Scala的列表提供了豐富的操作方法, 如 map 、filter 、foldLeft 等, 用于對列表進行轉(zhuǎn)換和操作 ;

示例:

// 1. 創(chuàng)建列表: 可以使用List關(guān)鍵字創(chuàng)建列表

val numbers = List(1, 2, 3, 4, 5)

// 2. 訪問元素: 可以使用索引訪問列表中的元素, 索引從0開始

val firstElement = numbers(0)

println(firstElement) // 輸出: 1

// 3. 操作列表: 可以使用map, filter, reduce等方法對列表進行操作

val doubledNumbers = numbers.map(_ * 2)

println(doubledNumbers) // 輸出: List(2, 4, 6, 8, 10)

val evenNumbers = numbers.filter(_ % 2 == 0)

println(evenNumbers) // 輸出: List(2, 4)

val sum = numbers.reduce(_ + _)

println(sum) // 輸出: 15

// 4. 連接列表: 可以使用 `::` 操作符將元素添加到列表的開頭

val newNumbers = 0 :: numbers

println(newNumbers) // 輸出: List(0, 1, 2, 3, 4, 5)

// 5. 列表模式匹配: 可以使用模式匹配來處理列表中的元素

val (head, tail) = numbers match {

case h :: t => (h, t)

case _ => (0, Nil)

}

println(head) // 輸出: 1

println(tail) // 輸出: List(2, 3, 4, 5)

Scala的列表是不可變的, 這意味著列表的內(nèi)容在創(chuàng)建后不可更改 ;

如果需要可變列表, 可以使用 scala.collection.mutable.ListBuffer .

2- 集 (Set)

在Scala中, 集合 (Set) 是一種不可變的元素集合, 其中元素不重復(fù) ;

Scala的集合庫提供了 Set 特質(zhì)以及不可變和可變的具體實現(xiàn), 用于存儲一組唯一的元素 ;

集合在Scala中通常用于快速查找和去重操作 ;

示例:

// 1. 創(chuàng)建集合: 可以使用 `Set` 關(guān)鍵字創(chuàng)建集合

val numberSet = Set(1, 2, 3, 4, 5)

// 2. 添加元素: 集合是不可變的, 無法直接添加元素, 但可以通過創(chuàng)建新的集合來添加元素

val newNumberSet = numberSet + 6

// 3. 操作集合: 可以使用集合的 `map` 方法來對集合中的每個元素進行操作, `insersect` 方法來求交集, `union` 方法來求并集

val otherSet = Set(3, 4, 5, 6, 7)

val intersectSet = numberSet.intersect(otherSet)

val unionSet = numberSet.union(otherSet)

println(intersectSet) // 輸出: Set(5, 3, 4)

println(unionSet) // 輸出: Set(5, 1, 6, 2, 7, 3, 4)

// 4. 檢查元素: 可以使用 `contains` 方法來檢查集合中是否包含某個元素

val containsFive = numberSet.contains(5)

println(containsFive) // 輸出: true

// 5. 遍歷集合: 可以使用 `foreach` 方法來遍歷集合中的每個元素

numberSet.foreach(println)

// 輸出:

// 5

// 1

// 2

// 3

// 4

Scala的集合庫還提供了豐富的方法和操作符, 用于對集合進行操作和轉(zhuǎn)換 ;

集合在Scala中是非常常用且強大的數(shù)據(jù)結(jié)構(gòu), 適應(yīng)于各種場景 .

3- 映射 (Map)

在Scala中, 映射 (Map) 是一種鍵值對的集合, 用于存儲一組唯一的鍵和對應(yīng)的值 ;

Scala的映射是基于哈希表實現(xiàn)的, 可以快速查找和訪問鍵值對 ;

映射在Scala中非常常用, 用于表示各種數(shù)據(jù)關(guān)系和映射關(guān)系 ;

示例:

// 1. 創(chuàng)建映射: 可以使用 `Map` 關(guān)鍵字創(chuàng)建映射

val personInfo = Map("name" -> "Jim", "age" -> 18)

// 2. 訪問值: 可以通過鍵訪問映射中的值

val name = personInfo("name")

val age = personInfo.getOrElse("age", 0)

println(s"name: $name, age: $age") // name: Jim, age: 18

// 3. 添加值: 映射不可變, 無法直接添加鍵值對, 可以通過創(chuàng)建新的映射來添加鍵值對, 可以使用 `+` 運算符添加鍵值對

val newPersonInfo = personInfo + ("gender" -> "male")

println(newPersonInfo) // Map(name -> Jim, age -> 18, gender -> male)

// 4. 操作映射: 可以使用各種方法對映射進行操作, 例如: `keys` 獲取所有鍵, `values` 獲取所有值, `contains` 判斷是否存在鍵

val keys = personInfo.keys

val values = personInfo.values

println(keys) // Set(name, age)

println(values) // MapLike(Jim, 18)

println(personInfo.contains("name")) // true

println(personInfo.contains("gender")) // false

// 5. 遍歷映射: 可以使用 `foreach` 方法遍歷映射, 并執(zhí)行指定的操作

personInfo.foreach {

case (key, value) => println(s"$key: $value")

}

/* 輸出結(jié)果:

name: Jim

age: 18

*/

Scala的映射提供了豐富的方法和操作符, 用于對鍵值對進行操作和轉(zhuǎn)換 ;

映射是一種非常有用的數(shù)據(jù)結(jié)構(gòu), 適應(yīng)于各種場景, 如配置信息, 數(shù)據(jù)索引等 .

4- 數(shù)組 (Array)

在Scala中, 數(shù)組 (Array) 是一種可變的有序集合, 用于存儲固定大小的元素 ;

Scala的數(shù)組與Java的數(shù)組類似, 但Scala的數(shù)組可以是泛型的, 運行存儲不同類型的元素 ;

數(shù)組在Scala中是一種基本的數(shù)據(jù)結(jié)構(gòu), 常用于需要高性能和可變性的場景 ;

示例:

// 1. 創(chuàng)建數(shù)組: 可以使用 `Array` 關(guān)鍵字創(chuàng)建數(shù)組

val numbers = Array(1, 2, 3, 4, 5)

// 2. 訪問元素: 可以使用索引訪問數(shù)組中的元素, 索引從0開始

val firstNumber = numbers(0)

println(firstNumber) // 輸出: 1

// 3. 更新元素: 由于數(shù)組是可變的, 可以使用索引更新數(shù)組中的元素

numbers(0) = 10

println(numbers(0)) // 輸出: 10

// 4. 操作數(shù)組: 可以使用 `map` 方法對數(shù)組進行操作, 例如將數(shù)組中的每個元素乘以2; `filter` 方法對數(shù)組進行過濾, 例如只保留偶數(shù);

val doubledNumbers = numbers.map(_ * 2)

println(doubledNumbers.mkString(", ")) // 輸出: 20, 4, 6, 8, 10

val evenNumbers = numbers.filter(_ % 2 == 0)

println(evenNumbers.mkString(", ")) // 輸出: 2, 4

// 5. 遍歷數(shù)組: 可以使用 `foreach` 方法遍歷數(shù)組

numbers.foreach(println) // 輸出: 10 2 3 4 5

// 6. 轉(zhuǎn)換為列表: 可以使用 `toList` 方法將數(shù)組轉(zhuǎn)換為列表

val numbersList = numbers.toList

println(numbersList) // 輸出: List(10, 2, 3, 4, 5)

Scala的數(shù)組提供了高性能和可變性, 適應(yīng)于需要頻繁修改元素的場景 ;

但需要注意的是, 數(shù)組是可變的數(shù)據(jù)結(jié)構(gòu), 可能引入一些副作用, 因此在函數(shù)式編程中建議盡量使用不可變的集合 .

5- 元組 (Tuple)

在Scala中, 元組 (Tuple) 是一種不可變的有序集合, 用于存儲固定數(shù)量的元素 ;

元組可以包含不同類型的元素, 并且元組的長度是固定的 ;

Scala的元組提供了一種方便的方式來組合和傳遞多個值, 而不需要創(chuàng)建新的類或結(jié)構(gòu) ;

示例:

// 1. 創(chuàng)建元組: 可以使用小括號和逗號創(chuàng)建元組

val person = ("Tom", 18, "London")

// 2. 訪問元組: 可以使用 `.` 和索引訪問元組中的元素, 索引從1開始

val name = person._1

val age = person._2

val city = person._3

println(name) // 輸出: Tom

println(age) // 輸出: 18

println(city) // 輸出: London

// 3.元組模式匹配: 可以使用模式匹配來解構(gòu)元組

person match {

case (name, age, city) => println(s"$name is $age years old, and lives in $city.")

}

// 輸出: Tom is 18 years old, and lives in London.

// 4. 元組轉(zhuǎn)換為列表: 可以使用 `.toList` 方法將元組轉(zhuǎn)換為列表

val personList = person.productIterator.toList

println(personList) // 輸出: List(Tom, 18, London)

// 5. 遍歷元組: 可以使用 `.foreach` 方法遍歷元組中的每個元素

person.productIterator.foreach(println)

/* 輸出:

Tom

18

London

*/

元組的特性: 元組子啊Scala中常用于返回多個值的函數(shù) 、臨時組合數(shù)據(jù)等場景 , 具有簡潔和靈活的特性 ;

Scala的元組是一種輕量級的數(shù)據(jù)結(jié)構(gòu), 適用于需要臨時組合多個值的情況 ;

元組的不可變性和固定長度使其在某些場景下非常有用 .

6- 可變和不可變集合

在Scala中, 集合可以分為可變 (mutable) 和不可變 (immutable) 兩種類型 ;

不可變集合是指一旦創(chuàng)建就無法更改的集合, 任何修改操作都會返回一個新的集合, 原集合保持不變 ;

相反, 可變集合允許在原地修改其內(nèi)容, 即可以直接修改集合而不需要創(chuàng)建新的集合 .

不可變集合在Scala中是更常用的選擇, 因為他們具有線程安全性和函數(shù)式編程的優(yōu)點 ;

不可變集合的操作不會改變原始集合, 而返回一個新的不可變集合, 這有助于避免副作用和提高代碼的可維護性 .

可變集合則適用于需要頻繁修改數(shù)據(jù)的場景, 因為他們允許直接在原地修改集合內(nèi)容, 而不是創(chuàng)建新的集合 ;

可變集合在某些情況下可以提供更高的性能, 但也需要更多的注意力來管理狀態(tài)變化 ;

在Scala中, 不可變集合通常位于 scala.collection.immutable 包中, 而可變集合位于 scala.collection.mutable 包中 ;

開發(fā)者可以根據(jù)具體需求和場景選擇合適的集合類型, 以實現(xiàn)更安全、高效的編程 .

7- 添加或者去除元素

在Scala中, 集合中常用的方法用于添加或去除元素包括 + 、+: 和 :+ ;

+ : 對于不可變無順序的集合, + 方法用于向集合中添加元素并返回一個新的集合, 原集合保持不變 ; 例如: 對于Set集合: val set = Set(1, 2, 3, 4, 5)

val newSet = set + 6

println(newSet) // Set(5, 1, 6, 2, 3, 4)

+: : 對于List集合, +: 方法用于在列表的頭部添加元素并返回一個新的列表, 原列表保持不變 ; 例如: val list = List(3,4,5)

val newList = 1 +: list

println(newList) // List(1, 3, 4, 5)

:+ : 對于List集合, :+ 方法用于在列表的尾部添加元素并返回一個新的列表, 原列表保持不變 ; 例如: val list = List(3,4,5)

val newList = list :+ 6

println(newList) // List(3, 4, 5, 6)

這些操作符都會返回新的集合, 不會修改原有的集合 .

8- 化簡、折疊和掃描

在Scala中, 集合的化簡 (reduce) 、折疊(fold) 和掃描(scan) 是常用的函數(shù)式編程操作, 用于對集合中的元素進行聚合計算 ;

化簡 (reduce) :

reduce 函數(shù)將集合中的元素兩兩結(jié)合, 遞歸地將結(jié)果與下一個元素結(jié)合, 最終返回一個值 ; 示例: 對列表中的元素求和 val list = List(1, 2, 3, 4, 5)

val sum = list.reduce(_ + _)

println(sum) // 15

折疊 (fold) :

fold 函數(shù)接受一個初始值和一個二元操作函數(shù), 從初始值開始, 將集合中的元素依次應(yīng)用于操作函數(shù), 返回最終結(jié)果 ; 示例: 對列表中的元素求和, 初始值為 1000 val list = List(1, 2, 3, 4, 5)

val sum = list.fold(100)((x, y) => x + y) // list.fold(100)(_ + _)

println(sum) // 115

掃描 (scan) :

scan 函數(shù)類似于 fold , 但會返回每一步的中間結(jié)果組成的集合 ; 示例: 對列表中的元素進行累加掃描 val list = List(1, 2, 3, 4, 5)

val scanResult = list.scan(-3)(_ + _)

println(scanResult) // List(-3, -2, 0, 3, 7, 12)

val scanLeftResult = list.scanLeft(-3)(_ + _) // 從左到右

println(scanLeftResult) // List(-3, -2, 0, 3, 7, 12)

val scanRightResult = list.scanRight(-3)(_ + _) // 從右到左

println(scanRightResult) // List(12, 11, 9, 6, 2, -3)

9- 拉鏈操作

在Scala中, 拉鏈操作 (zip) 是一種常見的集合操作, 用于將兩個集合的對應(yīng)元素進行配對 ;

具體來說, 拉鏈操作會將兩個集合中相同位置的元素組成一個元組, 生成一個新的集合 ;

示例:

val list1 = List(1, 2, 3, 4, 5)

val list2 = List("A", "B", "C", "D", "E")

val list3 = list1 zip list2

println(list3) // List((1,A), (2,B), (3,C), (4,D), (5,E))

// 如果兩個列表元素個數(shù)不同, 以最少的進行匹配

val list1 = List(1, 2, 3, 4)

val list2 = List("A", "B", "C", "D", "E")

val list3 = list1 zip list2

println(list3) // List((1,A), (2,B), (3,C), (4,D)

在上面的示例中, list1 和 list2 分別是兩個不同類型的集合, 通過 zip 方法進行拉鏈操作后, 生成了一個包含元組的新集合 list3 , 其中每個元組包含了兩個集合對應(yīng)位置的元素 ;

拉鏈操作在處理需要將兩個集合的元素一一對應(yīng)的情況下非常有用, 可以方便地將兩個集合進行配對操作 .

10- 迭代器

在Scala中, 可以使用迭代器 (Iterator) 來遍歷集合 ;

迭代器提供了一種逐個訪問集合元素的方式, 適用于需要逐個處理集合元素的場景 ;

示例: 使用迭代器遍歷集合的基本方法

val list = List(1, 2, 3, 4, 5)

val it = list.iterator

while (it.hasNext) {

println(it.next())

}

/* 輸出:

1

2

3

4

5

*/

在上面的示例中, 首先創(chuàng)建了一個整數(shù)列表 list , 然后通過 iterator 方法獲取了該列表的迭代器 it ;接著使用 while 循環(huán)和 hasNext 方法判斷是否還有下一個元素, 然后使用 next 方法逐個訪問并處理元素 .

除了使用 while 循環(huán)外, 還可以使用 foreach 方法來簡化迭代器的遍歷:

val list = List(1, 2, 3, 4, 5)

val it = list.iterator

it.foreach(println)

/*

1

2

3

4

5

*/

通過以上方法, 您可以方便地使用迭代器遍歷Scala集合中的元素 .

end

柚子快報激活碼778899分享：Scala學(xué)習(xí)筆記13: 集合

http://yzkb.51969.com/

文章來源