scala代码-02

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

        // TODO Scala - 小练习 - WordCount
        // TODO 需求 ： 统计单词出现的次数，并且按照次数的大小取前3名
        // TODO 1. 准备数据
        val list : List[String] = List(
            "Hello Scala Spark Flink",
            "Hello Scala Spark",
            "Hello Scala",
            "Hello"
        )

        // TODO 2. 将数据拆成一个一个单词（分词）(flatMap)
        // string => word
        // flatMap可以将数据变得多一些
        val words : List[String] = list.flatMap(
            str => {
   
                str.split(" ")
            }
        )

        // TODO 3. 将相同的单词放置在一个组中，方便统计(groupBy)
        // word => Map(  word -> (word, word, word) )
        val groupWordMap: Map[String, List[String]] = words.groupBy(word=>word)

        // TODO 4. 将分组后的数据进行结构的转换(map)
        // (word, list) =>（word, count)
        val wordToCountMap: Map[String, Int] = groupWordMap.map(
            kv => {
   
                (kv._1, kv._2.size)
            }
        )

        //println(wordToCountMap)

        // TODO 5. 将统计后的结果按照count进行排序(sort)(降序)
        val wordToCountList: List[(String, Int)] = wordToCountMap.toList
        val sortList: List[(String, Int)] = wordToCountList.sortBy(kv=>kv._2)(Ordering.Int.reverse)

        // TODO 6. 将排序后的结果取前3名。(take)
        val top3List: List[(String, Int)] = sortList.take(3)

        // TODO 7. 将结果打印在控制台(foreach)
        top3List.foreach(println)

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

        val list : List[String] = List(
            "Hello Scala Spark Flink",
            "Hello Scala Spark",
            "Hello Scala",
            "Hello"
        )

        list
            .flatMap(_.split(" "))
            .groupBy(word=>word)
            .map(
                kv => {
   
                    (kv._1, kv._2.size)
                }
            )
            .toList
            .sortBy(_._2)(Ordering.Int.reverse)
            .take(3)
            .foreach(println)

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

//        val list : List[String] = List(
//            "Hello Scala Spark Flink",
//            "Hello Scala Spark",
//            "Hello Scala",
//            "Hello"
//        )

        // TODO 下划线使用的问题
        //   1. 在匿名函数中，下划线主要用于简化函数参数的使用
        //      “能”省则省
        //   2. 在匿名函数中，如果函数的参数只“使用”了一次。可以使用下划线来代替参数
        //   3. 下划线可以将函数作为整体来使用， 所以在使用过程中，如果函数传递的参数不做处理，直接返回
        //      那么这种情况下，是不能使用下划线代替
        //   4. 下划线代替参数，是要严格按照参数的顺序使用
        //      (x, y) => y + x => _+_ (X)
        //   5. 下划线的逻辑操作不要放置在内部函数的传参上
        //   6. 下划线的简化操作主要用于简单逻辑，如果复杂逻辑不要简化

        val list1 = List(1,2,3,4)

        //list1.foreach((num:Int)=>{println(num)})
        //list1.foreach((num:Int)=>println(num))
        //list1.foreach((num)=>println(num))
        //list1.foreach(num=>println(num))
        //list1.foreach(println(_))
        // ******************************************
        def test( num:Int ): Unit = {
   
            println(num)
        }

        list1.foreach(test _)
        list1.foreach(test)


//        list
//            //TODO
//            // .flatMap( word => { word.split(" ") } )
//            .flatMap(_.split(" "))
//            // TODO
//            //   .groupBy(_) (X)
//            .groupBy(word=>word)
//            .map(
//                kv => {
   
//                    (kv._1, kv._2.size)
//                }
//            )
//            .toList
//            .sortBy(_._2)(Ordering.Int.reverse)
//            .take(3)
//            .foreach(println)

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

        // TODO Scala - 集合 - 计算函数
        val list = List(1,2,3,4)

        // TODO 想要对集合中的数据进行计算，但是计算的逻辑不确定?
        //      一般情况下，计算都应该产生计算结果。
        //      List => map => Result (X)
        //      List => filter => Result (X)
        //      List（N） => 简化，规约（reduce） => Result(1)
        // TODO Reduce方法的表示数据处理的规则
        //      为了使用方便，所有scala集合中数据处理基本上都是两两操作
//        val result: Int = list.reduce(
//            (x:Int, y:Int) => {
   
//                x * y
//            }
//        )

        //val result: Int = list.reduce((x:Int, y:Int) => {x * y})
        //val result: Int = list.reduce((x:Int, y:Int) =>x * y)
        //val result: Int = list.reduce((x, y) =>x * y)
        val result: Int = list.reduce(_ * _)
        println(result)

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

        // TODO Scala - 集合 - 计算函数
        val list = List(1,2,3,4,5)

        // TODO reduce 方法要求计算时参数类型和结果类型保持一致
        //      reduce方法的底层其实就是reduceLeft
        // (A1, A1) => A1
        //list.reduce()
        // TODO reduceLeft方法要求第一个参数和结果的参数类型保持一致，第二个参数就是当前集合数据的类型
        //      第一个参数类型和第二个参数类型之间有关系。
        // [B >: Int]
        // (B, Int) => B
        // TODO 当处理的数据类型一致时，那么reduce可以代替reduceLeft

        // 1, 2, 3, 4, 5
        //  -1  3
        //    -4   4
        //      -8  5
        //       -13

        //val result1 = list.reduceLeft(_-_)
        //println(result1) // -13
        // (Int, B) => B
        // TODO reduceLeft是将集合中的数据从左边两两计算
        // TODO reduceRight是将集合中的数据从右边两两计算

        // 1, 2, 3, 4, 5
        // reversed.reduceLeft[B]((x, y) => op(y, x))
        // TODO reduceRight实现原理
        //   1. 集合数据反转
        //        5, 4, 3, 2, 1
        //   2. 调用reduceLeft
        //          5, 4
        //   3. 两两计算时，会交换参数的顺序
        //           5, 4 => 4, 5 => -1
        //          -1, 3 => 3, -1 => 4
        //           4, 2 => 2, 4 => -2
        //          -2, 1 => 1, -2 => 3
         val result2: Int = list.reduceRight(_-_)
        println(result2) // 3

        // TODO 如何分析reduceLeft, reduceRight的计算结果?
        //      采用加括号的方式即可
        //  reduceLeft ： 从左边两两加括号
        //  ((((1，2)，3)，4)，5) => _-_ => -13
        //  reduceRight ： 从右边两两加括号
        //  (1，(2，(3，(4，5)))) => _-_ => 3

        //val s = new String("abc")
        //s.intern()

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

        // TODO Scala - 集合 - 计算函数
        val list = List(1,2,3,4)

        // reduce, reduceLeft, reduceRight 集合内部数据的聚合
        // 但是在某些情况下，需要将集合之外的数据和集合内部的数据进行聚合
        // 所以reduce, reduceLeft, reduceRight这些方法不太适用，可以采用折叠的方式来实现。
        // fold
        // 折叠的方法其实就是将集合之外的数据和集合内部的数据进行两两计算
        // 所以集合之外的数据称之为zero（初始值）

        // fold方法底层调用的其实就是foldLeft
        // fold, foldLeft其实是将初始值作为x使用, 放置在集合的左边
        val i: Int = list.fold(10)(_-_)
        val j: Int = list.foldLeft(10)(_-_)
        // reversed.foldLeft(z)((x, y) => op(y, x))
        // 1, 2, 3, 4
        // 5, 4, 3, 2, 1
        // (1, (2, (3, (4, 10))))
        // foldRight其实是将初始值作为y使用, 放置在集合的右边
        val k: Int = list.foldRight(10)(_-_)
        println(i + "," + j + ", " + k)

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

        // TODO Scala - 集合 - 计算函数
        val list = List(1,2,3,4)

        // Scala scan方法和fold方法很类似。
        // fold方法会将集合的数据最终聚合成一个结果
        val i: Int = list.fold(0)(_+_)
        // scan方法会将每一次的计算结果保存下来，形成计算结果的集合
        val ints: List[Int] = list.scan(0)(_+_)
        // scanLeft方法和foldLeft方法很类似。
        val ints1: List[Int] = list.scanLeft(0)(_-_)
        // scanRight方法和foldRight方法很类似。
        // 1, 2, 3, 4, 0
        val ints2 = list.scanRight(0)(_-_)
        println(ints2)

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

        // TODO Scala - 两个Map集合的合并
        val A = mutable.Map( "a"->1, "b"->2, "c"->3 )
        val B = mutable.Map( "a"->4, "d"->5, "c"->6 )

        B.foreach(
            kv => {
   
                val key = kv._1
                val bvalue = kv._2

                val avalue = A.getOrElse(key, 0)
                A.update(key, avalue + bvalue)
            }
        )

        println(A)


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

        // TODO Scala - 两个Map集合的合并
        val A = mutable.Map( "a"->1, "b"->2, "c"->3 )
        val B = mutable.Map( "a"->4, "d"-