spark筆記之數組、映射、元組、集合
（1）定長數組定義格式：
val arr=new ArrayT
（2）變長數組定義格式：
val arr = ArrayBuffer[T]()
註意需要導包：import scala.collection.mutable.ArrayBuffer
package cn.itcast.scala import scala.collection.mutable.ArrayBuffer object ArrayDemo { def main(args: Array[String]) { //初始化一個長度為8的定長數組，其所有元素均為0 val arr1 = new Array[Int](8) //直接打印定長數組，內容為數組的hashcode值 println(arr1) //將數組轉換成數組緩沖，就可以看到原數組中的內容了 //toBuffer會將數組轉換長數組緩沖 println(arr1.toBuffer) //註意：如果new，相當於調用了數組的apply方法，直接為數組賦值 //初始化一個長度為1的定長數組 val arr2 = Array[Int](10) println(arr2.toBuffer) //定義一個長度為3的定長數組 val arr3 = Array("hadoop", "storm", "spark") //使用()來訪問元素 println(arr3(2)) //變長數組（數組緩沖） //如果想使用數組緩沖，需要導入import scala.collection.mutable.ArrayBuffer包 val ab = ArrayBuffer[Int]() //向數組緩沖的尾部追加一個元素 //+=尾部追加元素 ab += 1 //追加多個元素 ab += (2, 3, 4, 5) //追加一個數組++= ab ++= Array(6, 7) //追加一個數組緩沖 ab ++= ArrayBuffer(8,9) //打印數組緩沖ab //在數組某個位置插入元素用insert，從某下標插入 ab.insert(0, -1, 0) //刪除數組某個位置的元素用remove 按照下標刪除 ab.remove(0) println(ab) } }
1.1.2. 遍歷數組
1.增強for循環
2.好用的until會生成腳標，0 until 10 包含0不包含10
package cn.itcast.scala
object ForArrayDemo {
def main(args: Array[String]) {
//初始化一個數組
val arr = Array(1,2,3,4,5,6,7,8)
//增強for循環
for(i <- arr)
println(i)
//好用的until會生成一個Range //reverse是將前面生成的Range反轉 for(i <- (0 until arr.length).reverse) println(arr(i))
}
}``
1.1.3. 數組轉換
yield關鍵字將原始的數組進行轉換會產生一個新的數組，原始的數組不變
package cn.itcast.scala object ArrayYieldDemo { def main(args: Array[String]) { //定義一個數組 val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9) //將偶數取出乘以10後再生成一個新的數組 val res = for (e <- arr if e % 2 == 0) yield e * 10 println(res.toBuffer) //更高級的寫法,用著更爽 //filter是過濾，接收一個返回值為boolean的函數 //map相當於將數組中的每一個元素取出來，應用傳進去的函數 val r = arr.filter(_ % 2 == 0).map(_ * 10) println(r.toBuffer) } }
1.1.4. 數組常用算法
在Scala中，數組上的某些方法對數組進行相應的操作非常方便！
1.2. 映射
在Scala中，把哈希表這種數據結構叫做映射。
1.2.1. 構建映射
（1）構建映射格式
1、val map=Map(鍵 -> 值，鍵 -> 值....)
2、利用元組構建 val map=Map((鍵，值),(鍵，值),(鍵，值)....)
1.2.2. 獲取和修改映射中的值
（1）獲取映射中的值：
值=map(鍵)
好用的getOrElse
註意：在Scala中，有兩種Map，一個是immutable包下的Map，該Map中的內容不可變；另一個是mutable包下的Map，該Map中的內容可變
例子：
註意：通常我們在創建一個集合是會用val這個關鍵字修飾一個變量（相當於java中的final），那麽就意味著該變量的引用不可變，該引用中的內容是不是可變，取決於這個引用指向的集合的類型
1.3. 元組
映射是K/V對偶的集合，對偶是元組的最簡單形式，元組可以裝著多個不同類型的值。
1.3.1. 創建元組
（1）元組是不同類型的值的聚集；對偶是最簡單的元組。
（2）元組表示通過將不同的值用小括號括起來，即表示元組。
創建元組格式：
val tuple=(元素,元素...)
1.3.2. 獲取元組中的值
(1) 獲取元組中的值格式：
使用下劃線加腳標 ，例如 t._1 t._2 t._3
註意：元組中的元素腳標是從1開始的
1.3.3. 將對偶的集合轉換成映射
將對偶的集合轉換成映射：
調用其toMap 方法
1.3.4. 拉鏈操作
1.使用zip命令可以將多個值綁定在一起
註意：如果兩個數組的元素個數不一致，拉鏈操作後生成的數組的長度為較小的那個數組的元素個數
2.如果其中一個元素的個數比較少，可以使用zipAll用默認的元素填充
1.4. 集合
Scala的集合有三大類：序列Seq、Set、映射Map，所有的集合都擴展自Iterable特質，在Scala中集合有可變（mutable）和不可變（immutable）兩種類型，immutable類型的集合初始化後就不能改變了（註意與val修飾的變量進行區別）。
1.4.1. List
(1)不可變的序列 import scala.collection.immutable._
在Scala中列表要麽為空（Nil表示空列表） 要麽是一個head元素加上一個tail列表。
9 :: List(5, 2) :: 操作符是將給定的頭和尾創建一個新的列表
註意：:: 操作符是右結合的，如9 :: 5 :: 2 :: Nil相當於 9 :: (5 :: (2 :: Nil))
list常用的操作符：
+: (elem: A): List[A] 在列表的頭部添加一個元素
:: (x: A): List[A] 在列表的頭部添加一個元素
:+ (elem: A): List[A] 在列表的尾部添加一個元素
++[B](that: GenTraversableOnce[B]): List[B] 從列表的尾部添加另外一個列表
::: (prefix: List[A]): List[A] 在列表的頭部添加另外一個列表
val left = List(1,2,3)
val right = List(4,5,6)
//以下操作等價
left ++ right // List(1,2,3,4,5,6)
right.:::(left) // List(1,2,3,4,5,6)
//以下操作等價
0 +: left //List(0,1,2,3)
left.+:(0) //List(0,1,2,3)
//以下操作等價
left :+ 4 //List(1,2,3,4)
left.:+(4) //List(1,2,3,4)
//以下操作等價
0 :: left //List(0,1,2,3)
left.::(0) //List(0,1,2,3)
例子:
package cn.itcast.collect
/**
* 不可變List集合操作
*/
object ImmutListDemo {
def main(args: Array[String]) {
//創建一個不可變的集合
val lst1 = List(1,2,3)
//補充：另一種定義list方法
val other_lst=2::Nil
//獲取集合的第一個元素
val first=lst1.head
//獲取集合中除第一個元素外的其他元素集合,
val tail=lst1.tail
//補充：其中如果 List 中只有一個元素，那麽它的 head 就是這個元素，它的 tail 就是 Nil；
println(other_lst.head+"----"+other_lst.tail)
//將0插入到lst1的前面生成一個新的List
val lst2 = 0 :: lst1
val lst3 = lst1.::(0)
val lst4 = 0 +: lst1
val lst5 = lst1.+:(0)
//將一個元素添加到lst1的後面產生一個新的集合
val lst6 = lst1 :+ 3
val lst0 = List(4,5,6)
//將2個list合並成一個新的List
val lst7 = lst1 ++ lst0
//將lst0插入到lst1前面生成一個新的集合
val lst8 = lst1 ++: lst0
//將lst0插入到lst1前面生成一個新的集合
val lst9 = lst1.:::(lst0)
println(other_lst)
println(lst1)
println(first)
println(tail)
println(lst2)
println(lst3)
println(lst4)
println(lst5)
println(lst6)
println(lst7)
println(lst8)
println(lst9)
}
}(2)可變的序列 import scala.collection.mutable._
ackage cn.itcast.collect
import scala.collection.mutable.ListBuffer
object MutListDemo extends App{
//構建一個可變列表，初始有3個元素1,2,3
val lst0 = ListBuffer[Int](1,2,3)
//創建一個空的可變列表
val lst1 = new ListBuffer[Int]
//向lst1中追加元素，註意：沒有生成新的集合
lst1 += 4
lst1.append(5)
//將lst1中的元素最近到lst0中， 註意：沒有生成新的集合
lst0 ++= lst1
//將lst0和lst1合並成一個新的ListBuffer 註意：生成了一個集合
val lst2= lst0 ++ lst1
//將元素追加到lst0的後面生成一個新的集合
val lst3 = lst0 :+ 5
//刪除元素,註意：沒有生成新的集合
val lst4 = ListBuffer[Int](1,2,3,4,5)
lst4 -= 5
//刪除一個集合列表,生成了一個新的集合
val lst5=lst4--List(1,2)
//把可變list 轉換成不可變的list 直接加上toList
val lst6=lst5.toList
//把可變list 轉變數組用toArray
val lst7=lst5.toArray
println(lst0)
println(lst1)
println(lst2)
println(lst3)
println(lst4)
println(lst5)
println(lst6)
println(lst7)
}1.4.2. Set
(1)不可變的Set import scala.collection.immutable._
Set代表一個沒有重復元素的集合；將重復元素加入Set是沒有用的，而且 Set 是不保證插入順序的，即 Set 中的元素是亂序的。
定義：val set=Set(元素,元素,.....)
//定義一個不可變的Set集合
scala> val set =Set(1,2,3,4,5,6,7)
set: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 4)
//元素個數
scala> set.size
res0: Int = 7
//取集合最小值
scala> set.min
res1: Int = 1
//取集合最大值
scala> set.max
res2: Int = 7
//將元素和set1合並生成一個新的set，原有set不變
scala> set + 8
res3: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 8, 4)
scala> val set1=Set(7,8,9)
set1: scala.collection.immutable.Set[Int] = Set(7, 8, 9)
//兩個集合的交集
scala> set & set1
res4: scala.collection.immutable.Set[Int] = Set(7)
//兩個集合的並集
scala> set ++ set1
res5: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 9, 2, 7, 3, 8, 4)
//在第一個set基礎上去掉第二個set中存在的元素
scala> set -- set1
res6: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)
//返回第一個不同於第二個set的元素集合
scala> set &~ set1
res7: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)
//計算符合條件的元素個數
scala> set.count(_ >5)
res8: Int = 2
/返回第一個不同於第二個的元素集合
scala> set.diff(set1)
res9: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)
/返回第一個不同於第二個的元素集合
scala> set1.diff(set)
res10: scala.collection.immutable.Set[Int] = Set(8, 9)
//取子set(2,5為元素位置, 從0開始，包含頭不包含尾)
scala> set.slice(2,5)
res11: scala.collection.immutable.Set[Int] = Set(6, 2, 7)
//叠代所有的子set，取指定的個數組合
scala> set1.subsets(2).foreach(x=>println(x))
Set(7, 8)
Set(7, 9)
Set(8, 9)(2)可變的Set import scala.collection.mutable._
//導入包
scala> import scala.collection.mutable
import scala.collection.mutable
//定義一個可變的Set
scala> val set1=new HashSet[Int]()
set1: scala.collection.mutable.HashSet[Int] = Set()
//添加元素
scala> set1 += 1
res1: set1.type = Set(1)
//添加元素 add等價於+=
scala> set1.add(2)
res2: Boolean = true
scala> set1
res3: scala.collection.mutable.HashSet[Int] = Set(1, 2)
//向集合中添加元素集合
scala> set1 ++=Set(1,4,5)
res5: set1.type = Set(1, 5, 2, 4)
//刪除一個元素
scala> set1 -=5
res6: set1.type = Set(1, 2, 4)
//刪除一個元素
scala> set1.remove(1)
res7: Boolean = true
scala> set1
res8: scala.collection.mutable.HashSet[Int] = Set(2, 4)1.4.3. Map
(1)不可變的Map import scala.collection.immutable._
定義Map集合
1.val map=Map(鍵 -> 值 , 鍵 -> 值...)
2.利用元組構建 val map=Map((鍵，值), (鍵，值) , (鍵，值)....)
展現形式：
val map = Map(“zhangsan”->30,”lisi”->40)
val map = Map((“zhangsan”,30),(“lisi”,40))
3.操作map集合
獲取值： 值=map(鍵)
原則：通過先獲取鍵，在獲取鍵對應值。
4.遍歷map集合
scala> val imap=Map("zhangsan" -> 20,"lisi" ->30)
imap: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 20, lisi -> 30)
//方法一：顯示所有的key
scala> imap.keys
res0: Iterable[String] = Set(zhangsan, lisi)
//方法二：顯示所有的key
scala> imap.keySet
res1: scala.collection.immutable.Set[String] = Set(zhangsan, lisi)
//通過key獲取value
scala> imap("lisi")
res2: Int = 30
//通過key獲取value 有key對應的值則返回，沒有就返回默認值0，
scala> imap.getOrElse("zhangsan",0)
res4: Int = 20
//沒有對應的key，返回默認0
scala> imap.getOrElse("zhangsan1",0)
res5: Int = 0
//由於是不可變map,故不能向其添加、刪除、修改鍵值對(2)可變的Map import scala.collection.mutable._
//導包
import scala.collection.mutable
//聲明一個可變集合
scala> val user =mutable.HashMap("zhangsan"->50,"lisi" -> 100)
user: scala.collection.mutable.HashMap[String,Int] = Map(lisi -> 100, zhangsan -> 50)
//添加鍵值對
scala> user +=("wangwu" -> 30)
res0: user.type = Map(lisi -> 100, zhangsan -> 50, wangwu -> 30)
//添加多個鍵值對
scala> user += ("zhangsan0" -> 30,"lisi0" -> 20)
res1: user.type = Map(zhangsan0 -> 30, lisi -> 100, zhangsan -> 50, lisi0 -> 20,wangwu -> 30)
//方法一：顯示所有的key
scala> user.keys
res2: Iterable[String] = Set(zhangsan0, lisi, zhangsan, lisi0, wangwu)
//方法二：顯示所有的key
scala> user.keySet
res3: scala.collection.Set[String] = Set(zhangsan0, lisi, zhangsan, lisi0, wangwu)
//通過key獲取value
scala> user("zhangsan")
res4: Int = 50
//通過key獲取value 有key對應的值則返回，沒有就返回默認值0，
scala> user.getOrElse("zhangsan",0)
res5: Int = 50
//沒有對應的key，返回默認0
scala> user.getOrElse("zhangsan1",0)
res6: Int = 0
//更新鍵值對
scala> user("zhangsan") = 55
scala> user("zhangsan")
res8: Int = 55
//更新多個鍵值對
scala> user += ("zhangsan" -> 60, "lisi" -> 50)
res9: user.type = Map(zhangsan0 -> 30, lisi -> 50, zhangsan -> 60, lisi0 -> 20,wangwu -> 30)
//刪除key
scala> user -=("zhangsan")
res14: user.type = Map(zhangsan0 -> 30, lisi -> 50, lisi0 -> 20, wangwu -> 30)
//刪除key
scala>user.remove("zhangsan0")
//遍歷map 方法一：通過key值
scala> for(x<- user.keys) println(x+" -> "+user(x))
lisi -> 50
lisi0 -> 20
wangwu -> 30
//遍歷map 方法二：模式匹配
scala> for((x,y) <- user) println(x+" -> "+y)
lisi -> 50
lisi0 -> 20
wangwu -> 30
//遍歷map 方法三：通過foreach
scala> user.foreach{case (x,y) => println(x+" -> "+y)}
lisi -> 50
lisi0 -> 20
wangwu -> 30spark筆記之數組、映射、元組、集合