1. 程式人生 > >spark筆記之數組、映射、元組、集合

spark筆記之數組、映射、元組、集合

轉變 mmu 寫法 構建 -o ipa 一個數 不包含 lec

1.1. 數組1.1.1. 定長數組和變長數組
(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 -> 30

spark筆記之數組、映射、元組、集合