scala的集合类型

一、集合类型

集合是⼀种用来存储各种对象和数据的容器。Scala 集合分为可变的和不可变的集合。

1. 不可变集合可以安全的并发访问。

2. 可变集合可以在适当的地⽅被更新或扩展。这意味着你可以修改，添加，移除⼀个集合的元素。

Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质，意味着 集合的基本特点是⽀持迭代遍历的。

scala集合两个主要的包：

# 不可变集合
 scala.collection.immutable (Scala默认采用不可变集合)
# 可变集合
 scala.collection.mutable

分类描述
Seq序列。元素以线性方式存储，集合中可以存放重复对象。
Set集（数据集，区别于集合）。集中的对象不按特定的方式排序，并且没有重复对象。
Map⼀种把键对象和值对象映射的集合，它的每⼀个元素都包含⼀对键对象和值对象。
对于可变与不可变集合，Seq、Set、Map又有不同的实现方式，下面两张图详细描述了其继承关系。

 

1.数组

任何数组都是可变集合

数组包括：Array（定长）和ArrayBuffer（变长）

# Array
- 定长数组，数组不可扩容 scala.Array
# ArrayBuffer
- 变长数组，数组可扩容 scala.collection.mutable.ArrayBuffer
val arr=Array(1,2,3) val arr1=new Array(100) scala> arr :+ 4 //+: res306:
Array[Int] = Array(1, 2, 3, 4) arr是定长数组，不能修改长度，这里是返回新的数组，原数组并没有被修改
# 什么时候用new

如果没有提供object的apply方法时，class必须用new.

定长数组

arr是定长数组，不能改变长度 

定⻓数组是不可变集合吗？ 不是。定长数组是可变集合的⼀种，内容可变，但是其长度不可变。

 # 扩展：为什么定长数组是可变集合？

 Array本身不属于scala集合成员，从前⾯类继承图中也可发现这⼀点，在可变集合图中IndexedSeq有⼀条虚线指向了Array，说明并不是直接继承关系。
 ⼀般将Array归为集合是因为Scala默认将Array隐式转换为WrappedArray，⽽WrappedArray实现了IndexedSeq特质。

 从这⼀点上来说，String与WrappedString也有异曲同⼯之妙，可以发现在不可变集合中，String与IndexedSeq也是虚线连接，也就是说在Scala中，String可以当集合处理。参考下⽂中的描述，请⾃⾏通过源码验证。

Array被隐式转换为WrappedArray（scala.collection.mutable.WrappedArray），间接拥有了集合的特征。
//Predef.scala 提示：所有scala⽂件默认导⼊Predef对象 implicit def genericWrapArray[T](xs:
Array[T]): WrappedArray[T] = if (xs eq null) null else WrappedArray.make(xs)
 

变长数组 ArrayBuffer

# ArrayBuffer的创建

1）直接创建

2）由Array转化
# 由arr转化 arr.toBuffer scala> arr.toBuffer res286:
scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3) scala>
arr.toBuffer+=4 res287: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1,
2, 3, 4) scala> res286 res289: scala.collection.mutable.Buffer[Int] =
ArrayBuffer(1, 2, 3) scala> res287 res290: scala.collection.mutable.Buffer[Int]
= ArrayBuffer(1, 2, 3, 4) # 直接创建 scala> import
scala.collection.mutable.ArrayBuffer import
scala.collection.mutable.ArrayBuffer scala> val arrBuff=ArrayBuffer(1, 2, 3)
arrBuff: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)
小结：ArrayBuffer是在原来的Buffer上修改.

+： 返回新的对象

+=  是在原对象上修改

Array(1,2,3,4,5).filter(_%2==0).map(_*2).foreach(println)

2 元组

Scala Tuple表示固定元素的组合，元组可以装着多个不同类型的值，是不同类型的值的聚集。Tuple是Scala中⾮常
重要的⼀种数据结构，后⾯会大量使用。其特点包括：

* 最多⽀持22个元素组合，分别对应类型Tuple1~Tuple22，相应也称为⼀元组（⼀般不用）、⼆元组、三元组...
* 元组可以容纳不同类型的元素
* 元组不可变
创建元组：使用小括号 () 将多个元素括起来，元素之间⽤逗号分隔，元素的类型和个数不超过22。

访问组元：使用 _1 ， _2 ， _3 等形式访问组元，注意下标从1开始。
scala> val stu=(101,"oak","male",24) stu: (Int, String, String, Int) =
(101,oak,male,24) scala> stu._1 res0: Int = 101 scala> stu._2 res1: String = oak
注意和同时定义多个变量的区别
scala> val (x,y,m,n)=(100,"jason","man",100) x: Int = 100 y: String = jason m:
String = man n: Int = 100
元组不能修改
scala> stu._3="xx" <console>:15: error: reassignment to val stu._3="xx"
因为元组不是集合，所以不能直接遍历，需要间接转换为集合进行遍历。
scala> for(i<-stu)println(i) <console>:17: error: value foreach is not a
member of (Int, String, String, Int) for(i<-stu)println(i) ^ scala>
for(i<-stu.productIterator)println(i) 100 jason man 100
Traversable（可以重复遍历） & TraversableOnce（只能遍历一次） 的区别

元组对应的类型为 Tuple1-Tuple22

为什么没有Tuple0？ （）

特别地：Tuple2 常用于表示对偶，可以表示Map中的⼀个元素，Map是K/V对偶的集合，对偶是元组的最简单形式。
scala> (1,("jason","man")) res349: (Int, (String, String)) = (1,(jason,man))
scala> (1,Array("jason","man")) res350: (Int, Array[String]) = (1,Array(jason,
man)) scala> val tp2=Tuple2(1,2) tp2: (Int, Int) = (1,2) scala> val
tp2="a"->100 tp2: (String, Int) = (a,100)
样例类的创建
scala> case class student(id: Int,name: String) defined class student
拉链操作：

 元组需要转换为集合进行拉链操作
scala> val tp3=(1,2,3) tp3: (Int, Int, Int) = (1,2,3) scala> val tp3_1=(1,2,3)
tp3_1: (Int, Int, Int) = (1,2,3) scala> tp3.productIterator.toList zip
tp3_1.productIterator.toList res364: List[(Any, Any)] = List((a,1), (b,2),
(c,3)) scala> Array("a","b").zipAll(Array(1,2,3),"",0) res367: Array[(String,
Int)] = Array((a,1), (b,2), ("",3)) scala>
Array("a","b","c").zipAll(Array(1,2),"",0) res2: Array[(String, Int)] =
Array((a,1), (b,2), (c,0)) scala> List(("a",1), ("b",2), ("c",0)).unzip res5:
(List[String], List[Int]) = (List(a, b, c),List(1, 2, 0)) 最常用的方法： scala>
Array("a","b").zipWithIndex res6: Array[(String, Int)] = Array((a,0), (b,1))
scala> Array("a","b").zipWithIndex.foreach(x=>println(x.swap)) (0,a) (1,b)
3 映射（Map）

3.1 不可变Map的创建
scala> val scores = Map("zhangsan"->70,"lisi"->80,"wangwu"->90) scores:
scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 70, lisi -> 80,
wangwu -> 90) # 无法修改Map中的值 scala> scores("zhangsan")=91 <console>:16: error:
value update is not a member of scala.collection.immutable.Map[String,Int]
scores("zhangsan")=91 scala> scores.keys res384: Iterable[String] =
Set(zhangsan, lisi, wangwu) scala> scores.values res385: Iterable[Int] =
MapLike(90, 80, 70)
取值
scala> scores.get("zhangsan") res390: Option[Int] = Some(90) scala>
scores.get("zhangsan").get res391: Int = 90 # 推荐使用 scala>
scores.getOrElse("zhangsan",0) res392: Int = 90
 移除n个元素
# 移除0个元素 scala> scores.drop(0) res393:
scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 90, lisi -> 80,
wangwu -> 70) scala> scores.drop(1) res394:
scala.collection.immutable.Map[String,Int] = Map(lisi -> 80, wangwu -> 70)
scala> scores.drop(2) res395: scala.collection.immutable.Map[String,Int] =
Map(wangwu -> 70) # 不可变map不发生变化 scala> scores res396:
scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 90, lisi -> 80,
wangwu -> 70)
 添加元素
//map 没有+:操作，只有 + scala> scores + ("d"->5) res404:
scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 90, lisi -> 80,
wangwu -> 70, d -> 5) # 未发生变化 scala> scores res405:
scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 90, lisi -> 80,
wangwu -> 70)
遍历操作
# 注意以下两种方式的区别 scala> for(kv<-scores) println(kv) (zhangsan,90) (lisi,80)
(wangwu,70) scala> for((k,v)<-scores) println(k,v) (zhangsan,90) (lisi,80)
(wangwu,70) scala> for(kv<-scores) println(kv._1) zhangsan lisi wangwu scala>
for(kv<-scores) println(kv._2) 90 80 70 scala> scores foreach println
(zhangsan,90) (lisi,80) (wangwu,70)
注意：map的默认实现就是HashMap  
scala> val scores =
scala.collection.immutable.HashMap("zhangsan"->90,"lisi"->80,"wangwu"->70,"zhaoliu"->66,"xx"->88)
scores: scala.collection.immutable.HashMap[String,Int] = Map(xx -> 88, lisi ->
80, zhaoliu -> 66, wangwu -> 70, zhangsan -> 90) scala> val scores =
scala.collection.immutable.TreeMap("zhangsan"->90,"lisi"->80,"wangwu"->70,"zhaoliu"->66,"xx"->88)
scores: scala.collection.immutable.TreeMap[String,Int] = Map(lisi -> 80, wangwu
-> 70, xx -> 88, zhangsan -> 90, zhaoliu -> 66)
 HashMap和TreeMap的转换
# 直接转换 无效 scala> scores.asInstanceOf[TreeMap[String,Int]]
java.lang.ClassCastException: scala.collection.mutable.HashMap cannot be cast
to scala.collection.immutable.TreeMap ... 32 elided # 先创建TreeMap 再遍历HashMap添加
scala> var tm=TreeMap[String,Int]() scala> scores.foreach(kv=>tm=tm+(kv))
scala> tm res439: scala.collection.immutable.TreeMap[String,Int] = Map(a -> 1,
lisi -> 80, wangwu -> 70, xx -> 88, zhangsan -> 90, zhaoliu -> 66)
 3.2 创建可变Map

== 可变Map使用较多 ==
scala> val scores =
scala.collection.mutable.Map("zhangsan"->90,"lisi"->80,"wangwu"->70,"zhaoliu"->66,"xx"->88)
scores: scala.collection.mutable.Map[String,Int] = Map(lisi -> 80, zhangsan ->
90, zhaoliu -> 66, xx -> 88, wangwu -> 70) scala> val scores =
scala.collection.mutable.HashMap("zhangsan"->90,"lisi"->80,"wangwu"->70,"zhaoliu"->66,"xx"->88)
scores: scala.collection.mutable.HashMap[String,Int] = Map(lisi -> 80, zhangsan
-> 90, zhaoliu -> 66, xx -> 88, wangwu -> 70) scala> scores.get("lisi") res441:
Option[Int] = Some(80) scala> scores("lisi")=91 scala> scores.get("lisi")
res443: Option[Int] = Some(91)
添加元素
//推荐使用 scala> scores.put("a",1) res444: Option[Int] = None scala> scores
res445: scala.collection.mutable.Map[String,Int] = Map(lisi -> 91, zhangsan ->
90, a -> 1, zhaoliu -> 66, xx -> 88, wangwu -> 70) // + 返回的是新的map对象 scala>
scores + ("b"->2) res446: scala.collection.mutable.Map[String,Int] = Map(b ->
2, lisi -> 91, zhangsan -> 90, a -> 1, zhaoliu -> 66, xx -> 88, wangwu -> 70) #
原来的Map未发生改变 scala> scores res447: scala.collection.mutable.Map[String,Int] =
Map(lisi -> 91, zhangsan -> 90, a -> 1, zhaoliu -> 66, xx -> 88, wangwu -> 70)
4 列表（List）

4.1 List 不可变
scala> List(1,2,3) res451: List[Int] = List(1, 2, 3) scala> (1 to 100) toList
warning: there was one feature warning; re-run with -feature for details
res452: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
97, 98, 99, 100) # 数组 scala> Array(1,2,3).toList res453: List[Int] = List(1, 2,
3) # 元组 scala> (1,2,3).productIterator.toList res455: List[Any] = List(1, 2, 3)
scala> Map("a"->1).toList res456: List[(String, Int)] = List((a,1)) scala>
Seq(1,2,3) res457: Seq[Int] = List(1, 2, 3) scala> 9 :: 5 :: 2 :: Nil res464:
List[Int] = List(9, 5, 2) scala> List(1):::List(2) res470: List[Int] = List(1,
2) scala> val lst1=List(1) lst1: List[Int] = List(1) scala> lst1:+123 res473:
List[Int] = List(1, 123) scala> lst1 res474: List[Int] = List(1) # 没有new
List(100)这种写法 了解实际上List这样创建出来的 scala> List(1,2,3).getClass res496: Class[_ <:
List[Int]] = class scala.collection.immutable.$colon$colon scala>
$colon$colon(1,$colon$colon(2,$colon$colon(3,Nil))) res500:
scala.collection.immutable.::[Int] = List(1, 2, 3) # new
scala.collection.immutable.::(x, this)
4.2 ListBuffer 可变
scala> import scala.collection.mutable.ListBuffer import
scala.collection.mutable.ListBuffer scala> val buf=ListBuffer(1,2,3) buf:
scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3) # :+ 返回新的对象
scala> buf:+4 res475: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1,
2, 3, 4) scala> buf res476: scala.collection.mutable.ListBuffer[Int] =
ListBuffer(1, 2, 3) # += 在原来的List上更改 scala> buf+=4 res478: buf.type =
ListBuffer(1, 2, 3, 4) scala> buf res479:
scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4) scala>
buf++=ListBuffer(7,8) res482: buf.type = ListBuffer(1, 2, 3, 4, 7, 8) scala>
buf res483: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4,
7, 8)
5 Set

Set中的元素不可重复，无序（TreeSet除外）

5.1 创建不可变Set
scala> import scala.collection.immutable.HashSet import
scala.collection.immutable.HashSet scala> val set0=Set(1,2,3,4,5) set0:
scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4) scala>
println(set0.getClass) class scala.collection.immutable.HashSet$HashTrieSet #
默认的Set scala> val set1 = new HashSet[Int]() set1:
scala.collection.immutable.HashSet[Int] = Set() # 可以使⽤加号追加元素，会产⽣⼀个新的集合，原有set不变
scala> val set2 = set1 + 1 set2: scala.collection.immutable.HashSet[Int] =
Set(1) scala> set1 res3: scala.collection.immutable.HashSet[Int] = Set() #
Set集合中不会出现重复的元素 scala> val set3 = set2 ++ Set(1,2,3) set3:
scala.collection.immutable.HashSet[Int] = Set(1, 2, 3) scala> val set4 =
Set(1,2,3,4,5,6) set4: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3,
4) # Set集合中的元素是⽆序的 scala> print(set4) Set(5, 1, 6, 2, 3, 4) # SortedSet中是有序的
scala> val set5=scala.collection.immutable.TreeSet(1,1,10,5,6,7,8,11,13) set5:
scala.collection.immutable.TreeSet[Int] = TreeSet(1, 5, 6, 7, 8, 10, 11, 13)
5.2 创建可变Set
import scala.collection.mutable object MutSetDemo extends App{ val mutableSet
= Set(1,2,3) println(mutableSet.getClass.getName) //
scala.collection.mutable.HashSet //创建⼀个可变的HashSet val set1 = new
mutable.HashSet[Int]() //向HashSet中添加元素 set1 += 2 //add等价于+= set1.add(4)
//删除⼀个元素,如果删除的对象不存在，则不⽣效，也不会报错 set1 -= 5 set1.remove(2) println(set1) }
5.3 集合的基本操作

Scala集合有三个基本操作：

* head 返回集合第⼀个元素
* tail 返回⼀个集合，包含除了第⼀元素之外的其他元素
* isEmpty 在集合为空时返回true
查找集合中最⼤与最⼩元素：

可以使⽤ Set.min ⽅法来查找集合中的最⼩元素，使⽤ Set.max ⽅法查找集合中 的最⼤元素。

5.4 两个set之间的常用操作

1）连接两个集合

使⽤ ++ 运算符或 Set.++() ⽅法来连接两个集合。如果元素有重复的就会移除重复的元素。

2）集合的交集

使⽤ Set.&（）⽅法或 Set.intersect（） 方法来查看两个集合的交集元素。

3）常用方法

* &:交集运算
* &~:差集运算
* union:并集运算
* contains:是否包含某⼀元素，包含返回true，不包含返回false
* count:计算满足指定条件的集合元素个数
* iterator:获得⼀个迭代器，可⽤于集合遍历
* size:返回集合元素的数量
* splitAt:将集合拆分为两个容器，第⼀个由前n个元素组成，第⼆个由剩下的元素组成
* take:返回前n个元素
* takeRight:返回后n个元素
* 使用to{type}转换为其他集合类型
二、集合的应用

1 集合的重要函数 
/* 常⽤⽅法 基本上集合中都可以使⽤,极个别使⽤不上 Spark中常⽤的集合: Array List 元组 Map Set */ object
CollectionMethodDemo { def main(args: Array[String]): Unit = { /*
map遍历集合处理集合中数据并返回⼀个全新集合 filter遍历集合提供⼀个函数指定过滤规则,对集合中数据继续过滤,满⾜需求的会被过滤出来形成⼀个新的集合
聚合函数(求和)sum 将集合中每⼀个元素相加求出最终和(具备可加性) --> 数值 max和min 最⼤值和最⼩值(了解)
foreach遍历集合主要是打印集合中数据(也可以操作集合中数据但是不能新的集合) --> 输出 sorted 排序 --> 升序 降序 可以考虑
reverse(翻转) sortwith 需要传⼊⽐较参数,这个参数⽐较会决定是升序还是降序 第⼀个参数 > 第⼆个参数 降序 第⼀个参数 < 第⼆个参数
升序 ps:这些⽅法Array和List基本上都可以使⽤ Map和Set选择使⽤ 元组也是选择使⽤ */ //1.Flatten
可以将存储在集合内部的集合压平 val list:List[List[Int]] =
List(List(1,2,3),List(4,5,6),List(7,8,9)) //List(1,2,3,4,5,6,7,8,9) val
flatten: List[Int] = list.flatten println(flatten) //set集合中提供了特殊的操作 --交集,并集和差集
val num1 = Set(5,6,9,20,30,45) val num2= Set(50,60,9,20,35,55) //交集
println(num1.intersect(num2)) //并集 println(num1.union(num2)) //差集
println(num1.diff(num2)) //forall 对集合中的元素条件进⾏过滤,只有当所有元素都满⾜要求时,才会返回true
否则返回false val list1 = List(1,2,3,4,5) val bool:Boolean = list1.forall(_ < 3)
//Partition 分区 //ps:Scala中只能模拟,Spark中可以做到这个分区 //根据传⼊的函数 将数据吸⼊到不同存储位置中 val list2
= List(1,2,3,4,5,6) //返回值类型是⼀个元组 val tuple: (List[Int], List[Int]) =
list2.partition(_%2 ==0) val list2_1 = tuple._1 //两个聚合函数 //1. fold 求和
⽐较特殊需要两个参数 ⼀个是默认值,另外⼀个是计算逻辑 // 当前fold是典型的 柯⾥化 val list3 = List(1,2,3,4,5) //计算
//[A1 >: A](z: A1)(op: (A1, A1) => A1): A1 //现在属于是单线程,效果是看出来, 使⽤par的时候会出现多线程状态
val sum = list3.fold(2)((res,n)=>res+n) println(sum) //fold有两个变种 foldleft 和
foldright //2.reduce 直接求和 通过计算逻辑 进⾏集合中数据的计算 val list4 = List(1,2,3,4,5) val
sum2 = list4.reduce((x,y)=>x+y) //reduce也有两个变种 reduceleft 和 reduceright } }
2 并行集合

Scala为了充分使用多核CPU，提供了并行集合（有别于前面的串行集合），用于多核环境的并行计算。 主要用到的算法有：

# Divide and conquer :
分治算法，Scala通过splitters，combiners等抽象层来实现，主要原理是将计算⼯作分解很多任务，分发给⼀些处理器去完成，并将它们处理结果合并返回
# Work
stealin：工作窃取算法，主要⽤于任务调度负载均衡（load-balancing），通俗点完成⾃⼰的所有任务之后，发现其他⼈还有活没⼲完，主动（或被安排）帮他⼈⼀起⼲，这样达到尽早⼲完的⽬的。

1）打印1~5
scala> (1 to 5).foreach(println(_)) 1 2 3 4 5 scala> println() scala> (1 to
5).par.foreach(println(_)) 3 1 4 2 5
2) 查看并行集合中元素访问的线程
scala> val result1 = (0 to 10000).map{case _ =>
Thread.currentThread.getName}.distinct result1:
scala.collection.immutable.IndexedSeq[String] = Vector(main) scala> val result2
= (0 to 10000).par.map{case _ => Thread.currentThread.getName}.distinct
result2: scala.collection.parallel.immutable.ParSeq[String] =
ParVector(ForkJoinPool-1-worker-25, ForkJoinPool-1-worker-23,
ForkJoinPool-1-worker-29, ForkJoinPool-1-worker-13, ForkJoinPool-1-worker-31,
ForkJoinPool-1-worker-21, ForkJoinPool-1-worker-11, ForkJoinPool-1-worker-15,
ForkJoinPool-1-worker-3, ForkJoinPool-1-worker-19, ForkJoinPool-1-worker-1,
ForkJoinPool-1-worker-5, ForkJoinPool-1-worker-17, ForkJoinPool-1-worker-9,
ForkJoinPool-1-worker-7, ForkJoinPool-1-worker-27) scala> println(result1)
Vector(main) scala> println(result2) ParVector(ForkJoinPool-1-worker-25,
ForkJoinPool-1-worker-23, ForkJoinPool-1-worker-29, ForkJoinPool-1-worker-13,
ForkJoinPool-1-worker-31, ForkJoinPool-1-worker-21, ForkJoinPool-1-worker-11,
ForkJoinPool-1-worker-15, ForkJoinPool-1-worker-3, ForkJoinPool-1-worker-19,
ForkJoinPool-1-worker-1, ForkJoinPool-1-worker-5, ForkJoinPool-1-worker-17,
ForkJoinPool-1-worker-9, ForkJoinPool-1-worker-7, ForkJoinPool-1-worker-27)
3 WordCount
/** * 单词统计 */ object Scala_WordCount { def main(args: Array[String]): Unit = {
//数据 val line = List("hello tom hello jerry","hello xiaobai hello","hello tom")
// 要求将数据进⾏处理得到的结果
//List("hello","tom","hello","jerry","hello","xiaobai","hello","hello","tom")
/*flatten+Map实现 val words: List[Array[String]] = line.map(_.split(" ")) val
flatten: List[String] = words.flatten println(flatten) */ //1.flatMap -->
flatten+Map 具备在遍历处理数据同时,将数据将数据进⾏扁平化处理 //在处理数据的时候⼀定要返回⼀个集 val words:List[String]
= line.flatMap(_.split(" ")) println(words) // 可以仿照MR中Map阶段,对单词拼接形成kv键值对 单词,1
val tuples: List[(String, Int)] = words.map((_,1)) println(tuples)
//MR中kv键值对会发送到Reduce然后会出现相同key为⼀组计算⼀次reduce
//因为处理是单词,仿照MR中Reduce端处理逻辑,相同key在⼀起,Scala中提供groupBy根据传⼊参数进⾏分组 //返回值时⼀个Map val
grouped: Map[String, List[(String, Int)]] = tuples.groupBy(_._1)
println(grouped) //Map的组成是 key 是单词 value是具体的单词对应元组 其中元组是使⽤List存储
//此时只需要知道key所对应value中List元素的个数,就可以知道当前单词的个数了
//mapValues是处理Map集合中value的值,只操作value,原则是对应key的value值,返回值是⼀个Map[key是原有的可以,value是计算结果之后的value]
val sumed: Map[String, Int] = grouped.mapValues(_.size) println(sumed) val
list: List[(String, Int)] = sumed.toList /** * sortBy分为两种⼀种是Scala版本
另外⼀种是Spark版本 * Scala版本在没有使⽤隐式转换⾃定义的前提下,sortBy只能升序不能降序 * Spark版本中sortBy有两个参数
⼀个是根据谁来排序, 第⼆个参数是Boolean类型 true是升序 false降序 */ //参数是⼀个⽐较原则 val sorted:
List[(String, Int)] = list.sortBy(_._2) //topN 降序排序 val top1 = sorted take 1
println(sorted) //简化版本 //line.flatMap(_.split(" ")).map((_,1)) //
.groupBy(_._1).mapValues(_.size).toList.sortBy(_._2).take(1) } }
4 Java和Scala集合的互操作
# Scala中的集合和Java中集合互相转换 引⽤⼀个包即可 import scala.collection.JavaConverters._ #
将Scala集合转换为Java集合 val list:java.util.List[Int]=List(1,2,3,4,5).asJava #
将Java集合转换为Scala val buffer: mutable.Buffer[Int] = list.asScala # toXXX
转换成需要的集合类型即可 --> XXX是集合名字 例如Array

• « 上一篇：css横向导航栏布局,CSS04--对齐、 布局、导航栏
• » 下一篇：C语言——数组和地址