集合计算高级函数

一、集合计算高级函数

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 zpark", "hello scala")

//（1）过滤

println(list.filter(x => x % 2 == 0))

//（2）转化/映射println(list.map(x => x + 1))

//（3）扁平化println(nestedList.flatten)

//（4）扁平化+映射 注：flatMap 相当于先进行 map 操作，在进行 flatten

操作

println(wordList.flatMap(x => x.split(" ")))

//（5）分组

println(list.groupBy(x => x % 2))

}

}

3）educe 方法

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

案例实操

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)

}

}

4）Fold 方法

Fold 折叠：化简的一种特殊情况。

（1）案例实操：fold 基本使用

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)

}

}

（2）案例实操：两个集合合并

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）需求

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

3）案例实操

object TestWordCount {

def main(args: Array[String]): Unit = {

// 单词计数：将集合中出现的相同的单词，进行计数，取计数排名前三的结

果

val stringList = List("Hello Scala Hbase kafka", "Hello Scala Hbase", "Hello Scala", "Hello")

// 1) 将每一个字符串转换成一个一个单词

val wordList: List[String] = stringList.flatMap(str=>str.split(" "))

//println(wordList)

// 2) 将相同的单词放置在一起

val wordToWordsMap: Map[String, List[String]] = wordList.groupBy(word=>word)

//println(wordToWordsMap)

// 3) 对相同的单词进行计数

// (word, list) => (word, count)

val wordToCountMap: Map[String, Int] = wordToWordsMap.map(tuple=>(tuple._1, tuple._2.size))

// 4) 对计数完成后的结果进行排序（降序）

val sortList: List[(String, Int)] = wordToCountMap.toList.sortWith {

(left, right) => { left._2 > right._2

}

}

// 5) 对排序后的结果取前 3 名

val resultList: List[(String, Int)] = sortList.take(3)

println(resultList)

}

}