> Java的if是语句，Scala的if是表达式；Java的for是循环，Scala的for是推导式。理解Scala控制流的"表达式思维"，是写出地道Scala代码的关键。

如果你从Java转到Scala，写第一个if语句时可能会困惑：**为什么if后面没有分号？为什么for循环里有个yield？为什么没有break和continue？**

这些困惑的根源在于：Java的控制结构是"语句"，而Scala的控制结构是"表达式"。

Java里，`if`是一条语句，你需要单独声明变量再赋值；`for`是一条循环语句，用来重复执行代码块；`switch`是一条选择语句，用来分支执行。而Scala里，**几乎所有控制结构都是表达式，都有返回值**。

这个设计哲学看似微小，却带来了根本性的差异：你可以用if表达式直接赋值、用for推导式生成新集合、用match表达式替代整段if-else链。控制流不再是"命令计算机做什么"，而是"描述你想要什么结果"。

这篇文章从七个层面拆解Scala的循环与判断，帮你建立从Java命令式到Scala表达式式的思维转变。

![Scala控制流知识体系](https://developer.qcloudimg.com/http-save/yehe-2482016/be06ff227e5d9dd1668f4ebe3b11e68b.jpg)

---

## 01 if表达式：一切皆有返回值

### if是表达式，不是语句

Java里，if是语句，你需要这样写：

```java
// Java: if是语句
String result;
if (x > 0) {
    result = "positive";
} else {
    result = "non-positive";
}
```

Scala里，if是表达式，直接返回值：

```scala
// Scala: if是表达式
val result = if (x > 0) "positive" else "non-positive"
```

这不是语法糖——这是**根本的思维转变**。if表达式的结果可以直接赋值、传递、作为函数返回值。

```scala
// if表达式作为函数返回值
def classify(n: Int): String = if (n > 0) "positive" else "non-positive"

// if表达式嵌套
val grade = if (score >= 90) "A"
            else if (score >= 80) "B"
            else if (score >= 70) "C"
            else "D"

// if表达式作为参数
println(if (isEmpty) "空列表" else "非空列表")
```

### 表达式vs语句的本质区别

| 维度 | Java（语句） | Scala（表达式） |
|------|-------------|----------------|
| if | 分支执行代码块 | 计算并返回一个值 |
| for | 重复执行代码块 | 生成新集合 |
| match | 分支执行 | 计算并返回一个值 |
| try | 异常处理 | 捕获异常并返回值 |
| 语句结尾 | 需要分号 | 不需要分号 |

**核心原则**：在Scala里，**能写表达式就不写语句**。表达式有返回值，可以组合、可以嵌套、可以传递；语句只是执行副作用。

---

## 02 for循环与for推导式

Scala的for比Java强大得多。它不仅是循环，还是**推导式（for-comprehension）**——可以用来生成新集合。

### 基础for循环

```scala
// to: 包含上界
for (i <- 1 to 5) print(i)     // 12345

// until: 不包含上界
for (i <- 1 until 5) print(i)  // 1234

// 遍历集合
val fruits = List("apple", "banana", "orange")
for (f <- fruits) println(f)

// 带索引遍历
for ((fruit, index) <- fruits.zipWithIndex) {
  println(s"$index: $fruit")
}
```

### 守卫（for if）

类似Java的for循环里加if条件：

```scala
// 打印1到10的偶数
for (i <- 1 to 10 if i % 2 == 0) println(i)

// 多个守卫
for (i <- 1 to 20 if i % 2 == 0 if i % 3 == 0) println(i)

// 等价写法
for (i <- 1 to 20 if (i % 2 == 0) && (i % 3 == 0)) println(i)
```

### 多生成器（嵌套循环）

```scala
// 两层嵌套循环
for {
  x <- 1 to 3
  y <- 1 to 3
} println(s"($x, $y)")

// 等价于Java:
// for (int x = 1; x <= 3; x++) {
//     for (int y = 1; y <= 3; y++) {
//         System.out.println("(" + x + ", " + y + ")");
//     }
// }
```

### for推导式（yield）

这是Scala for最强大的特性——用yield收集结果，生成新集合：

```scala
// 用yield生成新集合
val squares = for (i <- 1 to 5) yield i * i
// squares: Vector(1, 4, 9, 16, 25)

// 带守卫的推导式
val evenSquares = for (i <- 1 to 10 if i % 2 == 0) yield i * i
// evenSquares: Vector(4, 16, 36, 64, 100)

// 多生成器推导式
val pairs = for {
  x <- List(1, 2, 3)
  y <- List('a', 'b')
} yield (x, y)
// pairs: List((1,a), (1,b), (2,a), (2,b), (3,a), (3,b))
```

### for推导式与map/flatMap的关系

for推导式本质上是map、flatMap、withFilter的语法糖：

```scala
// for推导式
val result = for {
  x <- Some(3)
  y <- Some(4)
} yield x + y
// result: Some(7)

// 等价于
val result2 = Some(3).flatMap(x => Some(4).map(y => x + y))
// result2: Some(7)

// 这就是为什么for推导式可以用于Option、List、Future
// 只要类型有map和flatMap，就可以用for推导式
```

**大数据场景提示**：Spark的RDD和Dataset都支持map和flatMap，因此也支持for推导式。虽然实际开发中更多直接用链式调用，但理解for推导式的本质，有助于理解Spark转换操作的函数式本质。

---

## 03 while与do-while循环

Scala保留了while循环，但**不推荐使用**——因为while是命令式的、可变状态的，与函数式编程风格相悖。

```scala
// while循环
var i = 0
while (i < 5) {
  println(i)
  i += 1
}

// do-while循环
var j = 0
do {
  println(j)
  j += 1
} while (j < 5)
```

### 为什么不推荐while？

```scala
// 命令式：可变状态，容易出bug
var sum = 0
for (i <- 1 to 100) {
  sum += i
}
// sum: 5050

// 函数式：不可变，声明式
val sum = (1 to 100).sum
// sum: 5050

// 函数式：用递归替代循环
def factorial(n: Int): Int = n match {
  case 0 => 1
  case _ => n * factorial(n - 1)
}
```

**经验法则**：在Scala中，优先使用集合操作（map/filter/reduce/fold）和递归，而不是while循环。while只在确实需要循环等待、轮询等场景使用。

---

## 04 match模式匹配

match是Scala的switch，但功能强大得多。它支持值匹配、类型匹配、解构匹配、守卫匹配。

### 基础值匹配

```scala
val day = "MON"
val type = day match {
  case "MON" | "TUE" | "WED" | "THU" | "FRI" => "weekday"
  case "SAT" | "SUN" => "weekend"
  case _ => "unknown"
}
// type: "weekday"

// match是表达式，可以直接赋值
val result = x match {
  case 0 => "zero"
  case 1 => "one"
  case _ => "other"
}
```

### 类型匹配

```scala
def describe(x: Any): String = x match {
  case i: Int => s"整数: $i"
  case s: String => s"字符串: $s"
  case d: Double => s"浮点数: $d"
  case b: Boolean => s"布尔值: $b"
  case list: List[_] => s"列表，长度${list.size}"
  case m: Map[_, _] => s"映射，${m.size}个键值对"
  case _ => "其他类型"
}

describe(42)           // "整数: 42"
describe("hello")      // "字符串: hello"
describe(List(1,2,3))  // "列表，长度3"
```

### 样例类解构匹配

```scala
case class Person(name: String, age: Int)

val alice = Person("Alice", 25)

alice match {
  case Person("Alice", age) => println(s"Alice is $age")
  case Person(name, age) if age < 18 => println(s"未成年: $name")
  case Person(name, _) => println(s"Hello $name")
}
```

### 守卫（match if）

```scala
def classify(n: Int): String = n match {
  case x if x > 0 => "positive"
  case x if x < 0 => "negative"
  case _ => "zero"
}

// 更复杂的守卫
def greet(person: Person): String = person match {
  case Person(name, age) if age < 18 => s"未成年: $name"
  case Person(name, age) if age >= 65 => s"老年: $name"
  case Person(name, age) => s"成年: $name ($age)"
}
```

### 匹配集合

```scala
val list = List(1, 2, 3)

list match {
  case Nil => "空列表"
  case head :: Nil => s"单元素: $head"
  case head :: second :: rest => s"多个元素，首:$head, 次:$second"
  case _ => "其他"
}

// 匹配元组
val pair = (1, "hello")
pair match {
  case (1, "hello") => "匹配"
  case (x, y) => s"($x, $y)"
}
```

### match的穷尽性检查

如果match的输入是密封特质（sealed trait），编译器会检查是否所有情况都被覆盖：

```scala
sealed trait Color
case object Red extends Color
case object Green extends Color
case object Blue extends Color

def colorName(c: Color): String = c match {
  case Red => "红色"
  case Green => "绿色"
  // 如果漏掉Blue，编译器会警告：match may not be exhaustive
  case Blue => "蓝色"
}
```

**对Java开发者的启示**：Java的switch只能匹配整数值和枚举，而Scala的match可以匹配任何类型、可以解构对象、可以加守卫。模式匹配是Scala函数式编程的核心工具，在Spark的RDD处理、Akka的消息路由中大量使用。

---

## 05 try-catch-finally表达式

Scala的try-catch也是表达式，可以返回值：

```scala
// try-catch作为表达式
val result = try {
  "42".toInt
} catch {
  case e: NumberFormatException => 0
}
// result: 42

// 多catch分支
val config = try {
  val props = new java.util.Properties()
  props.load(getClass.getResourceAsStream("/config.properties"))
  props.getProperty("app.name")
} catch {
  case e: java.io.FileNotFoundException => "默认应用"
  case e: java.io.IOException => "IO错误"
} finally {
  println("加载完成")
}
```

### Try类型：更函数式的异常处理

Scala推荐用`Try`替代try-catch：

```scala
import scala.util.Try

// Try[T]是一个容器，要么是Success[T]，要么是Failure
val result = Try("abc".toInt)
// result: Failure(java.lang.NumberFormatException)

// 模式匹配处理Try
result match {
  case Success(value) => println(s"成功: $value")
  case Failure(e) => println(s"失败: ${e.getMessage}")
}

// 链式处理
val safeResult = Try("42".toInt)
  .map(_ * 2)
  .getOrElse(0)
// safeResult: 84

// for推导式中使用Try
val combined = for {
  a <- Try("10".toInt)
  b <- Try("20".toInt)
} yield a + b
// combined: Success(30)
```

---

## 06 循环控制：break与continue

Scala没有原生的break和continue关键字。这是设计选择——鼓励用函数式方式替代循环控制。

### 用Breaks类实现break

```scala
import scala.util.control.Breaks._

breakable {
  for (i <- 1 to 10) {
    if (i == 5) break()
    println(i)
  }
}
// 输出: 1 2 3 4
```

### 用函数式方式替代continue

```scala
// Java: for循环里用continue跳过某些元素
// for (int i = 1; i <= 10; i++) {
//     if (i % 2 == 0) continue;
//     System.out.println(i);
// }

// Scala: 用filter替代continue
for (i <- 1 to 10 if i % 2 != 0) println(i)

// 更函数式的写法
(1 to 10).filter(_ % 2 != 0).foreach(println)
```

### 用return从函数返回

```scala
def findFirstEven(nums: List[Int]): Int = {
  for (n <- nums) {
    if (n % 2 == 0) return n  // 直接从函数返回
  }
  -1  // 没找到
}
```

### 为什么没有break/continue？

Scala的设计哲学是：**用集合操作替代循环，用模式匹配替代分支，用Option替代null**。break和continue是命令式循环的产物，当你用map/filter/reduce时，根本不需要它们。

```scala
// 命令式：用break找到第一个偶数
import scala.util.control.Breaks._
var found = -1
breakable {
  for (n <- nums) {
    if (n % 2 == 0) {
      found = n
      break()
    }
  }
}

// 函数式：用headOption
val found = nums.find(_ % 2 == 0).getOrElse(-1)
```

后者更简洁、更安全、更易读。

---

## 07 与Java循环判断的对比

![Java控制流vs Scala控制流](https://developer.qcloudimg.com/http-save/yehe-2482016/2faf0d79bc6f747b66af50758cf7d65c.jpg)

### 核心差异对比

| 维度 | Java | Scala |
|------|------|-------|
| if | 语句，不能直接赋值 | 表达式，有返回值 |
| for | 循环语句 | 循环 + 推导式 |
| yield | 无 | for yield生成新集合 |
| switch | 仅支持整数/枚举 | match支持任意类型 |
| break/continue | 原生关键字 | 无，用Breaks类或函数式替代 |
| try-catch | 语句 | 表达式，有返回值 |
| while | 推荐使用 | 保留但不推荐 |
| 遍历集合 | for-each或Iterator | for推导式 + 高阶函数 |

### Java for循环 vs Scala for推导式

```java
// Java: 过滤偶数并平方
List<Integer> result = new ArrayList<>();
for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        result.add(i * i);
    }
}
// result: [4, 16, 36, 64, 100]
```

```scala
// Scala: for推导式
val result = for (i <- 1 to 10 if i % 2 == 0) yield i * i
// result: Vector(4, 16, 36, 64, 100)

// Scala: 更函数式的写法
val result = (1 to 10).filter(_ % 2 == 0).map(_ * _)
// result: Vector(4, 16, 36, 64, 100)
```

### Java switch vs Scala match

```java
// Java: switch
String type;
switch (day) {
    case "MON":
    case "TUE":
    case "WED":
    case "THU":
    case "FRI":
        type = "weekday";
        break;
    case "SAT":
    case "SUN":
        type = "weekend";
        break;
    default:
        type = "unknown";
}
```

```scala
// Scala: match
val type = day match {
  case "MON" | "TUE" | "WED" | "THU" | "FRI" => "weekday"
  case "SAT" | "SUN" => "weekend"
  case _ => "unknown"
}
```

### Scala 3新语法

Scala 3对控制流语法做了简化：

```scala
// Scala 3: if表达式
if x > 0 then
  "positive"
else
  "non-positive"

// Scala 3: for循环
for i <- 1 to 5 do
  println(i)

// Scala 3: while循环
while x > 0 do
  x -= 1

// Scala 3: match表达式
val result = x match
  case 0 => "zero"
  case _ => "other"
```

---

## 写在最后：从命令式到表达式式的思维转变

Scala的循环与判断系统，表面上是语法差异，本质上是**编程范式的差异**。

Java是命令式语言：你告诉计算机"一步步做什么"——先判断条件，再执行代码块，再循环重复。Scala是表达式语言：你描述"你想要什么结果"——if返回什么值、for生成什么集合、match匹配到什么分支。

这种转变带来三个好处：

1. **更少的可变状态**：if表达式直接赋值，不需要临时变量；for推导式生成新集合，不需要手动添加元素
2. **更强的组合性**：表达式可以嵌套、可以传递、可以作为参数；语句只能顺序执行
3. **更高的安全性**：match的穷尽性检查让编译器帮你发现遗漏的分支；Try类型让异常处理显式化

这些特性不是孤立的，它们共同支撑了Scala的函数式编程范式。Spark的RDD转换链、Flink的数据流处理、Cats的函数式组合——这些框架的核心都是"描述你想要什么"，而不是"告诉计算机怎么做"。

**学习建议**：不要试图一次记住所有语法。先从if表达式和for推导式开始，写一些小练习。当你习惯了"控制结构有返回值"的思维后，再学习match模式匹配和Try类型。循环与判断是编程的基础，但在Scala里，它们不仅是基础——它们是函数式编程的入口。

从Java的命令式循环到Scala的表达式式控制流，不是学习"另一种循环写法"，而是学习一种"更声明式、更安全、更组合的思考方式"。当你习惯了用map/filter替代for循环、用match替代if-else链、用Try替代try-catch，你会发现：原来控制流可以这么优雅。

Java的if是语句，Scala的if是表达式；Java的for是循环，Scala的for是推导式。理解Scala控制流的"表达式思维"，是写出地道Scala代码的关键。

Scala循环与判断：一切皆表达式的控制流

数据库

Scala控制流本质是表达式而非语句，if可直接赋值，for推导式可生成新集合，match支持任意类型模式匹配。从Java转向Scala需转变思维：用不可变表达式替代命令式循环，用filter替代continue，用find替代break。这种表达式思维带来更少可变状态、更强组合性，是掌握函数式编程的关键入口。

代码解释

大数据

数据流

编译器

容器

路由

Spark 

Java

2026上云采购 | AI焕新·智启新局

bigdata-class

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

Scala循环与判断：一切皆表达式的控制流-腾讯云开发者社区-腾讯云

Scala循环与判断：一切皆表达式的控制流

Scala循环与判断：一切皆表达式的控制流

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐