Scala之collection基本操作

//第一个参数传入一个函数,第二个参数为隐式参数，返回值和集合的类型一致都是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)的数据丢弃

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.