Scala 基础教程

object Hello {
  def main(args: Array[String]): Unit = {
    println("Hello, Scala!")
    println("Scala 融合面向对象与函数式")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val name = "Scala"
    var version = 3.3
    version = 3.4

    println(s"语言：$name")
    println(s"版本：$version")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val count: Int = 42
    val price: Double = 59.9
    val isActive: Boolean = true
    val name: String = "Scala"

    println(s"计数：$count")
    println(f"价格：$price%.2f")
    println(s"名称：$name，大写：${name.toUpperCase}")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    print("请输入一个整数：")
    val input = scala.io.StdIn.readLine()
    input.toIntOption match {
      case Some(n) => println(s"$n 的平方是 ${n * n}")
      case None    => println("输入无效")
    }
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val a = 17
    val b = 5
    println(s"和：${a + b}")
    println(s"差：${a - b}")
    println(s"积：${a * b}")
    println(s"整除商：${a / b}")
    println(s"余数：${a % b}")
    println(s"2 的 10 次方：${math.pow(2, 10).toInt}")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val r = 7.5
    val circumference = 2 * math.Pi * r
    val area = math.Pi * r * r
    println(f"周长：$circumference%.4f")
    println(f"面积：$area%.4f")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val a = 8
    val b = 12
    println(s"a > b：${a > b}")
    println(s"a != b：${a != b}")
    println(s"a<10 && b>10：${a < 10 && b > 10}")
    println(s"!(a == 8)：${!(a == 8)}")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val s = "42"
    val n = s.toInt + 8
    println(s"转换加 8：$n")

    val bad: Option[Int] = "abc".toIntOption
    println(s"非法转换：$bad")
    println(s"兜底值：${bad.getOrElse(-1)}")

    val d = 3.7
    println(s"3.7 转 Int：${d.toInt}")
    println(s"Int 转 Double：${n.toDouble}")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val score = 85
    if (score >= 90) {
      println("优秀")
    } else if (score >= 80) {
      println("良好")
    } else if (score >= 60) {
      println("及格")
    } else {
      println("不及格")
    }
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val day = 4
    val name = day match {
      case 1 => "星期一"
      case 2 => "星期二"
      case 3 => "星期三"
      case 4 => "星期四"
      case 5 => "星期五"
      case 6 => "星期六"
      case 7 => "星期日"
      case _ => "无效输入"
    }
    println(s"$day -> $name")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val n = 15
    val parity = if (n % 2 == 0) "偶数" else "奇数"
    println(s"$n 是$parity")

    val score = 85
    val grade = if (score >= 90) "优秀"
                else if (score >= 60) "及格"
                else "不及格"
    println(s"$score 分：$grade")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    def describe(x: Any): String = x match {
      case i: Int if i > 100 => s"大整数 $i"
      case i: Int            => s"整数 $i"
      case s: String         => s"字符串「$s」长度 ${s.length}"
      case _                 => "其他类型"
    }

    println(describe(200))
    println(describe(42))
    println(describe("hello"))
    println(describe(3.14))
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    var sum = 0
    for (i <- 1 to 100) {
      sum += i
    }
    println(s"1 到 100 的和：$sum")

    val sum2 = (1 to 100).sum
    println(s"range.sum：$sum2")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 9) {
      var row = ""
      for (j <- 1 to i) {
        row += s"${j}x$i=${i * j}  "
      }
      println(row)
    }
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val doubled = for (i <- 1 to 10) yield i * 2
    println(s"翻倍：$doubled")

    val evenSquares = for {
      i <- 1 to 10
      if i % 2 == 0
    } yield i * i
    println(s"偶数平方：$evenSquares")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    var i = 1
    while (i <= 20) {
      if (i == 15) i = 21  // 模拟 break
      else if (i % 3 == 0) println(i)
      i += 1
    }

    val nums = (1 to 20).filter(_ % 3 == 0).takeWhile(_ < 15)
    println(s"函数式写法：$nums")
  }
}

object Demo {
  def add(a: Int, b: Int): Int = {
    a + b
  }

  def main(args: Array[String]): Unit = {
    println(s"add(10, 20) = ${add(10, 20)}")
    println(s"add(3, 7) = ${add(3, 7)}")
  }
}

object Demo {
  def greet(name: String, greeting: String = "你好"): String = {
    s"$greeting，$name！"
  }

  def main(args: Array[String]): Unit = {
    println(greet("小明"))
    println(greet("小红", "早上好"))
    println(greet(greeting = "欢迎", name = "小刚"))
  }
}

object Demo {
  def applyTwice(x: Int, op: Int => Int): Int = {
    op(op(x))
  }

  def main(args: Array[String]): Unit = {
    val double: Int => Int = x => x * 2
    println(s"翻倍两次：${applyTwice(3, double)}")

    val nums = List(1, 2, 3, 4, 5, 6)
    val evenSquares = nums.filter(x => x % 2 == 0).map(x => x * x)
    println(s"偶数平方：$evenSquares")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val addOne: Int => Int = _ + 1
    val multiply: (Int, Int) => Int = _ * _

    println(s"addOne(5) = ${addOne(5)}")
    println(s"multiply(3, 4) = ${multiply(3, 4)}")

    val nums = List(1, 2, 3, 4)
    println(s"map _ * 2：${nums.map(_ * 2)}")
    println(s"filter _ % 2 == 0：${nums.filter(_ % 2 == 0)}")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val nums = List(12, 45, 7, 89, 33)
    val nums2 = nums :+ 60
    println(s"原列表：$nums")
    println(s"添加后：$nums2")
    println(s"大小：${nums2.size}")
    println(s"最大值：${nums2.max}")
    println(s"排序：${nums2.sorted}")
    println(s"反转：${nums2.reverse}")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4, 5, 6)
    println(s"翻倍：${nums.map(_ * 2)}")
    println(s"偶数：${nums.filter(_ % 2 == 0)}")
    println(s"总和：${nums.sum}")
    println(s"乘积：${nums.reduce(_ * _)}")
    println(s"foldLeft 带初始：${nums.foldLeft(100)(_ + _)}")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val nums = List(3, 1, 4, 1, 5, 9, 2, 6)
    val unique = nums.toSet
    println(s"去重：$unique")

    val a = Set(1, 2, 3, 4)
    val b = Set(3, 4, 5, 6)
    println(s"交集：${a.intersect(b)}")
    println(s"并集：${a.union(b)}")
    println(s"差集：${a.diff(b)}")

    val ages = Map("张三" -> 20, "李四" -> 22)
    ages.foreach { case (name, age) => println(s"$name：$age 岁") }
    println(s"张三年龄：${ages.getOrElse("张三", 0)}")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val scores = List(55, 90, 72, 88, 45, 98)

    val groups = scores.groupBy(s => if (s >= 60) "及格" else "不及格")
    groups.foreach { case (k, v) => println(s"$k：${v.size} 人") }

    val top3 = scores.sorted(Ordering.Int.reverse).take(3)
    println(s"前三：$top3")

    val total = scores.sum
    println(f"总分：$total，平均：${total.toDouble / scores.size}%.1f")
  }
}

class Student(val name: String, var score: Double) {
  def info: String = s"$name，成绩 $score 分"
}

object Demo {
  def main(args: Array[String]): Unit = {
    val stu = new Student("小明", 92.5)
    println(stu.info)
    stu.score = 95.0
    println(s"修改后：${stu.info}")
  }
}

class Animal(val name: String) {
  def speak: String = "动物叫声"
}

class Dog(name: String) extends Animal(name) {
  override def speak: String = s"${super.speak}：汪汪！"
}

object Demo {
  def main(args: Array[String]): Unit = {
    val dog = new Dog("旺财")
    println(dog.speak)
    println(s"是 Animal 子类：${dog.isInstanceOf[Animal]}")
  }
}

case class User(id: Int, name: String, email: String)

object Demo {
  def main(args: Array[String]): Unit = {
    val u1 = User(1, "Alice", "alice@example.com")
    val u2 = u1.copy(name = "Alicia")
    println(s"u1：$u1")
    println(s"相等：${u1 == u2}")
    println(s"copy 后：$u2")

    u1 match {
      case User(id, name, _) => println(s"解构：id=$id, name=$name")
    }
  }
}

class Circle(val radius: Double) {
  def area: Double = Circle.pi * radius * radius
}

object Circle {
  private val pi = math.Pi
  def apply(radius: Double): Circle = new Circle(radius)
  val UNIT: Circle = new Circle(1.0)
}

object Demo {
  def main(args: Array[String]): Unit = {
    val c = Circle(3.0)  // apply 工厂
    println(f"面积：${c.area}%.4f")
    println(f"单位圆面积：${Circle.UNIT.area}%.4f")
  }
}

object Demo {
  def safeDiv(a: Int, b: Int): Option[Int] =
    if (b == 0) None else Some(a / b)

  def main(args: Array[String]): Unit = {
    println(s"10/2：${safeDiv(10, 2).getOrElse(-1)}")
    println(s"10/0：${safeDiv(10, 0).getOrElse(-1)}")

    safeDiv(10, 0) match {
      case Some(v) => println(s"结果：$v")
      case None    => println("除数为 0，返回默认值")
    }

    val doubled = safeDiv(10, 2).map(_ * 2)
    println(s"map 翻倍：$doubled")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val point = (3, -2)
    point match {
      case (0, 0)       => println("原点")
      case (x, 0)       => println(s"x 轴上，x=$x")
      case (0, y)       => println(s"y 轴上，y=$y")
      case (x, y) if x > 0 && y > 0 => println("第一象限")
      case (x, y)       => println(s"其它位置：($x, $y)")
    }

    val list = List(1, 2, 3, 4, 5)
    list match {
      case head :: tail => println(s"头部：$head，尾部：$tail")
      case Nil          => println("空列表")
    }
  }
}

object Demo {
  def parseScore(s: String): Either[String, Int] =
    s.toIntOption match {
      case Some(n) if n >= 0 && n <= 100 => Right(n)
      case Some(_) => Left(s"分数越界：$s")
      case None    => Left(s"无法解析：$s")
    }

  def main(args: Array[String]): Unit = {
    List("85", "120", "abc").foreach { s =>
      parseScore(s) match {
        case Right(score) => println(s"$s -> 有效分数 $score")
        case Left(err)    => println(s"$s -> 错误：$err")
      }
    }
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val sentences = List(
      "scala is powerful",
      "scala is concise",
      "java is verbose"
    )
    val words = sentences.flatMap(_.split(" "))
    println(s"单词列表：$words")

    val longWords = words.filter(_.length > 4)
    println(s"长度>4：$longWords")

    val counts = words.groupBy(identity).view.mapValues(_.size).toMap
    println(s"词频：$counts")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4, 5)
    println(s"foldLeft 求和：${nums.foldLeft(0)(_ + _)}")
    println(s"foldLeft 拼接：${nums.foldLeft("")((acc, n) => acc + n)}")
    println(s"reduce 求积：${nums.reduce(_ * _)}")
    println(s"foldRight：${nums.foldRight(0)(_ + _)}")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val names = List("张三", "李四", "王五")
    val scores = List(90, 85, 78)

    val pairs = names.zip(scores)
    pairs.foreach { case (n, s) => println(s"$n：$s 分") }

    val (names2, scores2) = pairs.unzip
    println(s"姓名：$names2")
    println(s"分数：$scores2")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val r1 = 1 to 10
    println(s"1 to 10：$r1")

    val evens = 2 to 10 by 2
    println(s"偶数：$evens")

    val backwards = 5 to 1 by -1
    println(s"倒序：$backwards")

    val squares = (1 to 5).map(i => i * i)
    println(s"平方：$squares")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    def fibs(a: Int, b: Int): LazyList[Int] = a #:: fibs(b, a + b)

    val fib = fibs(0, 1).take(10).toList
    println(s"斐波那契前 10：$fib")
  }
}

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

object Demo {
  def main(args: Array[String]): Unit = {
    val future = Future {
      Thread.sleep(100)
      42
    }
    val result = Await.result(future, 2.seconds)
    println(s"Future 结果：$result")
  }
}

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

object Demo {
  def main(args: Array[String]): Unit = {
    val f1 = Future { Thread.sleep(100); 10 }
    val f2 = Future { Thread.sleep(100); 20 }

    val sum = for {
      a <- f1
      b <- f2
    } yield a + b

    println(s"组合结果：${Await.result(sum, 2.seconds)}")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val nums = (1 to 1000).toList

    val seqResult = nums.map(_ * 2)
    val parResult = nums.par.map(_ * 2).seq
    println(s"并行结果一致：${seqResult == parResult}")
    println(s"并行前 5 个：${parResult.take(5)}")
  }
}

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

object Demo {
  def main(args: Array[String]): Unit = {
    val risky = Future {
      if (math.random() > 0.3) 100 else throw new RuntimeException("模拟失败")
    }
    val safe = risky.recover {
      case e: RuntimeException => -1
    }
    println(s"恢复后结果：${Await.result(safe, 2.seconds)}")
  }
}

trait Logger {
  def log(msg: String): Unit = println(s"[LOG] $msg")
}

trait Timestamp {
  def now: String = java.time.LocalTime.now.toString
}

class Service extends Logger with Timestamp {
  def run(): Unit = log(s"服务启动于 $now")
}

object Demo {
  def main(args: Array[String]): Unit = {
    val svc = new Service
    svc.run()
  }
}

object Demo {
  def add(a: Int)(b: Int): Int = a + b

  def main(args: Array[String]): Unit = {
    println(s"柯里化 add(1)(2) = ${add(1)(2)}")

    val add5 = add(5) _
    println(s"部分应用 add5(3) = ${add5(3)}")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val positive: PartialFunction[Int, String] = {
      case n if n > 0 => s"正数 $n"
    }
    val negative: PartialFunction[Int, String] = {
      case n if n < 0 => s"负数 $n"
    }
    val zero: PartialFunction[Int, String] = {
      case 0 => "零"
    }

    val handler = positive.orElse(negative).orElse(zero)
    List(5, -3, 0).foreach(n => println(handler(n)))
  }
}

case class Price(amount: Double)

object Demo {
  implicit val taxRate: Double = 0.13

  def withTax(price: Price)(implicit rate: Double): Double =
    price.amount * (1 + rate)

  def main(args: Array[String]): Unit = {
    val p = Price(100.0)
    println(f"含税价：${withTax(p)}%.2f")
  }
}

case class Student(name: String, chinese: Double, math: Double) {
  def average: Double = (chinese + math) / 2
}

object Demo {
  def main(args: Array[String]): Unit = {
    val students = List(
      Student("张三", 90, 85),
      Student("李四", 78, 92),
      Student("王五", 88, 76)
    )

    val sorted = students.sortBy(-_.average)
    println("姓名	语文	数学	平均")
    sorted.foreach { s =>
      println(f"${s.name}	${s.chinese}	${s.math}	${s.average}%.1f")
    }

    val avg = students.map(_.average).sum / students.size
    println(f"全班平均：$avg%.1f")
    println(s"第一名：${sorted.head.name}")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val text = "scala is powerful scala is concise scala is fun"
    val words = text.split(" ").toList

    val freq = words.groupBy(identity).view.mapValues(_.size).toMap
    freq.toList.sortBy(-_._2).foreach { case (w, c) => println(s"$w：$c") }

    val top = freq.maxBy(_._2)
    println(s"出现最多：${top._1}，${top._2} 次")
  }
}

case class CartItem(name: String, price: Double, qty: Int) {
  def subtotal: Double = price * qty
}

object Demo {
  def main(args: Array[String]): Unit = {
    val items = List(
      CartItem("Scala 教程", 59.0, 2),
      CartItem("编程鼠标", 129.0, 1),
      CartItem("机械键盘", 399.0, 1)
    )

    items.sortBy(-_.subtotal).foreach { it =>
      println(f"${it.name} x${it.qty} = ${it.subtotal}%.2f 元")
    }

    val total = items.map(_.subtotal).sum
    println(f"总计：$total%.2f 元")
  }
}

import scala.util.Try

object Demo {
  def calculate(expr: String): Try[Double] = Try {
    val parts = expr.split(" ")
    require(parts.length == 3, "格式错误，示例：3 + 5")

    val a = parts(0).toDouble
    val b = parts(2).toDouble
    parts(1) match {
      case "+" => a + b
      case "-" => a - b
      case "*" => a * b
      case "/" =>
        require(b != 0, "除数不能为 0")
        a / b
      case op => throw new IllegalArgumentException(s"不支持的运算符：$op")
    }
  }

  def main(args: Array[String]): Unit = {
    List("10 + 5", "10 * 3", "10 / 0", "abc + 1").foreach { expr =>
      calculate(expr) match {
        case scala.util.Success(v) => println(s"$expr = $v")
        case scala.util.Failure(e) => println(s"$expr -> 错误：${e.getMessage}")
      }
    }
  }
}