Scala集合常用方法解析

    val list: List[Int] = List(1,2,3,4)
    // 反转集合
    //println(list.reverse) //List(6, 5, 4, 3, 2, 1)   //set，map没有反转
    list.max
    list.min
    list.sum //求和
    list.product //乘积

    // TODO 排序
    //val listStr = List("1", "5", "9", "11")
    //println("排序 = " + listStr.sorted) //排序 = List(1, 11, 5, 9) 按照字典顺序；  数字、字符串都是按字符串的字典顺序排序

    val stringList = List("11", "55", "13", "22")
    // 1, 5, 3, 2
    // 11 22 13 55
    // TODO 排序 使用自定义排序规则进行排序
    println(stringList.sortBy(x => {
      x.substring(1, 2)  //List(11, 22, 13, 55)
    }))
    //TODO 排序：升序，降序
    println("升序= " + stringList.sortWith{  //升序= List(11, 13, 22, 55)
      case (left, right) => {
        left < right
      }
    })
    println("降序= " + stringList.sortWith{  //降序= List(55, 22, 13, 11)
      case (left, right) => {
        left > right
      }
    })

    println("分组= " +list.groupBy(x => { 　　//分组= Map(1 -> List(1, 3, 5), 0 -> List(2, 4, 6))
      x % 2
    }))

    println(list.map(_ * 2)) //List(2, 4, 6, 8, 10, 12)
    println(list.map((_, 1))) //List((1,1), (2,1), (3,1), (4,1), (5,1), (6,1))

    val list: List[Int] = List(1,2,3,4)

　　// TODO flatMap 扁平化
    val list2 = List(List(1,2), List(3, 4), List(5, 6)) // ==> List(1,2,3,4,5,6)
    // in : List, out : Iterator
    println("扁平化=" + list2.flatMap(x => x)) //扁平化=List(1, 2, 3, 4, 5, 6) 集合中整体拆成一个个的 

    // TODO reduce 化简，折叠
    println(list.reduce((_ + _))) //10 两两聚合
    println(list.reduce(_ - _)) //-8
    println(list.reduceLeft(_ - _))//-8 同上，底层调用是一样的
    println(list.reduceRight(_ - _)) //-2 从右边开始计算

    val list: List[Int] = List(1,2,3,4)

// TODO fold fold和reduce比较类似，仅仅是多了一个集合之后的初始值
    println(list.fold(10)(_ - _)) // -0   底层本质上就是调用的foldLeft(z)(op)
 println(list.foldLeft(10)(_ - _)) //-0 

    // 1,2,3,4 ==> reverse ==> 4,3,2,1
    // 底层运算时，将集合反转后相邻的元素交互调用逻辑
    println(list.foldRight(0)(_ - _)) //-2
    //reverse.foldLeft(z)((right, left) => op(left, right))

    val lis1 = List(1,2,3,4)
    val lis2 = List(3,4,5,6,7)
    // 两个集合合并
    println(lis1.union(lis2)) //List(1, 2, 3, 4, 3, 4, 5, 6, 7)
    // 两个集合交集
    println(lis1.intersect(lis2)) //List(3, 4)
    // 两个集合差集
    println(lis2.diff(lis1)) //List(5, 6, 7)
    // 拉链
    println(lis1.zip(lis2)) //List((1,3), (2,4), (3,5), (4,6))

   // 滑动窗口window
    val intses: Iterator[List[Int]] = list.sliding(3)
    for (elem <- intses) {
      println(elem) //List(1, 2, 3)
                    //List(2, 3, 4)
    }

    // TODO 过滤
    val a = List(1, 2, 3, 4)
    def test(i: Int): Boolean = {
      i % 2 == 0
    }
    println("过滤=" + a.filter(test)) //简化如下
    println(a.filter(_ % 2 == 1))

object TestWorldCount {
  def main(args: Array[String]): Unit = {
    // 数据
    val lines = List("Hello Atguigu", "Hello Scala", "Hello Hbase", "Hi Atguigu")
    // 将一行的数据进行分解，变成一个一个的单词（扁平化）
    val words: List[String] = lines.flatMap(line => {line.split(" ")})
    // 将扁平化后的单词进行分组
    val groupNameToWordMap: Map[String, List[String]] = words.groupBy(word=>word)
    // 将分组后的数据转换为单词和数量的结构  _1是单词分组名称; t._2是集合
    val wordToCountMap: Map[String, Int] = groupNameToWordMap.map(t=>{(t._1, t._2.size)})
    // 将转换后的数据进行排序
    // map(k-v, k1-v1, k2-v2) ==> List((k,v), (k1,v1))
    val resultList: List[(String, Int)] = wordToCountMap.toList.sortWith {
      case (left, right) => {
        left._2 > right._2 //元组, 根据v去比较判断
      }
    }
---------------简化版-------------------------------
    val resultList: List[(String, Int)] = lines.flatMap(_.split(" ")).groupBy(word => word).map(t => {
      (t._1, t._2.size)
    }).toList.sortWith {
      case (left, right) => {
        left._2 > right._2
      }
    }
-----------------------------------------
    resultList

    resultList.foreach(println)
  }

}