uml => 統一建模語言java
1) Scala同時支持不可變集合和可變集合,不可變集合能夠安全的併發訪問數組
兩個主要的包安全
不可變集合:scala.collection.immutable數據結構
可變集合:scala.collection.mutable併發
2) Scala默認採用不可變集合,對於幾乎全部的集合類,Scala都同時提供了可變(mutable)和不可變(immutable)的版本app
3) Scala的集合有三大類:序列Seq(有序的,Linear Seq),集Set,映射Map[key -> value],全部的集合都擴展自Iterable特質,在Scala中集合有可變(mutable)和不可變(immutable)ide
1) 不可變集合:Scala不可變集合,就是集合自己不能動態變化(相似Java的數組,是不能夠動態增加的)函數
2) 可變集合:可變集合,就是這個集合自己能夠動態變化(好比:ArrayList,是能夠動態增加的)大數據
3) 使用Java作了一個簡單的案例網站
import java.util.ArrayList; public class JavaCollection { public static void main(String[] args) { //不可變集合相似java的數組 int[] nums = new int[3]; nums[2] = 6; //? nums[2] = 7; //nums[3] = 8; //? // String[] names = {"bj", "sh"}; // System.out.println(nums + " " + names); // // //可變集合舉例 ArrayList al = new ArrayList<String>(); al.add("狗蛋"); al.add("鐵蛋"); System.out.println(al + " 地址= " + al.hashCode()); //地址 al.add("熊大"); System.out.println(al + " 地址2=" + al.hashCode()); //地址 } }
1) Set、Map是Java中也有的集合
2) Seq是Java沒有的,咱們發現List歸屬到Seq了,所以這裏的List就和Java不是同一個概念了
3) 前面講述的for循環有一個1 to 3,就是IndexedSeq下的Vector
4) String也是屬於IndexedSeq
5) 經典的數據結構好比Queue和Stack被歸屬到LinearSeq
6) 注意Scala中的Map體系中有一個SortedMap,說明Scala的Map能夠支持排序
7) IndexSeq和LinearSeq的區別[IndexSeq是經過索引來查找和定位,所以速度快,好比String就是一個索引集合,經過索引便可定位] [LinearSeq是線型的,即有頭尾的概念,這種數據結構通常是經過遍從來查找,它的價值在於應用到一些具體的應用場景(電商網站,大數據推薦系統:最近瀏覽的10個商品)]
1) 在可變集合中比不可變集合更豐富
2) 在Seq集合中,增長了Buffer集合,經常使用的有ArrayBuffer和ListBuffer
3) 若是涉及到線程安全問題能夠選擇使用syn...開頭的集合
-說明
這裏的數組等同於Java中的數組,中括號的類型就是數組的類型
val arr = new Array[Int](10)
arr(1) = 9
-案例演示
object boke_demo01 { def main(args: Array[String]): Unit = { //說明 //1. 建立了一個Array對象, //2. [Int] 表示泛型,即該數組中,只能存放Int //3. [Any] 表示 該數組能夠存聽任意類型 //4. 在沒有賦值狀況下,各個元素的值 0 //5. arr(3) = 10 表示修改 第4個元素的值 val arr = new Array[Int](4) //底層 int[] arr = new int[4] println(arr.length) // 4 println("arr(0)=" + arr(0)) // 0 //數據的遍歷 for (i <- arr) { println(i) } println("--------------------") arr(3) = 10 // for (i <- arr) { println(i) } } }
-說明
在定義數組時,直接賦值
//使用apply方法建立數組對象
val arr = Apply(1,2)
-案例演示
object boke_demo01 { def main(args: Array[String]): Unit = { //說明 //1. 使用的是 object Array 的apply //2. 直接初始化數組,這時由於你給了 整數和 "", 這個數組的泛型就Any //3. 遍歷方式同樣 var arr = Array(1, 3, "xx") arr(1) = "xx" for (i <- arr) { println(i) } //可使用咱們傳統的方式遍歷,使用下標的方式遍歷 for (index <- 0 until arr.length) { printf("arr02[%d]=%s", index, arr(index) + "\t") } } }
-說明
//定義/聲明
val arr = ArrayBuffer[Int]()
//追加值/元素
arr.append(9)
//從新賦值
arr(0) = 6
-案例演示
object boke_demo01 { def main(args: Array[String]): Unit = { //建立ArrayBuffer val arr = ArrayBuffer[Any](3, 2, 5) //訪問,查詢 //經過下標訪問元素 println("arr(1)=" + arr(1)) // arr(1) = 2 //遍歷 for (i <- arr) { println(i) } println(arr.length) //3 println("arr.hash=" + arr.hashCode()) //修改 [修改值,動態增長] //使用append 追加數據 ,append支持可變參數 //能夠理解成java的數組的擴容 arr.append(90.0, 13) // (3,2,5,90.0,13) println("arr.hash=" + arr.hashCode()) println("===================") arr(1) = 89 //修改 (3,89,5,90.0,13) println("--------------------------") for (i <- arr) { println(i) } //刪除... //刪除,是根據下標來講 arr.remove(0) // (89,5,90.0,13) println("--------刪除後的元素遍歷---------------") for (i <- arr) { println(i) } println("最新的長度=" + arr.length) // 4 } }
1) ArrayBuffer是變長數組,相似Java的ArrayList
2) val arr = ArrayBuffer[Int]() 也是使用apply方法構建對象
3) def append(elems: A*) { appendAll(elems) } 接收的是可變參數
4) 每append一次,arr在底層會從新分配空間,進行擴容,arr的內存地址會發生變化,也就成爲新的ArrayBuffer
-說明
在開發中,咱們可能使用對定長數組和變長數組進行轉換
arr1.toBuffer //定長數組轉可變數組
arr2.toArray //可變數組轉定長數組
-注意事項
arr1.toBuffer 返回結果纔是一個可變數組,arr1自己沒有變化
arr2.toArray 返回結果纔是一個定長數組,arr2自己沒有變化
-案例演示
import scala.collection.mutable.ArrayBuffer object boke_demo01 { def main(args: Array[String]): Unit = { val arr2 = ArrayBuffer[Int]() // 追加值 arr2.append(1, 2, 3) println(arr2) //說明 //1. arr2.toArray 調用 arr2的方法 toArray //2. 將 ArrayBuffer ---> Array //3. arr2自己沒有任何變化 val newArr = arr2.toArray println(newArr) //說明 //1. newArr.toBuffer 是把 Array->ArrayBuffer //2. 底層的實現 /* override def toBuffer[A1 >: A]: mutable.Buffer[A1] = { val result = new mutable.ArrayBuffer[A1](size) copyToBuffer(result) result } */ //3. newArr自己沒變化 val newArr2 = newArr.toBuffer newArr2.append(123) println(newArr2) } }
-說明
//定義
val arr = Array.ofDim[Double](3,4)
//說明:二維數組中有三個一維數組,每一個一維數組中有四個元素
//賦值
aar(1)(1) = 9.6
-案例演示
object boke_demo01 { def main(args: Array[String]): Unit = { //建立 val arr = Array.ofDim[Int](3, 4) //遍歷 for (item <- arr) { //取出二維數組的各個元素(一維數組) for (item2 <- item) { // 元素(一維數組) 遍歷 print(item2 + "\t") } println() } //指定取出 println(arr(1)(1)) // 0 //修改值 arr(1)(1) = 9 //遍歷 println("=====================") for (item <- arr) { //取出二維數組的各個元素(一維數組) for (item2 <- item) { // 元素(一維數組) 遍歷 print(item2 + "\t") } println() } //使用傳統的下標的方式來進行遍歷 println("===================") for (i <- 0 to arr.length - 1) { //先對 for (j <- 0 to arr(i).length - 1) { printf("arr[%d][%d]=%d\t", i, j, arr(i)(j)) } println() } } }
在開發中,有時須要咱們將Scala數組轉成Java數組
import scala.collection.mutable.ArrayBuffer object boke_demo01 { def main(args: Array[String]): Unit = { // Scala集合和Java集合互相轉換 val arr = ArrayBuffer("1", "2", "3") /* implicit def bufferAsJavaList[A](b : scala.collection.mutable.Buffer[A]) : java.util.List[A] = { /* compiled code */ } */ import scala.collection.JavaConversions.bufferAsJavaList //對象 ProcessBuilder , 由於 這裏使用到上面的 bufferAsJavaList val javaArr = new ProcessBuilder(arr) //爲何能夠這樣使用? // 這裏arrList 就是java中的List val arrList = javaArr.command() println(arrList) //輸出 [1, 2, 3] } }
-案例演示
//java的List 轉成 scala的 ArrayBuffer //說明 //1. asScalaBuffer 是一個隱式函數 /* implicit def asScalaBuffer[A](l : java.util.List[A]) : scala.collection.mutable.Buffer[A] = { /* compiled code */ } */ import scala.collection.JavaConversions.asScalaBuffer import scala.collection.mutable // java.util.List ==> Buffer val scalaArr: mutable.Buffer[String] = arrList scalaArr.append("jack") scalaArr.append("tom") scalaArr.remove(0) println(scalaArr) // (2,3,jack,tom)
元組也是能夠理解爲一個容器,能夠存放各類相同或者不一樣類型的數據。說得簡單點,就是將多個無關的數據封裝爲一個總體,稱爲元組。特色靈活,對數據沒有過多的約束。注意:元組中最多隻能有22個元素
-案例演示
object boke_demo01 { def main(args: Array[String]): Unit = { //建立 //說明 1. tuple 就是一個 Tuple 類型是 Tuple5 //簡單說明: 爲了高效的操做元組 , 編譯器根據元素的個數不一樣,對應不一樣的元組類型 // 分別 Tuple1----Tuple22 val tuple = (1, 2, 3, "hello", 4) println(tuple) } }
-對案例演示的說明
1) tuple的類型是Tuple5類,是Scala特有的類型
2) tuple的類型取決於tuple後面有多少個元素,有對應關係,好比:4個元素 -> Tuple4
3) 看一個Tuple5類的定義
final case class Tuple5[+T1, +T2, +T3, +T4, +T5](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5) extends Product5[T1, T2, T3, T4, T5] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + "," + _5 + ")" }
4) 元組中最多隻能有22個元素,即Tuple1 -> Tuple22
訪問元組中的數據,能夠採用順序號(_順序號),也能夠經過索引(productElement)訪問
object boke_demo01 { def main(args: Array[String]): Unit = { //訪問元組 val t1 = (1, "a", "b", true, 2) println(t1._1) // 1 //訪問元組的第一個元素 ,從 1 開始 println(t1.productElement(0)) // 1 // 訪問元組的第一個元素,從 0 開始 } }
Tuple是一個總體,遍歷須要調其迭代器
object boke_demo01 { def main(args: Array[String]): Unit = { val t1 = (1, "a", "b", true, 2) //遍歷元組, 元組的遍歷須要使用到迭代器 for (item <- t1.productIterator) { println("item=" + item) } } }
Scala中的List和Java List不同,在Java中List是一個接口,真正存放數據的是ArrayList,而Scala的List能夠直接存放數據,就是一個object,默認狀況下Scala的List是不可變的,List屬於序列Seq
val List = scala.collection.immutable.List
object List extends SeqFactory[List]
object boke_demo01 { def main(args: Array[String]): Unit = { //說明 //1. 在默認狀況下 List 是scala.collection.immutable.List,即不可變 //2. 在scala中,List就是不可變的,如須要使用可變的List,則使用ListBuffer //3. List 在 package object scala 作了 val List = scala.collection.immutable.List //4. val Nil = scala.collection.immutable.Nil // List() val list01 = List(1, 2, 3, "Hello") //建立時,直接分配元素 println(list01) val list02 = Nil //空集合 println(list02) } }
1) List默認爲不可變的集合
2) List在Scala包對象聲明的,所以不須要引入其它包也可使用
val List = scala.collection.immutable.List
3) List中能夠聽任何數據類型,好比:arr1的類型爲List[Any]
4) 若是但願獲得一個空列表,可使用Nil對象,在Scala包對象聲明的,所以不須要引入其它包也可使用
val Nil = scala.collection.immutable.Nil
//訪問 List 的元素 val value1 = list01(1) // 1 是索引,表示取出第 2 個元素 println("value1=" + value1) // 2
向列表中增長元素,會返回新的列表/集合對象。注意:Scala中List元素的追加形式很是獨特,和Java不同
-案例演示
-案例演示
println("-------------list 追加元素後的效果-----------------") //經過 :+ 和 +: 給 list 追加元素(自己的集合並無變化) var list1 = List(1, 2, 3, "abc") // :+運算符表示在列表的最後增長數據 val list2 = list1 :+ 4 // (1,2,3,"abc", 4) println(list1) //list1 沒有變化 (1, 2, 3, "abc"),說明 list1 仍是不可變 println(list2) //新的列表結果是 [1, 2, 3, "abc", 4] val list3 = 10 +: list1 // (10,1, 2, 3, "abc") println("list3=" + list3)
-說明
1) 符號::表示向集合中 新建集合添加元素
2) 運算時,集合對象必定要放置在最右邊
3) 運算規則,從右向左
4) ::: 運算符是將集合中的每個元素加入到集合中去
-案例演示
//:: 符號的使用 val list4 = List(1, 2, 3, "abc") //說明 val list5 = 4 :: 5 :: 6 :: list4 :: Nil 步驟 //1. List() //2. List(List(1, 2, 3, "abc")) //3. List(6,List(1, 2, 3, "abc")) //4. List(5,6,List(1, 2, 3, "abc")) //5. List(4,5,6,List(1, 2, 3, "abc")) val list5 = 4 :: 5 :: 6 :: list4 :: Nil println("list5=" + list5) //說明 val list6 = 4 :: 5 :: 6 :: list4 ::: Nil 步驟 //1. List() //2. List(1, 2, 3, "abc") //3. List(6,1, 2, 3, "abc") //4. List(5,6,1, 2, 3, "abc") //5. List(4,5,6,1, 2, 3, "abc") val list6 = 4 :: 5 :: 6 :: list4 ::: Nil println("list6=" + list6)
ListBuffer是可變的list集合,能夠添加,刪除元素,ListBuffer屬於序列
//追一下繼承關係便可
Seq var listBuffer = ListBuffer(1,2)
import scala.collection.mutable.ListBuffer object boke_demo01 { def main(args: Array[String]): Unit = { //建立ListBuffer val lst0 = ListBuffer[Int](1, 2, 3) //如何訪問 println("lst0(2)=" + lst0(2)) // 輸出 lst0(2)= 3 for (item <- lst0) { // 遍歷,是有序 println("item=" + item) } //動態的增長元素,lst1就會變化, 增長一個一個的元素 val lst1 = new ListBuffer[Int] //空的ListBuffer lst1 += 4 // lst1 (4) lst1.append(5) // list1(4,5) // lst0 ++= lst1 // lst0 (1, 2, 3,4,5) println("lst0=" + lst0) val lst2 = lst0 ++ lst1 // lst2(1, 2, 3,4,5,4,5) println("lst2=" + lst2) val lst3 = lst0 :+ 5 // lst0 不變 lst3(1, 2, 3,4,5,5) println("lst3=" + lst3) println("=====刪除=======") println("lst1=" + lst1) lst1.remove(1) // 表示將下標爲1的元素刪除 for (item <- lst1) { println("item=" + item) //4 } } }
1) 隊列是一個有序列表,在底層能夠用數組或是鏈表來實現
2) 其輸入和輸出要遵循先入先出的原則。即:現存入隊列的數據,要先取出。後存入的要後取
3) 在Scala中,由設計者直接給咱們提供隊列類型Queue使用
4) 在Scala中,有scala.collection.mutable.Queue 和 scala.collection.immutable.Queue,通常來講,在開發中一般使用可變集合中的隊列
import scala.collection.mutable object boke_demo01 { def main(args: Array[String]): Unit = { //建立隊列 val q1 = new mutable.Queue[Int] println(q1) } }
import scala.collection.mutable object boke_demo01 { def main(args: Array[String]): Unit = { //建立隊列 val q1 = new mutable.Queue[Int] //給隊列增長元素 q1 += 9 // (9) println("q1=" + q1) // (9) q1 ++= List(4,5,7) // 默認值直接加在隊列後面 println("q1=" + q1) //(9,4,5,7) //q1 += List(10,0) // 表示將 List(10,0) 做爲一個元素加入到隊列中 } }
在隊列中,嚴格地遵照,入隊列的數據,放在隊尾,出隊列的數據是從隊列頭部取出
//dequeue 從隊列的頭部取出元素 q1 自己會變 val queueElement = q1.dequeue() println("queueElement=" + queueElement + "q1="+q1) //enQueue 入隊列,默認是從隊列的尾部加入. q1.enqueue(96,101,201,666) println("q1=" + q1) // Queue(4, 5, 7, 96,101,201,666)
//隊列 Queue-返回隊列的元素 //1. 獲取隊列的第一個元素 println(q1.head) // 4, 對 q1 沒有任何影響 //2. 獲取隊列的最後一個元素 println(q1.last) // 666, 對 q1 沒有任何影響 //3. 取出隊尾的數據 ,即:返回除了第一個之外剩餘的元素,能夠級聯使用 println(q1.tail) // (5, 7, 96,101,201,666) println(q1.tail.tail.tail.tail) // (101,201,666)
HashMap是一個散列表(數組+鏈表),它存儲的內容是鍵值對(key-value)映射,Java中的HashMap是無序的,key不能重複
import java.util.HashMap; public class JavaHashMap { public static void main(String[] args) { HashMap<String,Integer> hm = new HashMap(); hm.put("no1", 100); hm.put("no2", 200); hm.put("no3", 300); hm.put("no4", 400); hm.put("no1", 500); //更新 System.out.println(hm);//無序的 System.out.println(hm.get("no2")); } }
1) Scala中的Map和Java相似,也是一個散列表,它存儲的內容也是鍵值對(key-value)映射,Scala中不可變的Map是有序的,可變的Map是無序的
2) Scala中,有可變Map(scala.collection.mutable.Map)和不可變Map(scala.collection.immutable.Map)
Scala中的不可變Map是有序的,構建Map中的元素底層是Tuple2類型
案例演示
object boke_demo01 { def main(args: Array[String]): Unit = { //方式1-構造不可變映射 //1.默認Map是 immutable.Map //2.key-value 類型支持Any //3.在Map的底層,每對key-value是Tuple2 //4.從輸出的結果看到,輸出順序和聲明順序一致 val map1 = Map("Alice" -> 19, "Tom" -> 20, "Jack" -> 21) println(map1) } }
//方式2-構造可變映射 //1.從輸出的結果看到,可變的map輸出順序和聲明順序不一致 val map2 = mutable.Map("Alice" -> 19, "Tom" -> 20, "Jack" -> 21) println(map2)
val map3 = new scala.collection.mutable.HashMap[String, Int] println(map3)
-說明
即建立包含鍵值對的二元組,和第一種方式等價,只是形式上不一樣而已
對偶元組就是隻含有兩個數據的元組
-案例演示
//方式 4-對偶元組 val map4 = mutable.Map(("Alice" , 19), ("Tom" , 20), ("Jack" , 21)) println("map4=" + map4)
val value1 = map2("Alice") println(value1)
-說明
1) 若是key存在,則返回對應的值
2) 若是key不存在,則拋出異常[java.util.NoSuchElementException]
3) 在Java中,若是key不存在則返回null
4) 案例演示
//方式 1-使用 map(key) println(map4("Alice")) // 19 // 拋出異常(java.util.NoSuchElementException: key not found:) //println(map4("Alice~"))
// 返回 Boolean // 1.若是 key 存在,則返回 true // 2.若是 key 不存在,則返回 false map4.contains("T")
-說明
使用contains先判斷再取值,能夠防止異常,並加入相應的處理邏輯
-案例演示
//方式 2-使用 contains 方法檢查是否存在 key if (map4.contains("Alice")) { println("key 存在,值=" + map4("Alice")) } else { println("key 不存在:)") }
經過 映射.get(鍵) 這樣的調用返回一個Option對象,要麼是Some,要麼是None
-說明
1) map.get 方法會將數據進行包裝
2) 若是map.get(key) 若是key存在,返回some,若是key不存在,則返回None
3) 若是 map.get(key).get 若是key存在,則返回key對應的值,不然,拋出異常java.util.NoSuchElementException: None.get
-案例演示
//方式 3-使用 map.get(key).get 取值 //1. 若是 key 存在 map.get(key) 就會返回 Some(值) ,而後 Some(值).get 就能夠取出 //2. 若是 key 不存在 map.get(key) 就會返回 None println(map4.get("Alice").get) //println(map4.get("Alice~").get) // 拋出異常
-getOrElse方法:def getOrElse[V1 >: V](key: K, default :=> V1)
-說明
1) 若是key存在,返回key對應的值
2) 若是key不存在,返回默認值。在Java中底層有不少相似的操做
3) 案例演示
//方式 4-使用 map4.getOrElse()取值 println(map4.getOrElse("Alice~~~","默認的值:愛麗絲"))
1) 若是咱們肯定map有這個key,則應當使用map(key),速度快
2) 若是咱們不肯定map是否有這個key,並且有不一樣的業務邏輯,使用map.contains(),先判斷再加入邏輯
3) 若是隻是簡單的但願獲得一個值,使用map.getOrElse("ip","127.0.0.1")
-案例演示
val map5 = mutable.Map( ("Alice", 19), ("Tom", "20"), ("Jack", 23) ) map5("Alice") = 20 //更新 println("map5=" + map5)
-小結
1) map是可變的,才能修改,不然報錯
2) 若是key存在:則修改對應的值,key不存在,等價於添加一個key-value
-方式1-增長單個元素
val map5 = mutable.Map( ("Alice", 19), ("Tom", "20"), ("Jack", 23) ) map5 += ("史瑞克" -> 27) //增長 println("map5=" + map5)
-方式2-增長多個元素
val map5 = mutable.Map( ("Alice", 19), ("Tom", "20"), ("Jack", 23) ) map5 += ("史瑞克" -> 27, "滅霸" -> 100) println("map5=" + map5)
-說明:當增長一個key-value,若是key存在就是更新,若是不存在就是添加
-案例演示
val map5 = mutable.Map( ("Alice", 19), ("Tom", "20"), ("Jack", 23) ) map5 += ("史瑞克" -> 27, "滅霸" -> 100) map5 -= ("Alice","Tom","Ja") println("map5=" + map5)
-說明
1) 「Alice」,「Tom」就是要刪除的key,能夠寫多個
2) 若是key存在,就刪除,若是key不存在,也不會報錯
對map的元素(元組Tuple2對象)進行遍歷的方式不少,具體以下:
import scala.collection.mutable object boke_demo01 { def main(args: Array[String]): Unit = { val map1 = mutable.Map( ("A", 1), ("B", 2), ("C", 3) ) for ((k, v) <- map1) println(k + " is mapped to " + v) for (v <- map1.keys) println(v) for (v <- map1.values) println(v) for (v <- map1) println(v) } }
-說明
1) 每遍歷一次,返回的元素是Tuple2
2) 取出的時候,能夠按照元組的方式來取
-案例演示
import scala.collection.mutable object boke_demo01 { def main(args: Array[String]): Unit = { //map 的遍歷 val map6 = mutable.Map(("A", 1), ("B", 2), ("C", 3)) println("----(k, v) <- map6--------") for ((k, v) <- map6) println(k + " is mapped to " + v) println("----v <- map6.keys--------") for (v <- map6.keys) println(v) println("----v <- map6.values--------") for (v <- map6.values) println(v) //這樣取出方式 v 類型是 Tuple2 println("----v <- map6--------") for (v <- map6) println(v + " key =" + v._1 + " val=" + v._2) } }
集是不重複元素的結合,集不保留順序,默認是以哈希集實現
Java中,HashSet是實現Set<E>接口的一個實體類,數據是以哈希表的形式存放的,裏面不能包含重複數據。Set接口是一種不包含重複元素的collection,HashSet中的數據也是沒有順序的
import java.util.HashSet; public class JavaHashSet { public static void main(String[] args) { //java中的Set的元素 沒有順序,不能重複 HashSet hs = new HashSet<String>(); hs.add("Jack"); hs.add("Tom"); hs.add("Alice"); hs.add("史瑞克"); System.out.println(hs); } }
默認狀況下,Scala使用的是不可變集合,若是想要使用可變集合,須要引用scala.collection.mutable.Set包
import scala.collection.mutable object boke_demo01 { def main(args: Array[String]): Unit = { val set = Set(1, 2, 3) //不可變 println(set) val set2 = mutable.Set(1, 2, "hello") //能夠變 println("set2" + set2) } }
mutableSet.add(4) //方式 1 mutableSet += 6 //方式 2 mutableSet.+=(5) //方式 3
-說明:若是添加的對象已經存在,則不會重複添加,也不會報錯
val set3 = mutable.Set(1,2,3,"abc") set3 -= 2 // 操做符形式 set3.remove("abc") // 方法的形式,scala 的 Set 能夠直接刪除值 println(set3) //說明:若是刪除的對象不存在,則不生效,也不會報錯
val set4 = mutable.Set(1, 2, 3, "abc") for (x <- set4) { println(x) }