Scala版WordCount

object Demo12List {
  def main(args:Array[String]): Unit ={
    /**
     * List列表
     * 特点：元素可以重复、有序的、不可变的
     */
    //定义一个List
    val list1: List[Int] = List[Int](1, 2, 1, 2, 3, 5, 7, 3, 4, 6, 4, 9, 8)
    println(list1)

    //通过下标(index,索引)取元素
    println(list1(4))
    //list1(4)=10 //List不能修改

    //List中常用的方法
    println(list1.max)//最大值
    println(list1.min)//最小值
    println(list1.sum)//求和
    println(list1.head)//取第一个元素
    println(list1.tail)//取除第一个元素以外的元素
    println(list1.length)//长度 同size
    println(list1.take(3))//取前N个元素
    println(list1.distinct)//返回去重后结果
    println(list1.isEmpty)//判断是否为空
    println(list1.size)//大小 同length
    println(list1.reverse)//倒转List

    //List常见的操作
    /**
     * map 和 foreach
     * 区别：有无返回值
     * 都需要接收一个函数f
     * 都会将List中的每个元素传给函数f
     */
    //有返回值
    val newList1: List[Int] = list1.map(elem => elem * elem)
    println(newList1.mkString(","))

    //遍历
    list1.foreach(println)

    //过滤
    /**
     * filter方法：
     * 接收一个函数类型的参数p
     * p:Int=>Boolean
     * 函数p的参数类型为Int：因为list1中的每个元素的类型为Int
     * 函数p的返回值类型为Boolean
     * filter会根据函数p最后的返回值进行过滤
     * true: 保留数据
     * false: 将数据过滤
     */
    //将奇数过滤出来
    def filterList1(elem:Int): Boolean ={
      var flag:Boolean=false
     if(elem%2==1){
       flag=true
     }
      flag
    }

    //使用一般的函数
    val filterList: List[Int] = list1.filter(filterList1)
    println(filterList.mkString(","))

    //使用匿名函数
    val filterList2:List[Int]=list1.filter((elem:Int)=> {
      var flag: Boolean = false
      if (elem % 2 == 1) {
        flag=true
      }
      flag
    })
    println(filterList2.mkString(","))
    //简写
     println(list1.filter(elem => elem % 2==1).mkString(","))
    println(list1.filter(_%2==1).mkString(",")) //偶数
    println(list1.filter(_%2==0).mkString(",")) //奇数

    //groupBy 需要指定一个分组“字段”
    val zs: Stu = Stu("001", "zs", 20, "文科一班")
    val ls: Stu = Stu("002", "ls", 21, "文科二班")
    val ww: Stu = Stu("003", "ww", 22, "文科三班")
    val zl: Stu = Stu("004", "zl", 21, "理科二班")
    val lj: Stu = Stu("005", "lj", 20, "理科一班")

    val stuList: List[Stu] = List[Stu](zs, ls, ww, zl, lj)

    //按班级分组
    /**
     * 得到一个Map
     * Map的Key就是指定的分组“字段”表示每一组
     * Map的value就是经过分组过后属于同一组的元素一同构成的List
     */
    //    stuList.groupBy((stu:Stu)=>{stu.clazz})
    val groupStu: Map[String, List[Stu]] = stuList.groupBy(_.clazz)
    println(groupStu)

    groupStu.map((kv)=>{
      val clazz:String=kv._1
      val stus:List[Stu]=kv._2
      println("map处理逻辑")
      (clazz,stus.size)
    }).foreach(println)

    groupStu.map((kv:(String,List[Stu]))=>{
      (kv._1,kv._2.size)
    }).foreach(println)

    groupStu.map(kv=>(kv._1,kv._2.size)).foreach(println)

    /**
     * flatMap:接收一个函数f
     * 函数f：String=>GenTraversableOnce
     * String:因为List中每一个元素是String类型
     * GenTraversableOnce：所有可以遍历的类型
     * flatMap不仅会将List中的每个元素传给函数f处理
     * 并且会将函数f的返回值进行 扁平化处理（展开）
     */
    val lineList: List[String] = List[String]("hadoop,hive,hbase", "spark,flink", "python,java,MySQL")
    val list: List[Array[String]] = lineList.map(line => {
      val words: Array[String] = line.split(",")
      words
    })
    list.foreach(arr=>{
      arr.foreach(println)
    })

    val wordsList: List[String] = lineList.flatMap(line => {
      val words: Array[String] = line.split(",")
      words
    })
    wordsList.foreach(println)
    println(wordsList.length)
    //按照每个单词进行分组
    wordsList.
      groupBy(word=>word)
      .map(kv=>(kv._1,kv._2.size))
      .foreach(println)
  }

  case class Stu(id:String,name:String,age:Int,clazz:String)
}

 List(1, 2, 1, 2, 3, 5, 7, 3, 4, 6, 4, 9, 8)
3
9
1
55
1
List(2, 1, 2, 3, 5, 7, 3, 4, 6, 4, 9, 8)
13
List(1, 2, 1)
List(1, 2, 3, 5, 7, 4, 6, 9, 8)
false
13
List(8, 9, 4, 6, 4, 3, 7, 5, 3, 2, 1, 2, 1)
1,4,1,4,9,25,49,9,16,36,16,81,64
1
2
1
2
3
5
7
3
4
6
4
9
8
1,1,3,5,7,3,9
1,1,3,5,7,3,9
1,1,3,5,7,3,9
1,1,3,5,7,3,9
2,2,4,6,4,8
Map(理科一班 -> List(Stu(005,lj,20,理科一班)), 理科二班 -> List(Stu(004,zl,21,理科二班)), 文科一班 -> List(Stu(001,zs,20,文科一班)), 文科二班 -> List(Stu(002,ls,21,文科二班)), 文科三班 -> List(Stu(003,ww,22,文科三班)))
map处理逻辑
map处理逻辑
map处理逻辑
map处理逻辑
map处理逻辑
(理科一班,1)
(理科二班,1)
(文科一班,1)
(文科二班,1)
(文科三班,1)
(理科一班,1)
(理科二班,1)
(文科一班,1)
(文科二班,1)
(文科三班,1)
(理科一班,1)
(理科二班,1)
(文科一班,1)
(文科二班,1)
(文科三班,1)
hadoop
hive
hbase
spark
flink
python
java
MySQL
hadoop
hive
hbase
spark
flink
python
java
MySQL
8
(java,1)
(flink,1)
(hadoop,1)
(spark,1)
(hive,1)
(python,1)
(MySQL,1)
(hbase,1)

import scala.collection.immutable
import scala.io.{BufferedSource, Source}

object Demo13WordCountScala {
  def main(args: Array[String]): Unit = {
    //使用函数式编程的思想完成WordCount
    /**
     * 提示：使用flatMap方法可以将每行数据切分后的结果进行展开
     */

    //1、读文件
    val bs: BufferedSource = Source
      .fromFile("Scala/data/words.txt")

    val lines: List[String] = bs.getLines().toList

    //2、按照“,"切分 将每一行所有的单词 变成一列
    val words: List[String] = lines.flatMap(line => line.split(","))

    //3、进行分组
    val groupWords: Map[String, List[String]] = words.groupBy(word => word)

    //4、统计每个单词的数量
    val wordCnt: immutable.Iterable[String] = groupWords.map(kv => kv._1 + "," + kv._2.size)

    //5、打印
    wordCnt.foreach(println)

    //链式调用
    Source
      .fromFile("Scala/data/words.txt")
      .getLines()
      .toList
      .flatMap(_.split(","))
      .groupBy(word=>word)
      .map(kv => kv._1 + "," + kv._2.size)
      .foreach(println)
  }
}

hadoop,10
spark,10
java,20

hadoop,10
spark,10
java,20