基本属性和常用操作

说明

（1）获取集合长度
（2）获取集合大小
（3）循环遍历
（4）迭代器
（5）生成字符串
（6）是否包含

案例实操 ```scala object TestList { def main(args: Array[String]): Unit = { val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7)

//获取集合长度 println(list.length)

//获取集合大小,等同于length println(list.size)

//循环遍历 list.foreach(println)

//迭代器 for (elem <- list.itera tor) { println(elem) }

//生成字符串 println(list.mkString(“,”))

//是否包含 println(list.contains(3)) } }

<a name="tCn4b"></a>
# 衍生集合
1.说明<br />（1）获取集合的头<br />（2）获取集合的尾（不是头的就是尾）<br />（3）集合最后一个数据<br />（4）集合初始数据（不包含最后一个）<br />（5）反转<br />（6）取前（后）n个元素<br />（7）去掉前（后）n个元素<br />（8）并集<br />（9）交集<br />（10）差集<br />（11）拉链<br />（12）滑窗
2. **案例实操**
```scala
object TestList {
  def main(args: Array[String]): Unit = {
    val list1: List[Int] = List(1, 2, 3, 4, 5, 6, 7)
    val list2: List[Int] = List(4, 5, 6, 7, 8, 9, 10)
    //获取集合的头
    println(list1.head)
    //获取集合的尾（不是头的就是尾）
    println(list1.tail)
    //集合最后一个数据
    println(list1.last)
    //集合初始数据（不包含最后一个）
    println(list1.init)
    //反转
    println(list1.reverse)
    //取前（后）n个元素
    println(list1.take(3))
    println(list1.takeRight(3))
    //去掉前（后）n个元素
    println(list1.drop(3))
    println(list1.dropRight(3))
    //并集
    println(list1.union(list2))
    //交集
    println(list1.intersect(list2))
    //差集
    println(list1.diff(list2))
    //拉链 注:如果两个集合的元素个数不相等，那么会将同等数量的数据进行拉链，多余的数据省略不用
    println(list1.zip(list2))
    //滑窗
    list1.sliding(2, 5).foreach(println)
  }
}

集合计算初级函数

说明

（1）求和
（2）求乘积
（3）最大值
（4）最小值
（5）排序

案例实操 ```scala object TestList { def main(args: Array[String]): Unit = { val list: List[Int] = List(1, 5, -3, 4, 2, -7, 6)

//求和 println(list.sum)

//求乘积 println(list.product)

//最大值 println(list.max)

//最小值 println(list.min)

//排序 //按照元素大小排序 println(list.sortBy(x => x))

//按照元素的绝对值大小排序 println(list.sortBy(x => x.abs))

//按元素大小升序排序 println(list.sortWith((x, y) => x < y))

//按元素大小降序排序 println(list.sortWith((x, y) => x > y)) } }

（1）sorted<br />对一个集合进行自然排序，通过传递隐式的Ordering<br />（2）sortBy<br />对一个属性或多个属性进行排序，通过它的类型<br />（3）sortWith<br />基于函数的排序，通过一个comparator函数，实现自定义排序的逻辑
<a name="OWn8y"></a>
# 集合计算高级函数
1.说明<br />（1）过滤：遍历一个集合并从中获取满足指定条件的元素组成一个新的集合<br />（2）转化/映射（map）：将集合中的每一个元素映射到某一个函数<br />（3）扁平化<br />（4）扁平化+映射 注：flatMap相当于先进行map操作，在进行flatten操作，集合中的每个元素的子元素映射到某个函数并返回新集合<br />（5）分组(group) ：按照指定的规则对集合的元素进行分组<br />（6）简化（归约）<br />（7）折叠<br />**2.案例实操**
```scala
object TestList {
  def main(args: Array[String]): Unit = {
    val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
    val nestedList: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
    val wordList: List[String] = List("hello world", "hello atguigu", "hello scala")
    //过滤
    println(list.filter(x => x % 2 == 0))
    //转化/映射
    println(list.map(x => x + 1))
    //扁平化
    println(nestedList.flatten)
    //扁平化+映射 注：flatMap相当于先进行map操作，在进行flatten操作
    println(wordList.flatMap(x => x.split(" ")))
    //分组
    println(list.groupBy(x => x % 2))
  }
}

输出结果：
List(2, 4, 6, 8)
List(2, 3, 4, 5, 6, 7, 8, 9, 10)
List(1, 2, 3, 4, 5, 6, 7, 8, 9)
List(hello, world, hello, atguigu, hello, scala)
Map(1 -> List(1, 3, 5, 7, 9), 0 -> List(2, 4, 6, 8))

Reduce方法

Reduce简化（归约）：通过指定的逻辑将集合中的数据进行聚合，从而减少数据，最终获取结果。

案例实操 ```scala object TestReduce { def main(args: Array[String]): Unit = { val list = List(1,2,3,4)

//将数据两两结合，实现运算规则 val i: Int = list.reduce( (x,y) => x-y ) println(“i = “ + i)

//从源码的角度，reduce底层调用的其实就是reduceLeft //val i1 = list.reduceLeft((x,y) => x-y)

//((4-3)-2-1) = -2 val i2 = list.reduceRight((x,y) => x-y) println(i2) } }

<br />**5.Fold方法**<br />Fold折叠：化简的一种特殊情况<br />**6.案例实操**<br />fold基本使用
```scala
object TestFold {
  def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3, 4)
    //fold方法使用了函数柯里化，存在两个参数列表
    //第一个参数列表为：零值（初始值）
    //第二个参数列表为：简化规则
    //fold底层其实为foldLeft
    val i = list.foldLeft(1)((x, y) => x - y)
    val i1 = list.foldRight(10)((x, y) => x - y)
    println(i)
    println(i1)
  }
}

两个集合合并

object TestFold {
  def main(args: Array[String]): Unit = {
    //两个Map的数据合并
    val map1 = mutable.Map("a" -> 1, "b" -> 2, "c" -> 3)
    val map2 = mutable.Map("a" -> 4, "b" -> 5, "d" -> 6)
    val map3: mutable.Map[String, Int] = map2.foldLeft(map1) {
      (map, kv) => {
        val k = kv._1
        val v = kv._2
        map(k) = map.getOrElse(k, 0) + v
        map
      }
    }
    println(map3)
  }
}

普通WordCount例子

1.需求
单词计数：将集合中出现的相同的单词，进行计数，取计数排名前三的结果

2.需求分析

案例实操 ```scala object TestWordCount { def main(args: Array[String]): Unit = { //单词计数：将集合中出现的相同的单词，进行计数，取计数排名前三的结果 val stringList = List(“Hello Scala Hbase kafka”, “Hello Scala Hbase”, “Hello Scala”, “Hello”)

//将每一个字符串转换成一个一个单词 val wordList: List[String] = stringList.flatMap(str => str.split(“ “)) //println(wordList)

//将相同的单词放置在一起 val wordToWordsMap: Map[String, List[String]] = wordList.groupBy(word => word) //println(wordToWordsMap)

//对相同的单词进行计数 //(word, list) => (word, count) val wordToCountMap: Map[String, Int] = wordToWordsMap.map(tuple => (tuple._1, tuple._2.size))

//对计数完成后的结果进行排序（降序） val sortList: List[(String, Int)] = wordToCountMap.toList.sortWith { (left, right) => {
```
 left._2 > right._2
```
} }

//对排序后的结果取前3名 val resultList: List[(String, Int)] = sortList.take(3) println(resultList) } }

<a name="O8ymz"></a>
# 复杂WordCount例子
1. **方式一**
```scala
object TestWordCount {
  def main(args: Array[String]): Unit = {
    //第一种方式（不通用）
    val tupleList = List(("Hello Scala Spark World ", 4), ("Hello Scala Spark", 3), ("Hello Scala", 2), ("Hello", 1))
    val stringList: List[String] = tupleList.map(t => (t._1 + " ") * t._2)
    //val words: List[String] = stringList.flatMap(s=>s.split(" "))
    val words: List[String] = stringList.flatMap(_.split(" "))
    //在map中，如果传进来什么就返回什么，不要用_省略
    val groupMap: Map[String, List[String]] = words.groupBy(word => word)
    //val groupMap: Map[String, List[String]] = words.groupBy(_)
    //(word, list) => (word, count)
    val wordToCount: Map[String, Int] = groupMap.map(t => (t._1, t._2.size))
    val wordCountList: List[(String, Int)] = wordToCount.toList.sortWith {
      (left, right) => {
        left._2 > right._2
      }
    }.take(3)
    //tupleList.map(t=>(t._1 + " ") * t._2).flatMap(_.split(" ")).groupBy(word=>word).map(t=>(t._1, t._2.size))
    println(wordCountList)
  }
}

2.方式二

object TestWordCount {
  def main(args: Array[String]): Unit = {
    val tuples = List(("Hello Scala Spark World", 4), ("Hello Scala Spark", 3), ("Hello Scala", 2), ("Hello", 1))
    //(Hello,4),(Scala,4),(Spark,4),(World,4)
    //(Hello,3),(Scala,3),(Spark,3)
    //(Hello,2),(Scala,2)
    //(Hello,1)
    val wordToCountList: List[(String, Int)] = tuples.flatMap {
      t => {
        val strings: Array[String] = t._1.split(" ")
        strings.map(word => (word, t._2))
      }
    }
    //Hello, List((Hello,4), (Hello,3), (Hello,2), (Hello,1))
    //Scala, List((Scala,4), (Scala,3), (Scala,2)
    //Spark, List((Spark,4), (Spark,3)
    //Word, List((Word,4))
    val wordToTupleMap: Map[String, List[(String, Int)]] = wordToCountList.groupBy(t => t._1)
    val stringToInts: Map[String, List[Int]] = wordToTupleMap.mapValues {
      datas => datas.map(t => t._2)
    }
    stringToInts
    /*
    val wordToCountMap: Map[String, List[Int]] = wordToTupleMap.map {
        t => {
            (t._1, t._2.map(t1 => t1._2))
        }
    }
    val wordToTotalCountMap: Map[String, Int] = wordToCountMap.map(t=>(t._1, t._2.sum))
    println(wordToTotalCountMap)
    */
  }
}

集合常用函数

基本属性和常用操作

集合计算初级函数

普通WordCount例子