Scala基础之集合常用方法

引申：scala Builder设计模式
场景
	1）当对象具有大量可选参数时。
	2）当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
	3）当构造过程必须允许被构造的对象有不同的表示时。

//第一个参数,传入一个函数,第二个参数为隐式参数，返回值和集合的类型一致都是B
def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {
//方法内部定义builder方法
    def builder = { // extracted to keep method size under 35 bytes, so that it can be JIT-inlined
    //调用repr方法
      val b = bf(repr)
      b.sizeHint(this)
      b
    }
    //将上述builder方法的返回值赋值给b
    val b = builder
    for (x <- this) b += f(x)
   //调用result方法,返回一个集合
    b.result
  }　

1）map方法将某个函数应用到集合中的每个元素，并产生一个新集合。
2）新产生集合的个数等于原集合的个数，个数大于原元素就会形成集合嵌套
3）元素(eg:String)应用到map方法传递的函数(eg elem=>elem.split(""))后产生的元素大于原元素，此时生成一个集合，最后形成一个集合嵌套
4）进行map的对象是只含一层的集合　　

1）使用没用参数；
2）String最终会被扁平化到字符
3）返回的是集合
4）进行flatten的对象是可以嵌套的的集合

1）输入什么集合，返回什么集合
2）flatmap方法传递的函数的参数是字符串
3）flatMap返回的个数则是不同与原集合个数
4）flatMap = map + flatten 即先对集合中的每个元素进行map，再对map后的每个元素（map后的每个元素必须还是集合）中的每个元素进行flatten
5）进行map的对象可以是只含一层的集合，但进行flatten操作的对象必需是至少含两层的集合　

1）输入什么类型集合，返回什么类型集合
2）满足条件（true）的数据保留，不满足条件(false)的数据丢弃　

groupby
def groupBy[K](f: A => K): immutable .Map [K,, Repr] = {
//创建一个可变map对象m->【k:K v:mutable.Bulder[A,Repr]】
//Bulder 元素为A，构建类型为Repr,它可以通过+=来向构造器中添加元素，通过result返回得到一个任意类型的集合

  val m: mutable.Map[K, mutable.Builder[A, Repr]] = mutable.Map.empty[K, Builder[Aj Repr]] 

//遍历集合，向m中添加元素，key为传过来的集合中的元素通过函数f()计算返回的结果，
//如果该key是在m中没有，则创建一个元素类型为A,构建类型为Repr的Builder对象放入value中，
//并让bldr指向该Builder对象，向bldr中添加元素elem(事实上是向m的value中添加elem)
/*

举例： 第一次f()计算结果是1，elem是"a"，由于是第一次，则创建新的Builder给V，
此时m = （1 -> (“a”)）,第二次f()计算结果还是1，elem是"b"，
此时m=（1 ->（“a”,“b”））,第三次f()计算结果变成2了，elem是"c"，
由于key->2第一次出现，则创建新的Builder，此时m=（1 ->（“a”,“b”）,2 -> (“c”)）

*/
for (elem <- this) {
    val key: K = f(elem)
    val bldr： mutable.Builder[A, Repr] = m.getOrElseUpdate(key, newBuilder) bldr += elem
  }
//创建一个构造器b,元素类型是Tupple2(K,Repr),构建类型是Map(K,Repr),遍历m，
//向b中添加k和v,将m的数据导入到构造器b中 调用result输出集合
  val b: mutable.Builder[(K, Repr), Map[K, Repr]] = immutable.Map.newBuilder[K,, Repr] 
for ((k, v) <- m)
    b += ((k, v.result))
  b.result　

1) groupBy传入的参数f(A)=>K,  A为调用函数的集合元素类型，K为输出map的key。
2) 输出map的value类型为调用函数的集合的类型　　

//sortBy最后也是调用的sorted方法，隐式参数Ordering作用混入了Java的Comparator接口
//提供一个外部比较器

 def sortBy[B](f: A => B)(implicit ord: Ordering[B]): Repr = sorted(ord on f)
//sorted源码
 def sorted[B >: A](implicit ord: Ordering[B]): Repr = {
    val len = this.length
    val arr = new ArraySeq[A](len)
    var i = 0
    for (x <- this.seq) {
      arr(i) = x
      i += 1
    }
//sorted方法真正排序的逻辑是调用的java.util.Arrays.sort
//java中的sort用快速排序和优化的归并排序
//快速排序主要是对那些基本类型数据（int,short,long等）排序， 而归并排序用于对Object类型进行排序。
    java.util.Arrays.sort(arr.array, ord.asInstanceOf[Ordering[Object]])
    val b = newBuilder
    b.sizeHint(len)
    for (x <- arr) b += x
    b.result
  }　　

java sort总结：
1）首先先判断需要排序的数据量是否大于60。
2）小于60：使用插入排序，插入排序是稳定的
3）大于60的数据量会根据数据类型选择排序方式：
    基本类型：使用快速排序。因为基本类型。1、2都是指向同一个常量池不需要考虑稳定性。
    Object类型：使用归并排序。因为归并排序具有稳定性。
4）注意：不管是快速排序还是归并排序。在二分的时候小于60的数据量依旧会使用插入排序

scala sort总结：
1）升序默认
2）"Hello Scala" compare "Hello React" 第一个单词首字母相同，比较第二个单词首字母
3)  Ordering.Int.reverse;隐式参数Ordering来做倒序排序　

1）处理什么集合，返回什么集合
Let's say we have a Map[A,B]. For clarification: I'm always referring to an immutable Map.
mapValues takes a function B => C, where C is the new type for the values　

源码：
//箭头函数作为参数返回boolean，partition返回一个元组
  def partition(p: A => Boolean): (Repr, Repr) = {
// l,r是创建出来的2个集合对象
    val l, r = newBuilder
    for (x <- this) (if (p(x)) l else r) += x
//什么集合类型调用partition就返回什么类型的嵌套元组 eg (List(),List())
    (l.result, r.result)
  }　

滑动窗口数据会造成重复
运用场景： 每隔30分钟统计前1个小时的数据　

1）list1.zip(list2) 返回 list((),(),()) ;返回的集合类型嵌套元组
2）zipWithIndex，元素和索引映射

fold方法传递2个部分的参数, 第一个部分表示集合之外的数据, 第二个部分的参数表示数据进行的逻辑处理
foldLeft 实例可以操作2个map，让key相同的value相加

补充命令
intersect
union
diff
sliding
zip
reduce（相邻）
fold（折叠）
foldLeft
par
sortby
sortwith(自定义排序)
collect(偏函数) list.collect{
            case i : Int => i + 1
        }　

val list1 = List(1,2,3,4)
val map1 = mutable.Map(
      ("a", 1), ("b", 2), ("c", 3)
 )
val map2 = mutable.Map(
    ("a", 4), ("d", 5), ("c", 6)
)
val map3 = map2.foldLeft(map1)(
     (map, kv) => {
         val key = kv._1
          val cnt = kv._2
          val oldCnt = map.getOrElse(key, 0)
          map.update(key, oldCnt + cnt)
          map
      }
)