Scala语言基础与函数式编程详解

本文系统梳理Scala语言基础、函数式编程核心、集合与迭代器、模式匹配、隐式机制、泛型与Spark实战，并对每个重要专业术语进行简明解释，配合实用记忆口诀与典型代码片段，助你高效学习和应用Scala。

Scala语言基础
- 变量声明与类型推断
- 基本数据类型
- 流程控制
函数式编程核心
- 高阶函数与匿名函数
- 柯里化与函数组合
集合与迭代器模式
- 集合容器与常用操作
- Iterator模式与源码分析
模式匹配与面向对象
- match语法
- case class
隐式机制与类型类
- 隐式转换
- 隐式参数
- 隐式类
- 类型类
泛型与类型边界
Spark WordCount实战案例
源码片段与内部逻辑分析
经典口诀与流程图思路
专业术语速查表
参考文献与推荐资料

Scala语言基础

变量声明与类型推断

变量声明

val（不可变变量）：声明后值不可更改，相当于Java的final。
var（可变变量）：声明后值可随时更改。

val name = "Scala"  // 不可变变量，类型推断为String
var age = 25        // 可变变量，类型推断为Int

口诀： val恒不可变，var可随便变，类型自动推，省时又省心

类型推断

类型推断：编译器自动根据右侧表达式推断类型，无需显式声明类型。
函数返回类型：非递归函数可省略返回类型，递归函数建议显式标注。

def square(x: Int) = x * x // 返回值类型自动推断为Int

口诀： 函数类型推，递归需手写

基本数据类型

Int：整数类型
Double：双精度浮点数
Boolean：布尔类型（true/false）
Char：字符类型
String：字符串类型

集合类型

List：不可变链表
Array：定长数组
Map：键值对集合
Set：元素唯一集合

口诀： 常用类型五兄弟，集合类型分可变

流程控制

if表达式（有返回值）

val max = if (a > b) a else b

口诀： if有值，else莫丢

while循环

var i = 0
while (i < 10) {
  println(i)
  i += 1
}

口诀： while守条件，变量自更新

for推导式

for (i <- 1 to 10 if i % 2 == 0) println(i)

for推导式：支持守卫条件（if），可用yield生成新集合。

口诀： for推导，守条件，yield可产新集合

函数式编程核心

高阶函数与匿名函数

高阶函数：参数或返回值为函数的函数，是函数式编程的核心特性。
匿名函数（Lambda表达式）：没有名字的函数，常用于简洁地传递行为。

def operate(f: (Int, Int) => Int, a: Int, b: Int) = f(a, b)
val sum = operate((x, y) => x + y, 5, 3)

口诀： 函数当参数，妙用无边界

柯里化与函数组合

柯里化（Currying）：将多参数函数转为一系列单参数函数链式调用。

def add(x: Int)(y: Int) = x + y
add(1)(2) // 3

口诀： 柯里化，参数分批传

函数组合（compose/andThen）：将两个或多个函数合成一个新函数，按顺序依次执行。

val f = (x: Int) => x + 1
val g = (x: Int) => x * 2
val h = f andThen g
println(h(3)) // 8

口诀： 组合函数先后序，andThen先f后g

集合与迭代器模式

集合容器与常用操作

val arr = Array(1, 2, 3)
val nums = List(1, 2, 3)
val unique = Set(1, 1, 2)
val scores = Map("Alice" -> 90, "Bob" -> 85)

Array：定长可变内容
List：不可变链表
Set：元素唯一
Map：键值对

口诀： Array定长快，List链表慢，Set无重复，Map键值配

常用操作

nums.map(_ * 2)
nums.filter(_ > 1)
nums.foldLeft(0)(_ + _)

口诀： map变形，filter筛选，fold聚合

Iterator模式与源码分析

Iterator：用于遍历集合元素，支持惰性（延迟）计算。
惰性计算：只在需要时才计算结果，节省资源。
链式操作：可连续调用map、filter等方法。

trait Iterator[+A] {
  def hasNext: Boolean
  def next(): A
}
val it = nums.iterator
while (it.hasNext) println(it.next())

口诀： hasNext问有无，next取下一个

模式匹配与面向对象

match语法

模式匹配：类似Java的switch，但支持类型、结构、守卫等多种模式。

val x: Any = 10
x match {
  case 1 => "one"
  case n if n > 5 => "greater than five"
  case _ => "other"
}

口诀： case分支可守卫，_兜底防漏掉

case class

case class：自动生成equals、hashCode、toString，适合不可变数据和模式匹配。

case class Person(name: String, age: Int)
val p = Person("Alice", 25)
p match {
  case Person(n, a) => println(s"$n is $a years old")
}

口诀： case class免new，匹配解构妙

隐式机制与类型类

隐式转换

隐式转换（implicit conversion）：类型不匹配时，编译器自动查找并应用转换方法。

implicit def intToString(x: Int): String = x.toString
val s: String = 123 // 自动调用

口诀： implicit def，类型自动转

隐式参数

隐式参数（implicit parameter）：参数可自动由编译器补全，常用于上下文传递。

def greet(name: String)(implicit greeting: String) = println(s"$greeting, $name")
implicit val defaultGreeting = "Hello"
greet("Alice")

口诀： implicit参数，自动补全

隐式类

隐式类（implicit class）：为已有类型添加新方法，推荐方式。

implicit class RichInt(val x: Int) {
  def isEven: Boolean = x % 2 == 0
}
println(10.isEven)

口诀： implicit class，拓展类方法

类型类

类型类（type class）：通过隐式机制为不同类型提供统一接口，实现泛型多态。

trait Show[A] { def show(a: A): String }
implicit val intShow: Show[Int] = (x: Int) => s"Int($x)"
def printWithShow[A](a: A)(implicit s: Show[A]) = println(s.show(a))
printWithShow(42)

口诀： 类型类+隐式，泛型多态新玩法

注意事项

作用域：仅在当前作用域或伴生对象查找
唯一性：避免同类型多重隐式转换
显式优先
谨慎使用，防止晦涩

隐式转换与模式匹配关联

当match类型不匹配时，可自动尝试隐式转换
可结合提取器对象（unapply）实现灵活解构

object Even {
  def unapply(x: Int): Option[Int] = if (x % 2 == 0) Some(x) else None
}
val num = 10
num match {
  case Even(n) => println(s"$n is even")
  case _ => println("odd")
}

口诀： unapply做提取，match更灵活

泛型与类型边界

泛型

泛型：类或方法可操作任意类型数据，增强代码通用性和类型安全。

def identity[T](x: T): T = x

类型边界

上界（<:）：泛型类型必须是某类型的子类型
下界（>:）：泛型类型必须是某类型的父类型
上下文界定（:）：要求存在隐式实例（如Ordering）
协变（+T）/逆变（-T）：控制泛型子类型关系

def max[T <: Comparable[T]](a: T, b: T): T = if (a.compareTo(b) > 0) a else b
def sort[T: Ordering](list: List[T]) = list.sorted
class Box[+T](val value: T)
class Consumer[-T] { def consume(value: T): Unit = println(value) }

口诀： 协变加+，逆变加-，泛型边界多练习

Spark WordCount实战案例

本地版

val lines = List("hello world", "hello scala")
val wordCounts = lines.flatMap(_.split(" "))
                      .groupBy(identity)
                      .mapValues(_.size)
println(wordCounts)

流程图思路：
文本行 → 拆分单词 → 分组统计 → 计数输出

Spark版

val textFile = sc.textFile("hdfs://...")
val counts = textFile
  .flatMap(line => line.split(" "))
  .map(word => (word, 1))
  .reduceByKey(_ + _)
counts.saveAsTextFile("hdfs://...")

流程：
RDD读取 → flatMap分词 → map计数 → reduceByKey聚合 → 保存

口诀： 读分词，映射一，聚合加，存输出

源码片段与内部逻辑分析

Iterator设计：核心为hasNext和next，支持惰性、链式遍历。
高阶函数：如map、filter、fold，都是集合的高阶方法。
隐式转换：编译器自动查找implicit，补全类型/参数/方法。

经典口诀与流程图思路

口诀回顾

val恒不可变，var可随便变
if有值，else莫丢
map变形，filter筛选，fold聚合
hasNext问有无，next取下一个
case class免new，匹配解构妙
implicit def，类型自动转
implicit class，拓展类方法
unapply做提取，match更灵活
协变加+，逆变加-，泛型边界多练习
读分词，映射一，聚合加，存输出

流程图思路（文字版）

集合操作流程
数据源 → map/flatMap/for → filter → groupBy/reduce → 输出/保存
隐式转换匹配流程
类型不匹配 → 编译器查找implicit → 自动转换/补参数 → 编译通过
Spark WordCount流程
HDFS读取 → RDD分词 → (word, 1)映射 → reduceByKey聚合 → 结果输出

专业术语速查表

术语	解释
val/var	不可变/可变变量
类型推断	编译器自动判断类型
高阶函数	参数或返回值为函数的函数
柯里化	多参数函数转单参数函数链
匿名函数	没有名字的函数（lambda表达式）
case class	用于模式匹配的特殊类，自动生成常用方法
Iterator	支持惰性遍历的对象
隐式转换	编译器自动补全类型转换（implicit def）
隐式参数	编译器自动补全参数
隐式类	给已有类型添加新方法的语法糖
泛型	参数化类型，增强通用性
类型边界	泛型类型的上下界约束
协变/逆变	泛型子类型关系的控制（+/-）
unapply	提取器方法，支持模式匹配解构
RDD	Spark的弹性分布式数据集
DSL	领域特定语言
类型类	通过隐式机制实现的泛型多态接口
HDFS	Hadoop分布式文件系统
伴生对象	与类同名、同文件的object对象

参考文献与推荐资料

Scala官方文档与教程
- The Scala Language Documentation
- Tour of Scala
权威书籍
- Martin Odersky, Lex Spoon, Bill Venners. Programming in Scala (Fourth Edition), Artima, 2016.
- Dean Wampler, Alex Payne. Programming Scala (Third Edition), O’Reilly Media, 2021.
- Paul Chiusano, Rúnar Bjarnason. Functional Programming in Scala, Manning, 2014.
社区与博客
- Scala官方GitHub
- Stack Overflow Scala标签
- Awesome Scala
大数据与Spark相关
- Matei Zaharia et al. Spark: Cluster Computing with Working Sets. HotCloud 2010.
- Apache Spark官方文档（Scala版）
其他技术参考
- Scala标准库API文档
- Haskell Type Classes vs. Scala Type Classes
推荐进阶阅读
- Scala School by Twitter
- Scala Exercises
- Functional Programming Principles in Scala (Coursera)