spark笔记之数组、映射、元组、集合

龍子

　　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  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 50
lisi0 -> 20
wangwu -> 30
//遍历map 方法二：模式匹配
scala> for((x,y)  50
lisi0 -> 20
wangwu -> 30
//遍历map 方法三：通过foreach
scala>  user.foreach{case (x,y) => println(x+" -> "+y)}
lisi -> 50
lisi0 -> 20
wangwu -> 30