Scala(五)【集合的高级使用】

一.集合属性
- size
- length
- contains
- mkString
二.集合方法
三.集合的高级函数(重要)

一.集合属性

size

获取集合的大小

list.size

length

获取集合的长度

list.length

contains

是否包含

val list = List[Int](3,7,2,9,10)

list.contains(100

mkString

转字符串，参数是元素的分隔符。

val list = List(1, 2, 3, 4)

println(list.mkString("-"))//结果：1-2-3-4

二.集合方法

drop、dropRight

删除前[后]多少个元素，保留剩下的元素

val list1 = list.drop(3)

val list2 = list.dropRight(3)

distinct：去重

head、last：获取第一个、最后一个元素

tail、init：去除第一个元素剩余的所有元素、去除最后一个元素剩余的所有元素、

isEmpty：是否为空

intersect、diff、union：交集、差集、并集

max、min：最大、最小值

sum：求和

reverse：反转

sliding(窗口长度，滑动步长)

tail：除开最后一个元素，返回剩余元素组成的集合

take（n）：获取前多少个元素，TopN

求集合交集、并集、差集：intersect，diff，union

zip：拉链

val list14 = List[String]("name","age","address","sex","aa")

val list15 = List[Any]("zhangsan",20,"shenzhen","男")

val list16 = list14.zip(list15)

println(list16)// List((name,zhangsan), (age,20), (address,shenzhen), (sex,男))

unzip：反拉链

返回一个二元元祖，2个List

//list16:((name,zhangsan), (age,20), (address,shenzhen), (sex,男))

val list17 = list16.unzip

println(list17)//(List(name, age, address, sex),List(zhangsan, 20, shenzhen, 男))

sorted：升序

//排序，升序

val list1 = list.sorted

//降序

val list2 = list.sorted.reverse

sortBy：指定排序条件

默认升序

 val list3 = List[(String,Int)]( ("zhangsan",20),("lisi",30),("wangwu",15),("zhaoliu",5) )

val list = list3.sortBy(_._1)

sortWith：自定义升降序

// 函数体中< 代表是升序  >代表是降序

val list5 = list3.sortWith((x,y)=>x._2<y._2)

//升序

val list7 = list3.sortWith(_._2<_._2)

println(list7)//List((zhaoliu,5), (wangwu,15), (zhangsan,20), (lisi,30))

//降序

val list6 = list3.sortWith((x,y)=>x._2>y._2)

println(list6)//List((lisi,30), (zhangsan,20), (wangwu,15), (zhaoliu,5))

三.集合的高级函数(重要)

map：转换（一对一）

对list每个元素都执行一次，返回一个新的list

val list8 = List[String]("hello","word","python","hadoop")

val list9 = list8.map(x=>x.length)//List(5, 4, 6, 6)

class Person(val name:String,val age:Int)

val list10 = List[(String,Int)]( ("zhangsan",20),("lisi",50),("wangwu",60))

val list11 = list10.map(x=> new Person(x._1,x._2))//List(对象一，对象二，对象三)

flatten：压平（一对多）

只压第二层

val list12 = List[List[String]] ( List("scala","python"),List("hadoop","flume","kafka") )

val list13 = list12.flatten////List("scala","python","hadoop","flume","kafka")

//string也属于Seq，可以被压平成字符

val list16 = List[String]("hello spark","hello scala")

val list17 = list16.flatten

println(list17) //List(h, e, l, l, o,  , s, p, a, r, k, h, e, l, l, o,  , s, c, a, l, a)

flatMap：转换+压平（一对多）

等价于先map，再flatten

val list16 = List[String]("hello python","hello scala","hadoop flume")

val list17 = list16.map(x=>x.split(" ")).flatten

println(list17)//List(hello, spark, hello, scala)

groupBy：（多对一）

根据自定义的规则进行分组，分组后的结果是一个Map，key是分组的条件，value是一个List

    val list = List(("Shenczhen", "zhagnsan", 20), ("guangzhou", "lisi", 10), ("Shenczhen", "wangwu", 30), ("Shenczhen", "zhaoliu", 20), ("chengdu", "wuqi", 10))

    val map: Map[(String, Int), List[(String, String, Int)]] = list.groupBy(x => {

      (x._1, x._3)

    })

    println(map) //Map((Shenczhen,30) -> List((Shenczhen,wangwu,30)),

                //(chengdu,10) -> List((chengdu,wuqi,10)),

               // (guangzhou,10) -> List((guangzhou,lisi,10)),...)

reduce：聚合（多对一）

迭代计算，本次计算的结果作为下次计算的输出

sum默认给的是集合的第一个值，然后从第二个元素开始遍历

从左往右

val list1 = List(1, 2, 3, 4)

val s = list1.reduce((sum, x)=>sum+x)

println(s)

flod(初始值)(函数)：叠加（多对一）