Scala的集合操作之，可變數(shù)組和不可變數(shù)組，可變List集合與不可變List集合
不可變數(shù)組
/*
traversable/?tr?v?s?bl/adj.能越過的；可否認(rèn)的
*/
object Test01_ImmutableArray {
def main(args: Array[String]): Unit = {
// 1. 創(chuàng)建數(shù)組
val arr: Array[Int] = new Array[Int](5)
// 另一種創(chuàng)建方式
/*
Array.apply(12, 37, 42, 58, 97)通過Array伴生對(duì)象的apply方法獲取一個(gè)數(shù)組對(duì)象，
apply方法可以省略。等價(jià)于Array(12, 37, 42, 58, 97)
*/
val arr2 = Array(12, 37, 42, 58, 97)
println(arr)
// 2. 訪問元素
println(arr(0))
println(arr(1))
println(arr(4))
// println(arr(5))
arr(0) = 12
arr(4) = 57
println(arr(0))
println(arr(1))
println(arr(4))
println("========================")
// 3. 數(shù)組的遍歷
// 1) 普通for循環(huán)
// for (i <- 0 to arr.length-1) println(arr(i))
for (i <- 0 until arr.length){
println(arr(i))
}
/*
源碼注釋：
Produces the range of all indices of this sequence.
@return a `Range` value from `0` to one less than the length of this $coll.
indices方法實(shí)際上還是返回Range伴生對(duì)象的until方法
def indices: Range = 0 until length
*/
for (i <- arr.indices) println(arr(i))
println("---------------------")
// 2) 直接遍歷所有元素，增強(qiáng)for循環(huán)
for (elem <- arr2) println(elem)
println("---------------------")
// 3) 迭代器
val iter = arr2.iterator
while (iter.hasNext)
println(iter.next())
println("---------------------")
// 4) 調(diào)用foreach方法
arr2.foreach( (elem: Int) => println(elem) )
// 下面這個(gè)foreach遍歷跟上面的等價(jià)
arr.foreach( println )
println(arr2.mkString("--"))
println("========================")
// 4. 添加元素
val newArr = arr2.:+(73)
println(arr2.mkString("--"))
println(newArr.mkString("--"))
val newArr2 = newArr.+:(30)
println(newArr2.mkString("--"))
val newArr3 = newArr2 :+ 15
val newArr4 = 19 +: 29 +: newArr3 :+ 26 :+ 73
println(newArr4.mkString(", "))
}
}
可變數(shù)組ArrayBuffer
/**
* with: 和...在一起，具有，支持的含義
* 一個(gè)類繼承一個(gè)特質(zhì)用extends,多個(gè)特質(zhì)用，extends ..with..
* class 類名 extends 特質(zhì) 1 with 特質(zhì) 2 with 特質(zhì) 3...
*/
object Test02_ArrayBuffer {
def main(args: Array[String]): Unit = {
// 1. 創(chuàng)建可變數(shù)組
val arr1: ArrayBuffer[Int] = new ArrayBuffer[Int]()
val arr2 = ArrayBuffer(23, 57, 92)
println(arr1)
println(arr2)
// 2. 訪問元素
// println(arr1(0)) // error
println(arr2(1))
arr2(1) = 39
println(arr2(1))
println("======================")
// 3. 添加元素，:+操作會(huì)返回一個(gè)新的數(shù)組對(duì)象，+=操作返回的是原數(shù)組自身對(duì)象
val newArr1 = arr1 :+ 15
println(arr1)
println(newArr1)
println(arr1 == newArr1)
//可變數(shù)組推薦使用+=操作
val newArr2 = arr1 += 19
println(arr1)
println(newArr2)
println(arr1 == newArr2)
newArr2 += 13
println(arr1)
77 +=: arr1
println(arr1)
println(newArr2)
println("==============================")
/*
append(元素)向數(shù)組末尾添加一個(gè)元素
prepend(元素)向數(shù)組頭部添加一個(gè)元素
insert(元素1,元素2)向數(shù)組插入多個(gè)元素
insertAll(2, newArr)向數(shù)組2索引位置開始插入一個(gè)新的數(shù)組
prependAll(newArr)向數(shù)組頭部插入一個(gè)新的數(shù)組
*/
arr1.append(36)
arr1.prepend(11, 76)
arr1.insert(1, 13, 59)
println(arr1)
arr1.insertAll(2, newArr1)
arr1.prependAll(newArr2)
println("************************")
println("arr1: ==> " + arr1)
/**
* 刪除操作：
* remove(n: Int, count: Int)方法，從數(shù)組n索引位置開始刪除count個(gè)元素
* remove(n: Int)刪除數(shù)組n索引位置的數(shù)據(jù)
*/
// 4. 刪除元素
arr1.remove(3)
println(arr1)
arr1.remove(0, 10)
println(arr1)
//調(diào)用 -=方法刪除某個(gè)元素
arr1 -= 13
println(arr1)
// 5. 可變數(shù)組轉(zhuǎn)換為不可變數(shù)組
val arr: ArrayBuffer[Int] = ArrayBuffer(23, 56, 98)
val newArr: Array[Int] = arr.toArray
println(newArr.mkString(", "))
println(arr)
// 6. 不可變數(shù)組轉(zhuǎn)換為可變數(shù)組
val buffer: mutable.Buffer[Int] = newArr.toBuffer
println(buffer)
println(newArr)
}
}
多維數(shù)組
object Test03_MulArray {
def main(args: Array[String]): Unit = {
// 1. 創(chuàng)建二維數(shù)組
val array: Array[Array[Int]] = Array.ofDim[Int](2, 3)
// 2. 訪問元素
array(0)(2) = 19
array(1)(0) = 25
println(array.mkString(", "))
for (i <- 0 until array.length; j <- 0 until array(i).length){
println(array(i)(j))
}
for (i <- array.indices; j <- array(i).indices){
print(array(i)(j) + "\t")
if (j == array(i).length - 1) println()
}
array.foreach(line => line.foreach(println))
array.foreach(_.foreach(println))
}
}
不可變List集合
/** List底層源碼，Scala在List包對(duì)象中對(duì)List類型進(jìn)行了重定義：type List[+A] = scala.collection.immutable.List[A]
* 我們可以看到，這里的List實(shí)際上就是來自不可變集合包下的List.
* List是一個(gè)抽象類，sealed abstract class List[+A]；無法直接New對(duì)象，它繼承了AbstractSeq特質(zhì)，具有LinearSeq[A]等特質(zhì)
* 與List抽象類對(duì)應(yīng)的有一個(gè)同名的伴生對(duì)象List,我們可以調(diào)用伴生對(duì)象的apply方法創(chuàng)建List[T] 集合
*/
object Test04_List {
def main(args: Array[String]): Unit = {
// 1. 創(chuàng)建一個(gè)List，不可變的List
//val list1 = List.apply(23, 65, 87)，因?yàn)閍pply方法調(diào)用可以簡化，直接寫成List(元素1,元素2,...)
val list1 = List(23, 65, 87)
println(list1)
// 2. 訪問和遍歷元素
println(list1(1))
// list沒有索引
list1.foreach(println)
/*
3. 添加元素
+: 向list集合前面頭部添加元素
:+ 向list集合尾部添加元素
*/
val list2 = 10 +: list1
val list3 = list1 :+ 23
println("list1: "+list1)
println("list2: "+list2)
println("list3: "+list3)
println("==================")
/**
* 雙冒號(hào)的功能：
* ::是Lits集合自帶的方法，用于為集合添加一個(gè)元素,直接添加到集合的頭部
* 例如：list2.::(51)，在list2集合前面添加一個(gè)51的元素
* Nil.::(13)也可以為一個(gè)空的list集合添加一個(gè)元素
*/
val list4 = list2.::(51)
println("list4: "+list4)
val list5 = Nil.::(13)
println("list5: "+list5)
val list6 = 73 :: 32 :: Nil
// Nil空list集合對(duì)象，可以鏈?zhǔn)秸{(diào)用雙冒號(hào)方法從右向左依次去添加元素
val list7 = 17 :: 28 :: 59 :: 16 :: Nil
println("list7: "+ list7)
// 4. 合并列表
val list8 = list6 :: list7
println("list8: "+list8)
/**
* 三冒號(hào)和++ 操作：
* ::: 與++ 都能實(shí)現(xiàn)將一個(gè)list集合所有元素加入另外一個(gè)list集合中
*/
val list9 = list6 ::: list7
println("list9: "+ list9)
val list10 = list6 ++ list7
println("list10: "+ list10)
}
}
可變List集合ListBuffer操作
object Test05_ListBuffer {
def main(args: Array[String]): Unit = {
// 1. 創(chuàng)建可變列表
val list1: ListBuffer[Int] = new ListBuffer[Int]()
val list2 = ListBuffer(12, 53, 75)
println("list1 ==> " + list1)
println("list2 ==> " + list2)
println("==============")
// 2. 添加元素
list1.append(15, 62)
list2.prepend(20)
list1.insert(1, 19, 22)
println("list1 ==> " + list1 )
println("list2 ==> " + list2)
println("==============")
/**
* +=:帶冒號(hào)的操作是從右向左，向頭部添加元素
* += 不帶冒號(hào)的操作方法是默認(rèn)加到list集合后邊
*
*/
31 +=: 96 +=: list1 += 25 += 11
println("list1 ==> " + list1)
println("==============")
// 3. 合并list,++操作方法是克隆原來的集合，在復(fù)制的集合上進(jìn)行操作。合并后返回一個(gè)新的集合
val list3 = list1 ++ list2
println("list1 ==> " + list1)
println("list2 ==> " + list2)
println("==============")
// ++=會(huì)直接覆蓋原來的集合
list1 ++=: list2
println("list1 ==> " + list1)
println("list2 ==> " + list2)
println("==============")
// 4. 修改元素，把索引位置為3的元素修改為30
list2(3) = 30 //它底層調(diào)用了update方法
list2.update(0, 89)
println("list2 ==> " + list2)
// 5. 刪除元素，指定某個(gè)索引位置的元素，也可以使用-=操作方法
list2.remove(2)
list2 -= 25
println("list2 ==> " + list2)
}
}
不可變Set集合操作
object Test06_ImmutableSet {
def main(args: Array[String]): Unit = {
// 1. 創(chuàng)建set,使用Set的伴生對(duì)象創(chuàng)建Set集合，set集合無序，因此會(huì)去重
val set1 = Set(13, 23, 53, 12, 13, 23, 78)
println(set1)
println("==================")
// 2. 添加元素
//val set2 = set1.+(129)跟下面的等價(jià)
val set2 = set1 + 129
println(set1)
println(set2)
println("==================")
// 3. 合并兩個(gè)set集合，使用++操作方法，會(huì)返回一個(gè)新的set的集合
val set3 = Set(19, 13, 23, 53, 67, 99)
val set4 = set2 ++ set3
println(set2)
println(set3)
println(set4)
// 4. 刪除元素，使用-
val set5 = set3 - 13
println(set3)
println(set5)
}
}
可變Set集合mutable.Set操作
object Test07_MutableSet {
def main(args: Array[String]): Unit = {
// 1. 創(chuàng)建set
val set1: mutable.Set[Int] = mutable.Set(13, 23, 53, 12, 13, 23, 78)
println("set1 => " +set1)
println("==================")
// 2. 添加元素
val set2 = set1 + 11
println("set1 => " + set1)
println("set2 => " + set2)
set1 += 11
println("set1 => " + set1)
val flag1 = set1.add(10)
println("flag1 => " + flag1)
println("set1 => " + set1)
val flag2 = set1.add(10)
println("flag2 => " + flag2)
println("set1 => " + set1)
println("==================")
// 3. 刪除元素
set1 -= 11
println(set1)
val flag3 = set1.remove(10)
println("flag3 => " + flag3)
println("set1 => " + set1)
val flag4 = set1.remove(10)
println("flag4 => " + flag4)
println("set1 => " + set1)
println("==================")
// 4. 合并兩個(gè)Set
val set3 = mutable.Set(11,22,33)
println("set1: " + set1 )
println("set3 => " + set3 )
println("******************")
// 合并set1集合與set3集合,返回合并后的新的集合
val set4= set1 ++ set3
// println("set4: " + set4 )
//set3 ++= set1就會(huì)把set1集合的元素合并到set3里面
set3 ++= set1 //set3調(diào)用 ++=方法, 誰調(diào)用誰改變
println("set1: " + set1)
println("set3 => "+ set3)
}
}
Scala集合操作之可變Map 集合和不可變Map集合,元組數(shù)據(jù)操作
不可變Map集合
object Test08_ImmutableMap {
def main(args: Array[String]): Unit = {
// 1. 創(chuàng)建map
val map1: Map[String, Int] = Map("a" -> 13, "b" -> 25, "hello" -> 3)
println(map1)
println(map1.getClass)
println("==========================")
// 2. 遍歷元素
map1.foreach(println)
map1.foreach( (kv: (String, Int)) => println(kv) )
println("============================")
// 3. 取map中所有的key 或者 value
// keys是包含所有key的Iterable[K]集合
// 也可以獲取所有map集合的所有key的keySet集合，然后遍歷keySet集合獲取所有key，在根據(jù)key獲取value值
for (key <- map1.keys){
println(s"$key ---> ${map1.get(key)}")
}
// 4. 訪問某一個(gè)key的value
println("a: " + map1.get("a").get)
/**
* map1.get("a")獲取的是一個(gè)Option[+A] 類型,但Option是一個(gè)密封的抽象類，
對(duì)應(yīng)有兩個(gè)實(shí)現(xiàn)：
一個(gè)為None: 如果根據(jù)key獲取不到值，返回的就是一個(gè)空集合對(duì)象，對(duì)應(yīng)的就是 None
case object None extends Option[Nothing] {
def isEmpty = true
def get = throw new NoSuchElementException("None.get")
}
另外一個(gè)為：Some: 如果根據(jù)key獲得值了，返回的就是 Some
final case class Some[+A](@deprecatedName('x, "2.12.0") value: A) extends Option[A] {
def isEmpty = false
def get = value
@deprecated("Use .value instead.", "2.12.0") def x: A = value
}
* map1集合里面沒有key為c的鍵值對(duì)，如果去獲取value值就會(huì)報(bào)空指針異常
* 為了避免報(bào)異常可以調(diào)用 getOrElse("c", 0)這個(gè)方法，含義是如果對(duì)應(yīng)的鍵值對(duì)存在則返回，不存在默認(rèn)返回0
*/
println("c: " + map1.get("c"))
println("c: " + map1.getOrElse("c", 0))
//map1.put() 不可變Map是不能往里面添加元素的
println(map1("a"))
}
}
可變Map操作
object Test09_MutableMap {
def main(args: Array[String]): Unit = {
// 1. 創(chuàng)建map
val map1: mutable.Map[String, Int] = mutable.Map("a" -> 13, "b" -> 25, "hello" -> 3)
println(map1)
println(map1.getClass)
println("==========================")
// 2. 添加元素
map1.put("c", 5)
map1.put("d", 9)
println(map1)
/*
* 使用符號(hào)添加數(shù)據(jù)，+=方法，底層調(diào)用的是update方法，
* ` def update(key: K, value: V) { this += ((key, value)) } `
* += 后面跟了一個(gè)k-v鍵值對(duì)的二元組，因此可以使用這種方式添加元素
*/
map1 += (("e", 7)) //("e", 7)這個(gè)一個(gè)key-vale的二元組
println(map1)
println("===========================")
// 3. 刪除元素
println(map1("c"))
map1.remove("c")
println(map1.getOrElse("c", 0))
map1 -= "d"
println(map1)
println("====================")
// 4. 修改元素
map1.update("c", 5)
map1.update("e", 10)
println(map1)
println("====================")
// 5. 合并兩個(gè)Map
val map2: Map[String, Int] = Map("aaa" -> 11, "b" -> 29, "hello" -> 5)
// 符號(hào)操作為 ++=
// 把map2中的所有鍵值對(duì)元素，添加到map1中
map1 ++= map2
println(map1)
println(map2)
println("---------------------------")
val map3: Map[String, Int] = map2 ++ map1
println(map1)
println(map2)
println(map3)
}
}
元組操作
object Test10_Tuple {
def main(args: Array[String]): Unit = {
// 1. 創(chuàng)建元組
val tuple: (String, Int, Char, Boolean) = ("hello", 100, 'a', true)
println(tuple)
// 2. 訪問數(shù)據(jù)
println(tuple._1)
println(tuple._2)
println(tuple._3)
println(tuple._4)
println(tuple.productElement(1))
println("=========================")
// 3. 遍歷元組數(shù)據(jù)
for (elem <- tuple.productIterator)
println(elem)
// 4. 嵌套元組
val mulTuple = (12, 0.3, "hello", (23, "scala"), 29)
println(mulTuple._4._2)
}
}
for推導(dǎo)式和yield關(guān)鍵字
for推導(dǎo)式的用法
Scala中的for推導(dǎo)式是一種用于對(duì)集合進(jìn)行迭代和轉(zhuǎn)換的強(qiáng)大工具。它提供了一種簡潔的語法來處理集合中的元素，并生成新的集合或執(zhí)行特定的操作。
for推導(dǎo)式的基本語法如下：
for (pattern <- collection) {
// 循環(huán)體
}
其中，pattern是一個(gè)模式，用于解構(gòu)集合中的元素，collection是要遍歷的集合。
以下是幾種常見的for推導(dǎo)式的用法：
- 遍歷集合并執(zhí)行操作：
val numbers = List(1, 2, 3, 4, 5)
for (num <- numbers) {
println(num)
}
上述示例中，for推導(dǎo)式遍歷numbers列表中的每個(gè)元素，并將其打印出來。
- 過濾并轉(zhuǎn)換集合元素：
val numbers = List(1, 2, 3, 4, 5)
val evenSquares = for (num <- numbers if num % 2 == 0) yield num * num
println(evenSquares)
上述示例中，for推導(dǎo)式通過添加if條件來過濾出偶數(shù)，然后將符合條件的偶數(shù)平方存儲(chǔ)在evenSquares列表中。
- 多個(gè)集合的交叉操作：
val colors = List("red", "green", "blue")
val sizes = List("small", "medium", "large")
val combinations = for {
color <- colors
size <- sizes
} yield (color, size)
println(combinations)
上述示例中，for推導(dǎo)式嵌套遍歷colors和sizes列表，并生成顏色和尺寸的所有可能組合。
除了基本語法之外，for推導(dǎo)式還可以使用模式匹配、嵌套條件、變量綁定等更高級(jí)的特性。您可以根據(jù)具體的需求來靈活使用和組合這些特性，以實(shí)現(xiàn)更復(fù)雜的邏輯。
需要注意的是，for推導(dǎo)式在編譯時(shí)會(huì)被轉(zhuǎn)換為其他高階函數(shù)（如map、filter、flatMap等），因此它具有與使用高階函數(shù)相似的性能特性和靈活性。
yield的使用
在Scala中，yield是一個(gè)關(guān)鍵字，用于生成集合或其他類型的值。它通常用于for循環(huán)中，以遍歷集合元素并執(zhí)行某些操作。以下是yield關(guān)鍵字的主要用法：
- 在for循環(huán)中生成新的集合
val numbers = List(1, 2, 3, 4, 5)
val squares = for (number <- numbers) yield number * number
println(squares) // 輸出: List(1, 4, 9, 16, 25)
上述示例中，yield關(guān)鍵字用于在for循環(huán)中生成新的集合squares，這個(gè)新的集合的元素是通過對(duì)原始集合numbers的每個(gè)元素進(jìn)行平方運(yùn)算得到的。
- 與模式匹配一起使用
case class Person(name: String, age: Int)
val people = List(Person("Alice", 25), Person("Bob", 30), Person("Charlie", 35))
val names = for (Person(name, _) <- people) yield name
println(names) // 輸出: List(Alice, Bob, Charlie)
上述示例中，yield關(guān)鍵字用于提取people列表中每個(gè)Person對(duì)象的name屬性，并生成一個(gè)新的列表names。
- 用于表達(dá)式求值
val result = (for (i <- 1 to 10) yield i * i).sum
println(result) // 輸出: 385
在上述示例中，yield關(guān)鍵字用于生成一個(gè)包含1到10的數(shù)值的集合，并對(duì)每個(gè)元素求平方。隨后，調(diào)用sum方法對(duì)所有元素進(jìn)行求和，并返回結(jié)果。文章來源：http://www.zghlxwxcb.cn/news/detail-695542.html
需要注意的是，在Scala中，yield關(guān)鍵字只會(huì)將新的集合或值返回給程序的其他部分，它不會(huì)修改原始的集合或任何其他的狀態(tài)。此外，yield關(guān)鍵字只能用于帶有for循環(huán)的語句中，且只有僅包含一個(gè)表達(dá)式的for循環(huán)才能使用yield生成結(jié)果。文章來源地址http://www.zghlxwxcb.cn/news/detail-695542.html
到了這里，關(guān)于Scala的集合操作之可變數(shù)組和不可變數(shù)組，可變List集合與不可變List集合,可變Set與不可變Set操作，可變和不可變Map集合和元組操作的文章就介紹完了。如果您還想了解更多內(nèi)容，請?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
