文件读写—全文单词统计

一、从文件中读取内容

在scala中，涉及到文件读写的方法有很多，可以使用java.io下的工具包，也可以使用scala.io下的功能。

source.fromFile格式： scala.io.Source.formFile(文件名)

source.fromFile作用： 读入一个文件

def main(args: Array[String]): Unit = {
    // 1.读入test.txt的内容  大大的长长的字符串
    //   Source.fromFile().mkString
    // 2.对字符串进行拆分 把句子变成一个一个单词
    //   split
//    val obj = scala.io.Source.fromFile("./test.txt").mkString
//    println(obj)

    val content=scala.io.Source.fromFile("./test.txt").mkString
    println(content)

    // 2.对字符串进行拆分：使用空格，对这个长长的字符串做拆分
    val rst=content.split(' ')
    rst.foreach(println)
  }

二、写拆分单词统计个数

1. 分隔出一个一个的单词。

2. 建立一个Map,key是单词，value是次数。

3. 遍历所有的单词，对每个单词来说：

   判断单词是否存在，如果存在把对应的key+1;

   否则就设置对应的key，且value为1

def main(args: Array[String]): Unit = {
    // 1.读入test.txt的内容  大大的长长的字符串
    //   Source.fromFile().mkString
    // 2.对字符串进行拆分 把句子变成一个一个单词
    //   split
//    val obj = scala.io.Source.fromFile("./test.txt").mkString
//    println(obj)

    val content=scala.io.Source.fromFile("./test.txt").mkString
    println(content)

    // 2.对字符串进行拆分：使用空格，对这个长长的字符串做拆分（字符串split方法）
    val rst=content.split(' ')

    // 3.空的容器保存键值对数据：键：单词，值：次数
    val map =scala.collection.mutable.Map[String,Int]()
    rst.foreach(word => {
      if (map.contains(word)){
        // 如果word在map中存在，就把值+1
        map(word) += 1
      }
      else {
        // 如果word在map中不存在，将值设为1
        map(word)=1
      }
      println(word,map.contains(word))
    })
  }

三、对Map结果排序

Map本身是键值对，它是无序的。可以先转成List或者Seq，然后再排序。

{
  def main(args: Array[String]): Unit = {
    // 1.读入test.txt的内容  大大的长长的字符串
    //   Source.fromFile().mkString
    // 2.对字符串进行拆分 把句子变成一个一个单词
    //   split
//    val obj = scala.io.Source.fromFile("./test.txt").mkString
//    println(obj)

    val content=scala.io.Source.fromFile("./test.txt").mkString
    println(content)

    // 2.对字符串进行拆分：使用空格，对这个长长的字符串做拆分
    val rst=content.split(' ')

    // 3.空的容器保存键值对数据：键：单词，值：次数
    val map =scala.collection.mutable.Map[String,Int]()
    rst.foreach(word => {
      if (map.contains(word)){
        // 如果word在map中存在，就把值+1
        map(word) += 1
      }
      else {
        // 如果word在map中不存在，将值设为1
        map(word)=1
      }
      println(word,map.contains(word))
    })
//    // 4.排序
//    map.foreach(println)
    // 按照单词出现的频率，从高到低排序
    // map是无序的，不能做排序
    // list是可以排序的
    map.toList.sortBy(_._2).foreach(ele=>{
      println(ele._1,ele._2)
    })
  }

四、结果写入

使用java.io.PrintWriter写入文件
write:不会自动换行，可以加入\n； println：写入一行

def main(args: Array[String]): Unit = {
    // 1.读入test.txt的内容  大大的长长的字符串
    //   Source.fromFile().mkString
    // 2.对字符串进行拆分 把句子变成一个一个单词
    //   split
//    val obj = scala.io.Source.fromFile("./test.txt").mkString
//    println(obj)

    val content=scala.io.Source.fromFile("./test.txt").mkString
    println(content)

    // 2.对字符串进行拆分：使用空格，对这个长长的字符串做拆分
    val rst=content.split("\W+").map(ele=>ele.toLowerCase)

    // 3.空的容器保存键值对数据：键：单词，值：次数
    val map =scala.collection.mutable.Map[String,Int]()
    rst.foreach(word => {
      if (map.contains(word)){
        // 如果word在map中存在，就把值+1
        map(word) += 1
      }
      else {
        // 如果word在map中不存在，将值设为1
        map(word)=1
      }
//      println(word,map.contains(word))
    })
//    // 4.排序
//    map.foreach(println)

    // 按照单词出现的频率，从高到低排序
    // map是无序的，不能做排序
    // list是可以排序的
//    map.toList.sortBy(_._2).foreach(ele=>{
//      println(ele._1,ele._2)
//    })
    val wordLists=map.toList.sortBy(_._2).reverse

    // 5.把结果写入到文件中
    val writer=new FileWriter("result.txt")
    wordLists.foreach(ele=>{
      writer.write(s"${ele._1}: ${ele._2} \n")
    })
    writer.close()
  }