scala-集合3 - 技术栈

集合计算高级函数

过滤：遍历一个集合并从中获取满足指定条件的元素组成一个新的集合

（筛选出满足条件的元素组成新集合。）

转换或映射（map）：将原始集合中的元素映射到某个函数。

扁平化：取消嵌套格式，将嵌套元素和外层元素放在一起。

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

++（先进行映射操作，再进行扁平化操作。）++

集合中的每个元素的子元素映射到某个函数并返回新集合

分组（group）：按照指定规则对集合元素进行分组。

简化（归约）和折叠：通过指定逻辑聚合数据，减小数据量。

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

        //（1）过滤     筛选出偶数元素。
        println(list.filter(x => x % 2 == 0))

        //（2）转化/映射      将1到9的数字每个加1，变成2-10
        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))
    }
}

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)
    }
}

Fold 方法

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

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)
    }
}

两个集合合并 (合并两个map，累加相同键的值。)

Scala 复制代码

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案例

需求

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

(通过分割字符串、分组、求大小、排序等步骤实现频次计算)

Scala 复制代码

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 {
            case (left, right) => left._2 > right._2
        }

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