目錄

• 一.集合屬性
  • size
  • length
  • contains
  • mkString
• 二.集合方法
  • drop、dropRight
  • distinct：去重
  • head、last：獲取第一個、最後一個元素
  • tail、init：去除第一個元素剩餘的所有元素、去除最後一個元素剩餘的所有元素、
  • isEmpty：是否為空
  • intersect、diff、union：交集、差集、並集
  • max、min：最大、最小值
  • sum：求和
  • reverse：反轉
  • sliding(視窗長度，滑動步長)
  • tail：除開最後一個元素，返回剩餘元素組成的集合
  • zip：拉鍊
  • unzip：反拉鍊
  • sorted：升序
  • sortBy：指定排序條件
  • sortWith：自定義升降序
• 三.集合的高階函式(重要)
  • map：轉換（一對一）
  • flatten：壓平（一對多）
  • flatMap：轉換+壓平（一對多）
  • groupBy：（多對一）
  • reduce：聚合（多對一）
  • flod(初始值)(函式)：疊加（多對一）
  • filter

一.集合屬性

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：除開最後一個元素，返回剩餘元素組成的集合

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(初始值)(函式)：疊加（多對一）

從左往右

sum預設給的是集合的第一個括號引數的值，然後從第一個元素開始遍歷

val i = list1.fold(0)((sum,x)=>sum+x)
println(i)
println(i)

filter

過濾，判斷條件為True保留，返回過濾後的List集合

//找出集合中的偶數
val list1 = List(1, 2, 3, 4, 5)
val listfilter =list1.filter(x => {
   x % 2 == 0
})
println(listfilter)//List(2, 4)