arrays :+ 5尾部 頭部5 +: arrays
TODO 聲明不可變數組，不能刪; 默認情況下，scala中集合的聲明全都是不可變的
val arrays: Array[Int] = Array(1, 2, 3, 4) //增加 不可變使用伴生對象添加數 val newArrays1: Array[Int] = arrays :+5 //1,2,3,4,5 // 增加數據到集合的尾部，產生新的集合 val newArrays2: Array[Int] = 6+:arrays //6,1,2,3,4 // 增加數據到集合的頭部，產生新的集合 //println(newArrays.length) //println(arrays == newArrays1) //false ； ==是否是同一塊內存 //println(arrays.length) // 修改數據:數組(索引) = 修改的值； 修改，不變的是內存地址，里邊內容可以變 arrays(1)=1 println(arrays.mkString(",")) //1,1,3,4 // 獲取數組中的數據 //println(arrays(3)) //循環遍歷 for (elem <- arrays) { println(elem) } //println(arrays.mkString(",")) // 生成字符串 // 將不可變數組變成可變數組 arrays.toBuffer
TODO 聲明可變數組 可變數組的數據操作其實都是對同一個數組做操作
arrayBuffer+=5,跟之前數組是同一個內存地址，即一個數組
var arrayBuffer: ArrayBuffer[Int] = ArrayBuffer(1,2,3,4,5) // 增加數據 var newArrayBuffer: ArrayBuffer[Int] = arrayBuffer:+6 var newArrayBuffer1: ArrayBuffer[Int] = 7+:arrayBuffer println(arrayBuffer == newArrayBuffer) //false +=6就是true // 修改數據 arrayBuffer.insert(2, 9) arrayBuffer.update(1, 3) arrayBuffer(0) = 6 println(arrayBuffer.mkString(",")) //1,2,9,3,4,5 //println(newArrayBuffer1.mkString(",")) //7,1,2,3,4,5 // 刪除數據 //arrayBuffer.remove(2) //按索引刪 // 如果刪除的個數超過數組的容量，會發生錯誤 //arrayBuffer.remove(2, 2) //刪索引后的后兩位 //arrayBuffer-=5 //arrayBuffer-5它是針對新集合的，arrayBuffer-=5是操作完之后重新賦值給arrayBuffer，刪除的是元素 //查詢 println(arrayBuffer(2)) for (elem <- arrayBuffer) { print(elem) } def test(i: Int): Unit = { print(i) } // foreach方法會傳遞一個函數作為參數; foreach方法會將集合的每一個元素都調用這個函數 arrayBuffer.foreach(test) //arrayBuffer.foreach((i: Int) => {print(i)}) //arrayBuffer.foreach(i => {print(i)}) //arrayBuffer.foreach({print(_)}) //arrayBuffer.foreach(print(_)) arrayBuffer.foreach(print) //只有一個參數時(_)也可以省略 // 將可變數組變成不可變數組 arrayBuffer.toArray
list -- seq序列
TODO immutable : 不可變// java:list ==> scala:Seq
:緊挨着集合表增加
val list: List[Int] = List(1,2,3,4) // 增加數據 list:+5 val newList: List[Int] = 5+:list //5,1,2,3,4 // 特殊的List集合對象， Nil => List() val nil: List[Nothing] = List() val nils: List[Int] = nil:+3 //3 // 給空集合增加數據，不是空集合也可以, 元素可以重復 // 雙冒號的運算規則是從右向左 val list1: List[Int] = 1:: 2:: 3:: 4:: nils //1,2,3,4,3 println(list1.mkString(",")) val list2: List[Int] = 5:: list //5,1,2,3,4 加在頭部 println(list2.mkString(",")) val list3: List[Any] = 5:: list:: nils //5,List(1, 2, 3, 4),3 list作為整體 val list3: List[Any] = 5:: list::: nils //5,1,2,3,4,3 整體拆開--扁平化 println(list3.mkString(","))
// 修改數據:list無法通過索引的方式對象數據進行修改 //list(1) = 7 // 可以通過updated方法修改數據，但是會產生新集合 val newUpdateList: List[Int] = list.updated(1, 8) //1,8,3,4 println(newUpdateList.mkString(",")) // 刪除數據,產生新的集合 val dropList: List[Int] = list.drop(2) //刪除前兩個 println("刪除="+ dropList.mkString(",")) //刪除=3,4 // 查詢數據 println(list(1)) //2 // 獲取指定個數的數據，產生新的集合 println(list.take(3)) //List(1, 2, 3) for (elem <- list) {} list.foreach(println)
mutable ： 可變，易變 ListBuffer
val listBuffer: ListBuffer[Int] = ListBuffer(1,2,3,4) //listBuffer.insert(1, 6) //listBuffer.remove(1) //listBuffer.updated(1, 9) val listBuffer1: ListBuffer[Int] = listBuffer+=5 //內存指向同一塊 val listBuffer2: ListBuffer[Int] = listBuffer-=4 println(listBuffer.mkString(",")) //1,2,3,5 println(listBuffer1.mkString(","))//1,2,3,5 println(listBuffer2.mkString(","))//1,2,3,5 listBuffer(1)=9 println(listBuffer.mkString(",")) println(listBuffer.to) //Vector(1, 9, 3, 5) println(listBuffer(0)) //1 for (elem <- listBuffer) {} //listBuffer.foreach(println)
隊列特殊集合：mutable.Queue 隊列, 必須為可變的 先進先出
// TODO 隊列, 必須為可變的 先進先出 val mqueue: mutable.Queue[Int] = new mutable.Queue // 增加數據 /* mqueue += 1 mqueue += 2*/ mqueue.enqueue(1,2,3,4,5,6) println("Before=" + mqueue) //Before=Queue(1, 2, 3, 4, 5, 6) println(mqueue.dequeue()) //1 println(mqueue.dequeue()) //2 按增加數據去取 println("after = " + mqueue) //after = Queue(3, 4, 5, 6)
Set:immutable 無序 不可變-- java:set ==> scala:Set
val set: Set[Int] = Set(1,2,3,4) // 增加數據 //set:+1 //報錯 println(set + 5) //Set(5, 1, 2, 3, 4) 形成新的集合 // 刪除數據 println(set.drop(2)) //Set(3, 4)，刪除前兩個 //修改，沒有update； 無序，沒有索引; println(set - 2) //Set(1, 3, 4) // 獲取數據 println(set(1)) //set集合中有這個元素就返回true，沒有返回false println(set) //Set(1, 2, 3, 4) println(set.mkString(",")) //1,2,3,4 for (elem <- set) {} //set.foreach(println)
mutable.set可變
val mset = mutable.Set(1,2,3,4) // 加號運算一定會產生新的集合 mset+=5 //產生新的集合又賦值給它 mset+6 ///產生新的集合 println(mset.add(7)) //true 添加元素 val list = List(11,22,33,44) mset++=(list) //添加集合 println(mset.mkString(",")) //33,1,5,2,3,7,4,22,11,44 // 修改數據,等同於增加或刪除。 //mset.update(9, false) ////true就是添加元素到mset集合; false是不添加 // 刪除數據 //mset.remove(1) //刪除元素1 //mset-=44 //刪除元素44 // 查詢數據 println(mset.head) //33 println(mset.tail) // tail ：集合中除了頭以外的元素 Set(1, 5, 2, 3, 7, 4, 22, 11, 44) println(mset.last) //最后一個元素 println(mset.init) // init : 集合中除了最后一個以外的元素 println(mset) // java:map ==> scala:Map println(mset.mkString(","))
Map
scala中的map也是存儲k v對 ，轉換結構，把a 轉換為另外一個結構的 a
不可變的Map集合 沒有專門類，就是包
val map: Map[String, Int] = Map("a" -> 1, "b" -> 2)
println(map + ("c" -> 3)) //Map(a -> 1, b -> 2, c -> 3) 產生新集合
println(map.updated("b", 5)) //Map(a -> 1, b -> 5)
println(map - "b") //Map(a -> 1) 新的集合
// Option : Some就是有值或者 None是無值, java中可能空指針;scala中用Option 為了代替空指針判斷
println(map.get("a"))//Some(1)
println(map.get("k")) //None
println(map.get("k").getOrElse(10)) //10如果為空，則取默認值10
println(map.keys) //Set(a, b)
println(map.values)//MapLike(1, 2)
println(map) //Map(a -> 1, b -> 2)
mutable.Map可變
// TODO 可變的Map集合 val mMap = mutable.Map("a" -> 1, "b" -> 2) mMap += ("c" -> 3, "d" -> 4, "E"->5) //=是把原來的值給覆蓋掉 mMap -= ("b", "E") mMap.update("a", 8) //, // mmap.get("").getOrElse(0) println(mMap) //Map(d -> 4, a -> 8, c -> 3)
Tuple元組，22個元素；函數中有22個參數數據
(, , , )
tuple._1 ._2
// TODO Tuple 元組：將多個無關聯的數據當成一個整體來使用。 // 聲明元組 : 使用小括號 val tuple= ("abc", 123, "c") // 使用特殊方式(下划線+順序號)訪問元組數據 println(tuple._2) //123 val iterator: Iterator[Any] = tuple.productIterator //迭代器 while (iterator.hasNext){ print(iterator.next())// abc 123 c } // 如果元組中的元素只有兩個，我們稱之為“對偶”，Map集合中的K，V其實就是“對偶” val map1 = Map(("a", 1), ("b", 2)) map1.foreach(println) //(a,1) (b,2) map1.foreach(t=>{println(t._1 + "," + t._2)}) //a,1 b,2 // 模式匹配 map1.foreach{ case(k, v)=>{ println(k + "," + v) //a,1 b,2 } }
Java集合和Scala集合的互相轉換
scala的集合轉換為java的集合
// Scala集合和Java集合互相轉換 val arr = ArrayBuffer("1", "2", "3") import scala.collection.JavaConversions.bufferAsJavaList val javaArr = new ProcessBuilder(arr) val arrList = javaArr.command() println(arrList) //[1, 2, 3]
Java的List轉Scala數組(mutable.Buffer)
隱式轉換（即自動轉換，二次編譯，第一次編譯沒通過就嘗試在指定范圍內看看類參數等是否可以再次編譯），隱藏的把它轉換為想要的類型；
// Scala集合和Java集合互相轉換 //Scala ==> Java val arr = ArrayBuffer("1", "2", "3") import scala.collection.JavaConversions.bufferAsJavaList val javaArr = new ProcessBuilder(arr) val arrList = javaArr.command() println(arrList) //[1, 2, 3] //Java ==> Scala import scala.collection.JavaConversions.asScalaBuffer import scala.collection.mutable // java.util.List ==> Buffer //val scalaArr: mutable.Buffer[String] = arrList val javaList: util.List[String] = new util.ArrayList[String]() //java中的 val scalaArr: mutable.Buffer[String] = javaList //scala中的 ;如果沒有上邊的import隱式轉換，就會報錯，兩個不同的類型無法轉換 scalaArr.append("jack") //ArrayBuffer(1, 2, 3, jack) Buffer(jack) println(scalaArr)