第10章 实战：文件、JSON 与并发

import scala.io.Source
import scala.util.Using
import java.nio.charset.StandardCharsets
import java.nio.file.Files

object SourceDemo {
  def main(args: Array[String]): Unit = {
    val path = Files.createTempFile("scores", ".csv")
    Files.write(path, "张三,90\n李四,85\n王五,78\n".getBytes(StandardCharsets.UTF_8))

    Using.resource(Source.fromFile(path.toFile, "UTF-8")) { src =>
      src.getLines().foreach(line => println(s"读到：$line"))
    }

    Using(Source.fromFile(path.toFile, "UTF-8")) { src =>
      src.getLines().toList
    } match {
      case scala.util.Success(lines) => println(s"共 ${lines.size} 行")
      case scala.util.Failure(e) => println(s"读取失败：${e.getMessage}")
    }

    Files.deleteIfExists(path)
  }
}

import java.nio.charset.StandardCharsets
import java.nio.file.{Files, Paths}
import scala.jdk.CollectionConverters._

object NioReport {
  def main(args: Array[String]): Unit = {
    val path = Paths.get("report-tmp.csv")
    val lines = List("一班,张三,90", "一班,李四,80", "二班,王五,70")
    Files.write(path, lines.asJava, StandardCharsets.UTF_8)

    val readBack = Files.readAllLines(path, StandardCharsets.UTF_8).asScala.toList
    val scores = readBack.flatMap { line =>
      line.split(",", -1).toList match {
        case cls :: name :: score :: Nil =>
          score.toIntOption.map(n => (cls, name, n))
        case _ => None
      }
    }

    scores.groupBy(_._1).toList.sortBy(_._1).foreach { case (cls, rows) =>
      val avg = rows.map(_._3).sum.toDouble / rows.size
      println(f"$cls：${rows.map(_._2).mkString("、")}，平均 $avg%.1f")
    }

    Files.deleteIfExists(path)
  }
}

import ujson._

object JsonReport {
  def main(args: Array[String]): Unit = {
    val raw =
      """[
        |  {"name":"张三","score":90,"class":"一班"},
        |  {"name":"李四","score":76,"class":"一班"},
        |  {"name":"王五","score":88,"class":"二班"},
        |  {"name":"赵六","score":59,"class":"二班"}
        |]""".stripMargin

    val rows = read(raw).arr.toList.map { o =>
      (o("class").str, o("name").str, o("score").num.toInt)
    }

    rows.groupBy(_._1).toList.sortBy(_._1).foreach { case (cls, xs) =>
      val avg = xs.map(_._3).sum.toDouble / xs.size
      println(f"$cls 人数=${xs.size} 平均分=$avg%.1f")
    }

    rows.sortBy(r => -r._3).take(1).foreach { case (_, name, score) =>
      println(s"最高分：$name $score")
    }
  }
}

object JsonRegexReport {
  val Row = """\{"name":"([^"]+)","score":(\d+),"class":"([^"]+)"\}""".r

  def main(args: Array[String]): Unit = {
    val raw =
      """[
        |  {"name":"张三","score":90,"class":"一班"},
        |  {"name":"李四","score":76,"class":"一班"},
        |  {"name":"王五","score":88,"class":"二班"},
        |  {"name":"赵六","score":59,"class":"二班"}
        |]""".stripMargin

    val rows = Row.findAllMatchIn(raw).map { m =>
      (m.group(3), m.group(1), m.group(2).toInt)
    }.toList

    println(s"解析到 ${rows.size} 条")
    rows.sortBy(r => (-r._3, r._2)).take(2).foreach { case (cls, name, score) =>
      println(s"$cls $name $score")
    }
  }
}

import scala.concurrent.{Await, Future}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

object FutureBasic {
  def square(n: Int): Future[Int] = Future {
    Thread.sleep(100)
    n * n
  }

  def main(args: Array[String]): Unit = {
    val fs: List[Future[Int]] = (1 to 4).toList.map(square)
    val all: List[Int] = Await.result(Future.sequence(fs), 3.seconds)
    println(all)
    println(s"总和=${all.sum}")

    val one = Future { 21 * 2 }
    println(s"单个结果=${Await.result(one, 1.second)}")
  }
}

import scala.concurrent.{Await, Future}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

object MiniProject {
  final case class Row(cls: String, name: String, score: Int)

  def scoreReport(rows: List[Row]): String = {
    val lines = rows.groupBy(_.cls).toList.sortBy(_._1).map { case (cls, xs) =>
      val avg = xs.map(_.score).sum.toDouble / xs.size
      f"$cls 平均=$avg%.1f 最高=${xs.maxBy(_.score).name}"
    }
    lines.mkString("\n")
  }

  def wordFreq(text: String): List[(String, Int)] =
    text.toLowerCase
      .split("[^a-z]+")
      .filter(_.nonEmpty)
      .groupBy(word => word)
      .view.mapValues(_.length)
      .toList
      .sortBy { case (w, c) => (-c, w) }

  def main(args: Array[String]): Unit = {
    val rows = List(
      Row("一班", "张三", 90), Row("一班", "李四", 80),
      Row("二班", "王五", 70), Row("二班", "赵六", 95)
    )
    val text = "Scala is fun, fun scala is fast. Spark uses Scala!"

    val reportF = Future(scoreReport(rows))
    val freqF = Future(wordFreq(text))
    val (report, freq) = Await.result(reportF.zip(freqF), 3.seconds)

    println("== 成绩分析 ==")
    println(report)
    println("== 词频 Top3 ==")
    freq.take(3).foreach { case (w, c) => println(s"$w: $c") }
  }
}