集合简介

1）说明
（1）Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。
（2）对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本，分别位于以下两个包
不可变集合：scala.collection.immutable
可变集合： scala.collection.mutable
2）案例实操
（1）Scala不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而不会对原对象进行修改。
（2）可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象。

  1. object TestList {
  3.   def main(args: Array[String]): Unit = {
  5.     //不可变List
  6.     val immutableList: List[Int] = List(1, 2, 3, 4, 5)
  8.     //对不可变List进行修改，在头部添加一个元素0
  9.     val newImmutableList: List[Int] = 0 +: immutableList
  11.     println(immutableList)
  13.     println(newImmutableList)
  16.     //可变List
  17.     val mutableList: ListBuffer[Int] = ListBuffer(1, 2, 3, 4, 5)
  19.     //对可变List进行修改，在头部添加一个元素0
  20.     val newMutableList: ListBuffer[Int] = 0 +=: mutableList
  22.     println(mutableList)
  23.     println(newMutableList)
  24.   }
  25. }

不可变集合继承图

image.png
1）Set、Map是Java中也有的集合
2）Seq是Java没有的，我们发现List归属到Seq了，因此这里的List就和Java不是同一个概念了
3）我们前面的for循环有一个 1 to 3，就是IndexedSeq下的Vector
4）String也是属于IndexeSeq
5）我们发现经典的数据结构比如Queue和Stack被归属到LinerSeq
6）大家注意Scala中的Map体系有一个SortedMap，说明Scala的Map可以支持排序
7）IndexSeq和LinearSeq的区别：
（1）IndexSeq是通过索引来查找和定位，因此速度快，比如String就是一个索引集合，通过索引即可定位
（2）LineaSeq是线型的，即有头尾的概念，这种数据结构一般是通过遍历来查找

可变集合继承图

image.png

集合符号总结：

  • 带+与带-的区别:

    带+是添加元素
    带-是删除元素（不可变一般没有-号）

  • 一个+/-与两个+/-的区别:

    一个+/-是添加/删除单个元素
    两个+/-是添加/删除指定集合所有元素

  • 冒号在前与冒号在后以及不带冒号的区别:

    冒号在前是将元素添加在集合最末尾
    不带冒号是将元素添加在集合最末尾
    冒号在后是将元素添加在集合最前面

  • 带=与不带=的区别

    带=是修改集合本身（不可变一般没有=号）
    不带=是生成一个新集合，原集合没有改变

    有序集合：【数组、list、队列】

  • update/updated方法修改元素

    可变的不需要update/updated方法，直接通过角标修改数据
    不可变的需要update/updated方法才能修改数据
    update:修改集合本身
    updated:生成一个新的集合，原集合没有改变

  • 不可变与可变，可相互转换

    无序集合：【map、set】

    set

  • 无法修改元素

    map

  • 不可变map，不可删除元素

  • 可变map，可删除

集合分类

数组

不可变数组

_ 不可变数组创建:
1、通过new创建: new Array元素类型
2、通过apply方法: Array元素类型
添加数据
删除数据
获取数据： 数组名(角标)
修改数据: 数组名(角标) = 值

  1. package tcode.chapter07
  3. object $01_ImmutableArray {
  5.   def main(args: Array[String]): Unit = {
  7.     //1、通过new创建: new Array[元素类型](数组的长度)
  8.     val arr = new Array[String](10)
  9.     println(arr.toList)
  11.     //2、通过apply方法: Array[元素类型](初始元素,...)
  12.     val arr2 = Array[Int](10,3,7,9,20)
  13.     println(arr2.toList)
  15.     //3、添加元素
  16.     //添加单个元素
  17.     val arr3 = arr2.+:(40)
  18.     println(arr3.toList)
  19.     println(arr2.toList)
  21.     println( arr2.eq(arr3)  )
  23.     val arr4 = arr2.:+(50)
  24.     println(arr4.toList)
  26.     //添加一个整个集合
  27.     val arr5 = arr2.++(Array(100,200,300))
  28.     println(arr5.toList)
  30.     val arr6 = arr2.++:(Array(600,700,800))
  31.     println(arr6.toList)
  33.     //2、删除
  35.     //3、获取元素
  36.     println(arr2(0))
  38.     //4、修改元素
  39.     arr2(0) = 100
  40.     println(arr2.toList)
  42.     arr2.update(1,30) // 只改变原集合，不会生成新集合
  43.     println(arr2.toList)
  45.     //不可变转可变
  46.     val arr10 = arr2.toBuffer
  47.     println(arr10)
  48.   }
  49. }

可变数组


可变数组的创建:
1、通过new: new ArrayBuffer元素类型
2、通过apply方法: ArrayBuffer元素类型 

  1. package tcode.chapter07
  3. import scala.collection.mutable.ArrayBuffer
  5. object $02_MutbaleArray {
  8.   def main(args: Array[String]): Unit = {
  11.     //1、通过new: new ArrayBuffer[元素类型]()
  12.     val arr = new ArrayBuffer[Int]()
  14.     //2、通过apply方法: ArrayBuffer[元素类型](初始元素,...)
  15.     val arr2 = ArrayBuffer[Int](10,4,5,2,9)
  17.     println(arr.toList)
  18.     println(arr2.toList)
  20.     //添加元素
  21.     val arr3 = arr2.+:(10)
  22.     println(arr3.toList)
  23.     println(arr2.toList)
  25.     val arr4 = arr2.:+(30)
  26.     println(arr4.toList)
  28.     arr2.+=(60)
  29.     println(arr2.toList)
  31.     arr2.+=:(90)
  32.     println(arr2.toList)
  34.     //添加一个集合
  35.     val arr5 = arr2.++( Array(100,200) )
  36.     println(arr5.toList)
  38.     val arr6 = arr2.++:( Array(100,200)  )
  39.     println(arr6.toList)
  41.     arr2.++=( Array(500,600) )
  42.     println(arr2.toList)
  44.     arr2.++=:(  Array(500,600) )
  45.     println(arr2.toList)
  47.     //删除
  48.     val arr7 = arr2.-( 500 )
  50.     println(arr7.toList)
  52.     arr2.-=( 600 )
  53.     println(arr2.toList)
  55.     val arr8 = arr2.-- ( Array(500,600,600))
  56.     println(arr8.toList)
  58.     arr2.--=(  Array(500,600,2,9) )
  59.     println(arr2.toList)
  61.     arr2.remove(0,3)
  63.     //获取元素
  64.     println(arr2(0))
  66.     //修改元素
  67.     arr2(0)=900
  68.     println(arr2.toList)
  69.     arr2.+=(500)
  70.     arr2.+=(500)
  71.     arr2.+=(600)
  73.     println(arr2.toList)
  75.     //可变转不可变
  76.     val arr10 = arr2.toArray
  77.     println(arr10.toList)
  79.     //多维数组的创建
  80.     val arr11 = Array.ofDim[Int](3,4)
  82.     println(arr11.length)
  83.     println(arr11(0).length)
  84.   }
  85. }

Seq集合（List）

不可变list

  1.  创建:<br />       1、apply方法: List[元素类型](初始元素，。。。)<br />       2、初始元素 :: 初始元素 :: ... :: 不可变List/Nil（空的不可变list）<br />添加位置：看元素处于：：的位置<br />             :: 最右边必须是不可变List或者是Nil<br />              Nil是空集合，Nil与List的关系类似Null与String的关系<br />             ** Nil一般可以用于给不可变List变量赋予初始值, Nil给不可变List变量赋予初始值的时候**必须指定变量类型<br />   <br />     :: 与 ::: 的区别:<br />         ::是添加单个元素<br />         ::: 是添加一整个集合（array、list等）所有元素

list转array
println(list10.toBuffer)

  1. package tcode.chapter07
  3. object $03_ImmutableList {
  6.   def main(args: Array[String]): Unit = {
  8.     //1、apply方法: List[元素类型](初始元素，。。。)
  9.     val list = List[Int](10,3,6,7,2)
  11.     var list2:List[Int] = Nil
  13.     list2= list
  15.     //2、初始元素 :: 初始元素 :: ... :: List/Nil
  16.     val list3 = 10 :: 5 :: 6 :: Nil
  17.     println(list3)
  19.     //3、添加元素
  20.     val list4 = list3.+:(20)
  21.     println(list4)
  23.     val list5 = list3.:+(40)
  24.     println(list5)
  26.     val list6 = 40 :: list3
  27.     println(list6)
  29.     val list7 = list3.++(Array(10,20,30))
  30.     println(list7)
  32.     val list8 = list3.++:(Array(10,2030))
  33.     println(list8)
  35.     val list9 = List(50,60,70) ::: list3
  36.     println(list9)
  38.     val list10 = List(50,60,70) :: list3
  39.     println(list10)    // 两个冒号的结果是List（List（10，20,30），10,5,6）
  41.     //删除：无
  43.     //获取元素
  44.     println(list9(0))
  46.     //修改元素
  47.     //list9(0)=100，没办法通过这种方式获取值
  48.     //println(list9)
  49.     val list10 = list9.updated(0,100)// 获取给新list，0：索引，100：值
  50.     println(list9)
  51.     println(list10)
  52.     //List转Array
  53.     println(list10.toBuffer)
  54.   }
  55. }

可变list

  1. package tcode.chapter07
  3. import scala.collection.mutable.ListBuffer
  5. object $04_MutableList {
  7.   /**
  8.     * 创建可变List: ListBuffer[元素类型](初始元素,...)
  9.     */
  10.   def main(args: Array[String]): Unit = {
  12.     val list = ListBuffer[Int](10,20,3,5,9)
  14.     println(list)
  16.     //添加元素
  17.     val list2 = list.+:(30)
  18.     println(list2)
  20.     val list3 = list.:+(50)
  21.     println(list3)
  23.     list.+=(100)
  24.     println(list)
  26.     list.+=:(300)
  27.     println(list)
  29.     val list4 = list.++(Array(100,200,300))
  30.     println(list4)
  32.     val list5 = list.++:(Array(100,200,300))
  33.     println(list5)
  35.     list.++=(List(11,22,33))
  36.     println(list)
  38.     list.++=:(List(44,55,66))
  39.     println(list)
  41.     //删除元素
  42.     val list6 = list.-( 55 )
  43.     println(list6)
  45.     list.-=(66)
  46.     println(list)
  48.     val list7 = list.--(List(44,300,11))
  49.     println(list7)
  51.     list.--=(List(10,20,22,33))
  52.     println(list)
  54.     //获取元素
  55.     println(list(0))
  57.     //修改元素
  58.     list(0)=100
  59.     println(list)
  61.     //可变转不可变
  62.     println(list.toList)
  64.   }
  65. }

set集合

不可变set

  1. package tcode.chapter07
  3. object $05_ImmutableSet {
  5.   //Set的特性: 无序，不重复
  6.   //
  7.   def main(args: Array[String]): Unit = {
  9.     //创建Set： Set[元素类型](初始元素,...)
  10.     val set = Set[Int](10,2,2,5,1,9)
  12.     println(set)
  14.     //添加元素
  15.     val set2 = set.+(20)
  16.     println(set2)
  18.     val set3 = set.++(List(100,94,20,99))
  19.     println(set3)
  21.     val set4 = set.++:(List(100,94,20,99))
  22.     println(set4)
  24.     //删除元素
  25.     val set5 = set.-(10)
  26.     println(set5)
  28.     val set6 = set.--(List(5,1,9))
  29.     println(set6)
  31.     //获取元素，只能通过遍历获得
  32.    // println(set6(10)) // 返回true/false
  33.     for(e<- set){
  34.       println(e)
  35.     }
  37.     //修改元素，无法修改
  39.   }
  40. }

可变set

  1. package tcode.chapter07
  3. import scala.collection.mutable
  5. object $06_MutableSet {
  7.   def main(args: Array[String]): Unit = {
  9.     //创建: mutable.Set[元素类型](初始元素，。。。。)
  10.     val set = mutable.Set[Int](10,3,7,2,9,20)
  11.     println(set)
  13.     //添加
  14.     val set2 = set.+(100)
  15.     println(set2)
  17.     set.+=(100)
  18.     println(set)
  20.     val set3 = set.++(List(200,87,65))
  22.     println(set3)
  24.     val set4 = set.++:(List(200,87,65))
  25.     println(set4)
  27.     set.++=(List(200,87,65))
  28.     println(set)
  30.     //删除
  31.     val set5 = set.-(2)
  32.     println(set5)
  34.     set.-=(100)
  35.     println(set)
  37.     val set6 = set.--(List(2,3,7))
  38.     println(set6)
  40.     set.--=(List(2,3,7))
  41.     println(set)
  42.     //修改元素
  43.     //set.update(200,false),这个update执行的是新增操作，无法修改元素，true则添加元素
  44.     //println(set)
  46.   }
  47. }

元祖：

/*
 元组创建:
1、通过()方式创建: (初始元素,…)
 2、通过->方式创建[只能在二元元组使用]: K->V
scala中二元元祖对应KV键值对
 元组中最多只能存放22个元素
元组一旦定义就不可变[元素不可变，长度不可变]
 元组获取值: 元组名._角标 [元组的角标从1开始] 如 ： r._1
*/

  1. package tcode.chapter07
  3. object $07_Tuple {
  6.   def main(args: Array[String]): Unit = {
  7.     //元组创建:
  8.     val t1 = ("zhangsan",20,"shenzhen")
  10.     val t2 = "zhagnsan"->20
  12.     println(t1)
  13.     println(t2)
  15.     println(t1._1)
  17.     val logs = List("1 zhangsan 20 shenzhen","2 wagnwu 30 beijing","3 zhaoliu 44 shenzhen")
  19.     val persons = for(e<- logs) yield {
  20.       val arr = e.split(" ")
  21.       (arr(0),arr(1),arr(2).toInt,arr(3))
  22.     }
  24.     // persons: list((1，zhangsan，20，shenzhen)，（。。。），（。。。）)
  26.     for(e<- persons){
  27.       println(e._3)
  28.     }
  30.     val list2 = List[Region](
  31.       new Region("宝安区",new School("宝安中学",new Clazz("大数据班",new Student("zhangsan",20)))),
  32.       new Region("宝安区",new School("宝安中学",new Clazz("大数据班",new Student("wangwu",20)))),
  33.       new Region("宝安区",new School("宝安中学",new Clazz("大数据班",new Student("zhaoliu",20))))
  34.     )
  36.     val ts = List[(String,(String,(String,(String,Int))))](
  37.       ("宝安区",("宝安中学",("大数据班",("zhangsan",20)))),
  38.       ("宝安区",("宝安中学",("大数据班",("wangwu",20)))),
  39.       ("宝安区",("宝安中学",("大数据班",("zhaoliu",20))))
  40.     )
  42.     for(element<- ts){
  43.       println( element._2._2._2._1 )
  44.     }
  45.   }
  47.   class Region(name:String,school:School)
  49.   class School(name:String,clazz:Clazz)
  51.   class Clazz(name:String,stu:Student)
  53.   class Student(name:String,age:Int)
  54. }

map集合

不可变map

  1. * 创建方式:<br />    *     Map[K的类型,V的类型]( (K,V) ,..)<br />    *     Map[K的类型,V的类型]( K->V ,..)<br />    * Option: 提醒外部当前返回结果有可能为空（防止空指针异常）,需要进行处理<br />    *     Some: 代表有值,值封装在Some中<br />    *     None: 代表为空<br />    * Map取值通过getOrElse(key,默认值)[代表key如果在map中存在则取出对应的value值,如果不存在则返回默认值]
  1. package tcode.chapter07
  3. object $08_ImmutableMap {
  5.   /**
  6.     * 创建方式:
  7.     *     Map[K的类型,V的类型]( (K,V) ,..)
  8.     *     Map[K的类型,V的类型]( K->V ,..)
  9.     * Option: 提醒外部当前返回结果有可能为空,需要进行处理
  10.     *     Some: 代表有值,值封装在Some中
  11.     *     None: 代表为空
  12.     * Map取值通过getOrElse(key,默认值)[代表key如果在map中存在则取出对应的value值,如果不存在则返回默认值]
  13.     *
  14.     */
  15.   def main(args: Array[String]): Unit = {
  17.     val map = Map[String,Int]("aa"->1,"bb"->2,("cc",3) )
  19.     //添加元素
  20.     val map2 = map.+( "dd"->4 )
  21.     println(map2)
  23.     val map3 = map.++( List( ("ee",10),"oo"->20,"tt"->30,"ff"->20 ) )
  24.     println(map3)
  26.     val map4 = map.++:(  List( ("ee",10),"oo"->20,"tt"->30,"ff"->20 ) )
  28.     println(map4)
  30.     //获取元素
  31.     // map4.get("ee").get,可以通过get方法获取，但是返回类型是option类型，需要再通过get从some中获得，但是没什么意义
  32.     println(map4.getOrElse("ee",0))
  34.     //修改元素
  35.       //map4("ee")=200 ,不可变map无法通过这种方式修改
  36.     // updated方法：如果存在key则修改元素，如果不存在Key则不修改元素
  37.      val map5 = map4.updated("ee",100)
  38.      println(map4)
  39. //    println(map5)
  40.     // 删除元素：无
  41.   }
  42. }

可变map

  1. package tcode.chapter07
  3. import scala.collection.mutable
  5. object $09_MutableMap {
  7.   def main(args: Array[String]): Unit = {
  9.     val map = mutable.Map[String,Int]("aa"->10,("bb",20),"tt"->50)
  11.     //添加元素
  12.     val map2 = map.+( "pp"->60 )
  13.     println(map2)
  15.     map.+=( "uu"->33 )
  16.     println(map)
  18.     val map4 = map.++( List( "rr"->10,"ll"->20 ))
  19.     println(map4)
  21.     val map5 = map.++:(List( "rr"->10,"ll"->20 ))
  22.     println(map5)
  24.     map.++=(List( "rr"->10,"ll"->20 ))
  25.     println(map)
  27.     map.put("zz",300)
  28.     println(map)
  30.     //删除，只需要删除key即可
  31.     val map6 = map.-("uu")
  32.     println(map6)
  34.     map.-=("uu")
  35.     println(map)
  37.     val map7 = map.--(List("ll","aa","rr"))
  38.     println(map7)
  40.     map.--=(List("ll","aa","rr"))
  41.     println(map)
  43.     map.remove("zz")
  44.     println(map)
  46.     //获取元素
  47.     println(map.getOrElse("bb", 200))
  49.     //修改元素
  50.     map("bb")=200
  51.     println(map)
  53.     map.update("bb",400)
  54.     println(map)
  55.   }
  56. }

队列

可变队列

  1. package tcode.chapter07
  3. import scala.collection.immutable.Queue
  5. object $10_ImmutableQueue {
  7.   def main(args: Array[String]): Unit = {
  8.     //创建: Queue[元素类型](初始元素,...)
  9.     val q1 = Queue[Int](1,5,7,9,2)
  10.     println(q1)
  12.     //添加元素
  13.     val q2 = q1.+:( 20 )
  14.     println(q2)
  16.     val q3 = q1.:+( 30 )
  17.     println(q3)
  19.     val q4 = q1.++(List(100,400,200))
  20.     println(q4)
  22.     val a5 = q1.++:(List(100,400,200))
  23.     println(a5)
  25.     val q6 = q1.enqueue(1000)
  26.     println(q6)
  28.     //删除，dequeue返回值为元祖(A, Queue[A])A为出列的元素，Queue[A]为剩余元素
  29.     val r = q1.dequeue
  30.     println(r._1)
  31.     println(r._2)
  33.     //获取元素
  34.     println(q1(0))
  36.     //修改元素
  37.     //q1(0)=100 // 不可变无法通过下标修改
  38.     //println(q1)
  39.     val q9 = q1.updated(0,100)
  40.     println(q9)
  41.   }
  42. }

不可变队列

  1. package tcode.chapter07
  3. import scala.collection.mutable
  5. object $11_MutableQueue {
  7.   def main(args: Array[String]): Unit = {
  8.     //创建
  9.     val queue = mutable.Queue[Int](10,2,5,8,20)
  11.     //添加元素
  12.     val queue2 = queue.+:( 30 )
  13.     println(queue2)
  15.     val queue3 = queue.:+(40)
  16.     println(queue3)
  18.     queue.+=(50)
  20.     queue.+=:(70)
  22.     println(queue)
  24.     val queue4 = queue.++(List(100,300,200))
  25.     val queue5 = queue.++:(List(100,300,200))
  26.     queue.++=(List(100,300,200))
  27.     println(queue4)
  28.     println(queue5)
  29.     println(queue)
  31.     queue.enqueue(55,44,333)
  32.     println(queue)
  34.     //删除，dequeue返回值类型：元祖
  35.     println(queue.dequeue())
  37.     //获取元素
  38.     println(queue(0))
  40.     //修改元素
  41.     queue(1)=222
  42.     println(queue)
  44.     queue.update(0,111)
  45.     println(queue)
  46.   }
  47. }

par并行集合

/*
 并行集合: scala集合默认是单线程操作,如果想要多线程操作集合元素,需要使用并行集合
普通集合转并行集合: 集合名.par
/

  1. package tcode.chapter07
  3. object $12_Par {
  6.   def main(args: Array[String]): Unit = {
  8.     val list = List(1,2,5,8,20)
  10.     list.foreach(x=>{
  11.       println(s"${Thread.currentThread().getName} --- ${x}")
  12.     } )
  13.     println("-"*100)
  14.     val list2 = list.par
  15.     list2.foreach(x=>{
  16.         println(s"${Thread.currentThread().getName} --- ${x}")
  17.       } )
  18.   }
  19. }

集合常用函数

基本属性操作

  1. package tcode.chapter07
  3. object $13_CollectionField {
  6.   def main(args: Array[String]): Unit = {
  8.     val list = List(1,5,3,7,10,2)
  10.     //是否包含某个元素
  11.     println(list.contains(100))
  13.     //是否为空
  14.     println(list.isEmpty)
  16.     //获取集合长度
  17.     println(list.length)
  18.     println(list.size)
  20.     //将集合转成字符串
  21.     println(list)
  22.     println(list.mkString("#"))
  23.   }
  24. }

衍生集合

  1. package tcode.chapter07
  3. object $14_CollectionPar {
  5.   def main(args: Array[String]): Unit = {
  7.     val list = List(10,2,5,6,3,90,8,4,10)
  9.     //去重 ！！！
  10.     println(list.distinct)
  12.     //删除前多少个元素,保留剩余其他元素
  13.     println(list.drop(3))
  15.     //删除后多少个元素,保留剩余其他元素
  16.     println(list.dropRight(3))
  18.     //获取第一个元素 ！！！
  19.     println(list.head)
  21.     //获取最后一个元素 ！！！
  22.     println(list.last)
  24.     //获取除开最后一个元素的所有元素
  25.     println(list.init)
  27.     //反转 *****
  28.     println(list.reverse)
  30.     //获取子集合
  31.     println(list.slice(0, 3))
  33.     //滑窗 ！！！
  34.     //size: 窗口的长度
  35.     // 内部是元祖，外部是list：List((),(),())
  36.     //step: 滑动长度
  37.     println(list.sliding(4, 3).toList)
  39.     //获取除开第一个元素的所有元素
  40.     println(list.tail)
  42.     //获取前多少个元素 ！！！
  43.     println(list.take(3))
  45.     //获取后多少个元素
  46.     println(list.takeRight(3))
  48.     //交集
  49.     val list2 = List(1,2,3,4,5)
  50.     val list3 = List(4,5,6,7,8)
  51.     println(list2.intersect(list3))
  52.     //并集
  53.     println(list2.union(list3))
  54.     //差集[A差B的结果就是A中有B中没有的元素]
  55.     println(list2.diff(list3))
  57.     //拉链
  58.     val list4 = List("aa","bb","cc","dd")
  59.     val list5 = List(10,20,30)
  60.     val list6 = list4.zip(list5)
  61.     println(list6)
  63.     //反拉链
  64.     println(list6.unzip)
  66.     //将元素与角标拉链
  67.     println(list4.zipWithIndex)
  68.   }
  69. }

集合初级函数

聚合

list.max
list.min
list.sum
list.maxby
list.minby

排序

list.sorted
list.reverse
list.sortBy
list.sortWith

  1. package tcode.chapter07
  3. import scala.math.Ordering
  5. object $15_CollectionLowFunction {
  7.   def main(args: Array[String]): Unit = {
  9.     val list = List(10,3,5,7,2,20)
  11.     //获取最大值
  12.     println(list.max)
  13.     //获取最小值
  14.     println(list.min)
  15.     //求得总和
  16.     println(list.sum)
  17.     //根据指定字段获取最大值
  18.     //maxBy(func: 集合元素类型 => B )
  19.     //maxBy是根据函数的返回值进行排序之后取最大元素
  20.     //后续会将集合每个元素当做参数传递给函数,maxBy中的函数是集合有多少元素就调用多少次
  21.     val list2 = List[(String,Int,Int)](
  22.       ("zhangsan1",20,3000),
  23.       ("zhangsan4",16,4000),
  24.       ("zhangsan4",30,4000),
  25.       ("zhangsan2",15,2500),
  26.       ("zhangsan3",33,1500)
  27.     )
  28.     val func = (x:(String,Int,Int)) => x._2
  29.     println(list2.maxBy(func))
  30.     //直接传递函数值
  31.     println(list2.maxBy((x:(String,Int,Int)) => x._2))
  32.     //省略函数参数类型
  33.     println(list2.maxBy((x) => x._2))
  34.     //函数参数只有一个,()可以省略
  35.     println(list2.maxBy( x => x._2))
  36.     // 使用_代替
  37.     println(list2.maxBy( _._2))
  38.     //根据指定字段获取最小值
  39.     //minBy(func: 集合元素类型=>B )
  40.     //minBy是根据函数的返回值排序之后取最小值
  41.     //后续会将集合每个元素当做参数传递给函数,minBy中的函数是集合有多少元素就调用多少次
  42.     println(list2.minBy(x => {
  43.       x._3
  44.     }))
  46.     //排序
  47.     //1、直接根据元素本身排序,默认升序【sorted】
  48.     val list3 = list.sorted
  50.     println(list3)
  51.     //降序
  52.     println(list3.reverse)
  54.     println(list2.sorted)
  56.     //2、根据指定字段排序[sortBy],默认升序 *****
  57.     //sortBy(func: 集合元素类型 => B )
  58.     //sortBy是根据函数的返回值进行排序
  59.     //后续会将集合每个元素当做参数传递给函数
  61.     val ordering = new Ordering[Int]{
  63.       override def compare(x: Int, y: Int): Int = {
  64.         if(x>y) -1
  65.         else if(x==y) 0
  66.         else 1
  67.       }
  68.     }
  69.     println(list2.sortBy(x => {
  70.       x._3 // 一定要在花括号内（之前因可省略而删除）打断点才能看到函数体的值
  71.     })(ordering))
  73.     //3、根据自己比较排序 sortWith
  74.     // 升序: 第一个参数>第二个参数
  75.     // 降序: 第一个参数<第二个参数
  76.     println(list.sortWith((x, y) => {
  77.       x > y  
  78.     }))
  79.   }
  80. }

集合高阶函数

过滤: filter(func: 集合元素类型=>Boolean)

  1.  filter是针对每个元素操作,后续会将集合每个元素当做函数的参数值传入<br />     filter是集合有多少个元素就调用多少次<br />     filter保留是函数返回值为true的数据

映射: map(func: 集合元素类型=> B ),

其实就是：val func = 集合元素类型 => B , map(func)
map的应用场景: 一对一
map中的函数也是针对集合每个元素操作,后续会将集合每个元素当做函数的参数值传入
val B = A.map( ..) 此时B集合的长度=A集合的长度
map一般用于转换[值的转换、类型的转换]
一般用于抽出（集合）元素进行操作

压平: flatten

  1. flatten是针对集合嵌套集合的场景,会将第二层集合去掉<br />    flatten的场景: 一对多

压平转换类型 flatMap(func: 集合元素类型 => 集合) = map + flatten

  1. flatMap中的函数是针对集合每个元素进行操作,集合有多少个元素,函数就调用多少次<br />    flatMap的应用场景： 一对多<br />    flatMap与flatten的区别:<br />        flatMap是先对元素进行转换之后再压平,flatten是直接压平不转换

遍历 foreach(func: 集合元素类型 => B ):Unit : 遍历

  1. foreach中的函数是针对集合每个元素操作<br />    foreach与map的区别:<br />      map有返回值,foreach是没有返回值

分组 groupBy(func: 集合元素类型=> K): 根据指定字段分组

  1. groupBy里面的函数是针对集合每个元素进行操作,groupBy分组是根据函数的返回值进行分组<br />    groupBy的结果是Map[K,V] 【K就是函数的返回值,也就是分组的key,V是分组的key对应原集合中的所有元素】

聚合reduce\fold

reduce(func: (集合元素类型,集合元素类型)=>集合元素类型): 从左向右计算

  1. reduce是对集合中所有元素进行聚合<br />    reduce函数第一个参数第一次计算的时候初始值 = 集合第一个元素，第N次计算的时候第一个参数的值 = 第N-1次的结果<br />     reduceRight(func: (集合元素类型,集合元素类型)=>集合元素类型): 从右向左计算<br />    reduceRight是对集合中所有元素进行聚合.<br />    reduceRight函数第二个参数第一次计算的时候初始值 = 集合最后一个元素，第N次计算的时候第二个参数的值 = 第N-1次的结果

fold(初始值)(func: (集合元素类型,集合元素类型)=>集合元素类型): 从左向右计算

  1. fold是对集合中所有元素进行聚合<br />    fold函数第一个参数第一次计算的时候初始值 = 指定默认值，第N次计算的时候第一个参数的值 = 第N-1次的结果<br />    foldRight(初始值)(func: (集合元素类型,集合元素类型)=>集合元素类型): 从右向左计算<br />     foldRight是对集合中所有元素进行聚合<br />    foldRight函数第二个参数第一次计算的时候初始值 = 指定默认值，第N次计算的时候第二个参数的值 = 第N-1次的结果
  1. package tcode.chapter07
  3. object $16_CollectionHightFunction {
  5.   def main(args: Array[String]): Unit = {
  7.     val list = List(10,2,5,6,7,9)
  8.     //过滤: filter(func: 集合元素类型=>Boolean)
  9.     // filter是针对每个元素操作,后续会将集合每个元素当做函数的参数值传入
  10.     // filter是集合有多少个元素就调用多少次
  11.     // filter保留是函数返回值为true的数据
  12.     val list2 = list.filter(x=> {
  13.       println(s"x=${x}")
  14.       x%2==0
  15.     })
  16.     println(list2)
  17.     //映射: map(func: 集合元素类型=> B )
  18.     //map的应用场景: 一对一
  19.     //map中的函数也是针对集合每个元素操作,后续会将集合每个元素当做函数的参数值传入
  20.     //val B = A.map( ..) 此时B集合的长度=A集合的长度
  21.     //map一般用于转换[值的转换、类型的转换]
  22.     val list3 = List("spark","hadoop","flume","kafka")
  24.     val list4 = list3.map( x => x.length )
  25.     println(list4)
  27.     //压平: flatten
  28.     //flatten是针对集合嵌套集合的场景,会将第二层集合去掉
  29.     //flatten的场景: 一对多
  31.     val list5 = List[List[Int]](
  32.       List(1,2),
  33.       List(4,5),
  34.       List(7,8)
  35.     )
  37.     val list6 = list5.flatten
  38.     println(list6)
  40.     val list7 = List[List[List[Int]]](
  42.       List(
  43.         List(1,2),
  44.         List(5,6)
  45.       ),
  47.       List(
  48.         List(7,8),
  49.         List(9,10)
  50.       )
  51.     )
  53.     val list8 = list7.flatten.flatten
  54.     println(list8)
  56.     val list9 = List("aa","cc")
  57.     println(list9.flatten)
  59.     //flatMap(func: 集合元素类型 => 集合) = map + flatten
  60.     //flatMap中的函数是针对集合每个元素进行操作,集合有多少个元素,函数就调用多少次
  61.     //flatMap的应用场景： 一对多
  62.     //flatMap与flatten的区别:
  63.     //  flatMap是先对元素进行转换之后再压平,flatten是直接压平不转换
  64.     val list10 = List("hadoop spark flume","kafka flink hello")
  65. //    val list11 = list10.map(x=> x.split(" "))
  66. //    val list12 = list11.flatten
  67. //    println(list12)
  68.     // 上面等价于：
  69.     val list11 = list10.flatMap(x=>x.split(" "))
  70.     println(list11)
  72.     //结果：List(hadoop,spark,flume,kafka,flink,hello)
  74.     //遍历：foreach(func: 集合元素类型 => B ):Unit : 遍历
  75.     //foreach中的函数是针对集合每个元素操作
  76.     //foreach与map的区别:
  77.     //  map有返回值,foreach是没有返回值
  78.     list.foreach(x=>println(x))
  80.     //groupBy(func: 集合元素类型=> K): 根据指定字段分组
  81.     //groupBy里面的函数是针对集合每个元素进行操作,groupBy分组是根据函数的返回值进行分组
  82.     //groupBy的结果是Map[K,V] 【K就是函数的返回值,也就是分组的key,V是分组的key对应原集合中的所有元素】
  83.     val list13 = List( ("lisi","man","shenzhen"),("wangwu","woman","beijing"),("zhaoliu","man","beijing") )
  85.     val map2 = list13.groupBy(x=> x._3)
  87.     println(map2)
  88.     //reduce
  90.     //reduceRight
  92.     //fold
  94.     //foldRight
  96.      //聚合
  97.     //reduce(func: (集合元素类型,集合元素类型)=>集合元素类型): 从左向右计算
  98.     //reduce是对集合中所有元素进行聚合
  99.     //reduce函数第一个参数第一次计算的时候初始值 = 集合第一个元素，第N次计算的时候第一个参数的值 = 第N-1次的结果
  101.     val result = list.reduce((agg,curr) => {
  102.       println(s"agg=${agg} curr=${curr}")
  103.       agg-curr
  104.     })
  105.     println(result)
  106.     //reduceRight(func: (集合元素类型,集合元素类型)=>集合元素类型): 从右向左计算
  107.     //reduceRight是对集合中所有元素进行聚合
  108.     //reduceRight函数第二个参数第一次计算的时候初始值 = 集合最后一个元素，第N次计算的时候第二个参数的值 = 第N-1次的结果
  109.     println("-"*100)
  110.     val r1 = list.reduceRight((curr,agg)=>{
  111.       println(s"agg=${agg} curr=${curr}")
  112.       agg-curr
  113.     })
  114.     println(r1)
  115.     //fold(初始值)(func: (集合元素类型,集合元素类型)=>集合元素类型): 从左向右计算
  116.     //fold是对集合中所有元素进行聚合
  117.     //fold函数第一个参数第一次计算的时候初始值 = 指定默认值，第N次计算的时候第一个参数的值 = 第N-1次的结果
  118.     println("*"*100)
  119.     list.fold(100)((agg,curr)=>{
  120.       println(s"agg=${agg} curr=${curr}")
  121.       agg+curr
  122.     })
  123.     println("+"*100)
  124.     //foldRight(初始值)(func: (集合元素类型,集合元素类型)=>集合元素类型): 从右向左计算
  125.     // foldRight是对集合中所有元素进行聚合
  126.     //foldRight函数第二个参数第一次计算的时候初始值 = 指定默认值，第N次计算的时候第二个参数的值 = 第N-1次的结果
  127.     list.foldRight(200)((curr,agg)=>{
  128.       println(s"agg=${agg} curr=${curr}")
  129.       agg+curr
  130.     })
  132.   }
  134. }