在 Android Kotlin 开发中，条件语句和循环语句是最基础、最常用的语法之一。
条件语句用于根据不同条件执行不同代码，循环语句用于重复执行一段代码。无论是表单校验、按钮点击、页面状态处理、列表遍历，还是数据筛选，都离不开它们。
本文主要介绍 Kotlin 中常用的条件语句和循环语句，包括：
ifif elseif else ifwhenforwhiledo whilerepeatbreakcontinueforEachforEachIndexed
一、Kotlin 条件语句
Kotlin 中常用的条件语句有：
if
if else
if else if
when
其中 if 类似 Java 中的 if，而 when 类似 Java 中的 switch，但 Kotlin 的 when 更强大、更灵活。
1. if 条件语句
if 是最基础的条件判断语句。
基本格式：
if (条件表达式) {
条件成立时执行的代码
}
示例：
val age = 18
if (age >= 18) {
println("已经成年")
}
输出结果：
已经成年
这里的判断逻辑是：
age >= 18
如果结果是 true，就执行 {} 中的代码。
2. if else 条件语句
如果希望条件成立执行一段代码，条件不成立执行另一段代码，可以使用 if else。
基本格式：
if (条件表达式) {
条件成立时执行
} else {
条件不成立时执行
}
示例：
val age = 16
if (age >= 18) {
println("已经成年")
} else {
println("未成年")
}
输出结果：
未成年
3. if else if 多条件判断
如果有多个条件需要判断，可以使用 if else if。
基本格式：
if (条件1) {
条件1成立时执行
} else if (条件2) {
条件2成立时执行
} else if (条件3) {
条件3成立时执行
} else {
以上条件都不成立时执行
}
示例：根据分数判断等级。
val score = 85
if (score >= 90) {
println("优秀")
} else if (score >= 80) {
println("良好")
} else if (score >= 60) {
println("及格")
} else {
println("不及格")
}
输出结果：
良好
执行过程：
score >= 90 不成立
score >= 80 成立
所以输出：良好
一旦某个条件成立，后面的判断就不会继续执行。
4. if 可以作为表达式使用
Kotlin 中的 if 不仅是语句，还可以作为表达式使用。
也就是说，if 可以直接返回一个值。
示例：
val a = 10
val b = 20
val max = if (a > b) {
a
} else {
b
}
println(max)
输出结果：
20
如果代码只有一行，也可以简写：
val max = if (a > b) a else b
这个写法在 Kotlin 中非常常见。
5. if 表达式通常需要 else
如果用 if 给变量赋值，一般必须写 else，否则 Kotlin 不知道条件不成立时返回什么。
错误写法：
val age = 16
val result = if (age >= 18) {
"成年人"
}
正确写法：
val age = 16
val result = if (age >= 18) {
"成年人"
} else {
"未成年人"
}
也可以简写：
val result = if (age >= 18) "成年人" else "未成年人"
6. 条件判断中的比较运算符
条件语句中经常会使用比较运算符。
| 运算符 | 说明 | 示例 |
|---|---|---|
> | 大于 | age > 18 |
< | 小于 | age < 18 |
>= | 大于等于 | age >= 18 |
<= | 小于等于 | age <= 18 |
== | 等于 | name == "张三" |
!= | 不等于 | name != "张三" |
示例：
val username = "admin"
if (username == "admin") {
println("管理员用户")
}
注意：Kotlin 中判断两个值是否相等，使用 ==。
val name = "Kotlin"
if (name == "Kotlin") {
println("名称相同")
}
7. 逻辑运算符
多个条件组合判断时，需要使用逻辑运算符。
| 运算符 | 说明 | 示例 |
|---|---|---|
&& | 并且，多个条件都成立 | age >= 18 && hasCard |
| ` | ` | |
! | 取反 | !isLogin |
7.1 && 并且
val age = 20
val hasTicket = true
if (age >= 18 && hasTicket) {
println("可以入场")
}
只有两个条件都成立，才会输出：
可以入场
7.2 || 或者
val isVip = false
val isAdmin = true
if (isVip || isAdmin) {
println("允许访问")
}
只要有一个条件成立，就会输出：
允许访问
7.3 ! 取反
val isLogin = false
if (!isLogin) {
println("请先登录")
}
!isLogin 表示不是已登录状态，所以会输出：
请先登录
8. Android 中常见 if 使用场景
8.1 判断输入是否为空
val username = usernameEditText.text.toString()
if (username.isBlank()) {
Toast.makeText(this, "用户名不能为空", Toast.LENGTH_SHORT).show()
}
isBlank() 表示判断字符串是否为空，或者只包含空格。
8.2 判断密码长度
val password = passwordEditText.text.toString()
if (password.length < 6) {
Toast.makeText(this, "密码不能少于 6 位", Toast.LENGTH_SHORT).show()
}
8.3 登录表单校验
val username = usernameEditText.text.toString()
val password = passwordEditText.text.toString()
if (username.isBlank()) {
Toast.makeText(this, "请输入用户名", Toast.LENGTH_SHORT).show()
} else if (password.isBlank()) {
Toast.makeText(this, "请输入密码", Toast.LENGTH_SHORT).show()
} else if (password.length < 6) {
Toast.makeText(this, "密码不能少于 6 位", Toast.LENGTH_SHORT).show()
} else {
Toast.makeText(this, "开始登录", Toast.LENGTH_SHORT).show()
}
8.4 判断 View 是否显示
if (progressBar.visibility == View.VISIBLE) {
progressBar.visibility = View.GONE
} else {
progressBar.visibility = View.VISIBLE
}
8.5 判断网络状态
if (isNetworkAvailable()) {
println("网络可用，开始请求数据")
} else {
println("网络不可用，请检查网络")
}
9. when 条件语句
when 是 Kotlin 中非常重要的条件语句。
它类似 Java 中的 switch，但是更强大。
基本格式：
when (变量) {
值1 -> 执行代码1
值2 -> 执行代码2
值3 -> 执行代码3
else -> 默认执行代码
}
示例：
val day = 1
when (day) {
1 -> println("星期一")
2 -> println("星期二")
3 -> println("星期三")
4 -> println("星期四")
5 -> println("星期五")
6 -> println("星期六")
7 -> println("星期日")
else -> println("日期错误")
}
输出结果：
星期一
10. when 可以匹配多个值
如果多个值执行相同逻辑，可以用逗号隔开。
val day = 6
when (day) {
1, 2, 3, 4, 5 -> println("工作日")
6, 7 -> println("周末")
else -> println("日期错误")
}
输出结果：
周末
11. when 可以判断范围
when 可以结合 in 判断范围。
val score = 85
when (score) {
in 90..100 -> println("优秀")
in 80..89 -> println("良好")
in 60..79 -> println("及格")
in 0..59 -> println("不及格")
else -> println("分数不合法")
}
输出结果：
良好
这里：
in 80..89
表示 score 在 80 到 89 之间。
12. when 可以作为表达式使用
和 if 一样，when 也可以返回值。
val score = 85
val level = when (score) {
in 90..100 -> "优秀"
in 80..89 -> "良好"
in 60..79 -> "及格"
in 0..59 -> "不及格"
else -> "分数不合法"
}
println(level)
输出结果：
良好
这种写法比 if else if 更清晰。
13. when 不带参数
when 也可以不带参数，用来替代复杂的 if else if。
val score = 85
when {
score >= 90 -> println("优秀")
score >= 80 -> println("良好")
score >= 60 -> println("及格")
else -> println("不及格")
}
这种写法等价于：
if (score >= 90) {
println("优秀")
} else if (score >= 80) {
println("良好")
} else if (score >= 60) {
println("及格")
} else {
println("不及格")
}
14. when 判断类型
Kotlin 中可以使用 is 判断类型。
fun checkType(value: Any) {
when (value) {
is String -> println("这是字符串，长度是：${value.length}")
is Int -> println("这是整数，值是：$value")
is Boolean -> println("这是布尔值：$value")
else -> println("未知类型")
}
}
调用：
checkType("Hello")
checkType(100)
checkType(true)
输出结果：
这是字符串，长度是：5
这是整数，值是：100
这是布尔值：true
注意：
is String
表示判断 value 是否是 String 类型。
在 is String 分支中，Kotlin 会自动把 value 当成 String 使用，所以可以直接访问：
value.length
15. when 判断枚举类型
在 Android 开发中，有时会使用枚举表示状态。
enum class LoginState {
SUCCESS,
FAILED,
LOADING
}
使用 when 判断：
val state = LoginState.SUCCESS
when (state) {
LoginState.SUCCESS -> println("登录成功")
LoginState.FAILED -> println("登录失败")
LoginState.LOADING -> println("登录中")
}
如果 when 已经覆盖了所有枚举值，可以不写 else。
16. Android 中常见 when 使用场景
16.1 根据按钮 ID 判断点击事件
fun onButtonClick(view: View) {
when (view.id) {
R.id.loginButton -> {
println("点击了登录按钮")
}
R.id.registerButton -> {
println("点击了注册按钮")
}
R.id.cancelButton -> {
println("点击了取消按钮")
}
else -> {
println("未知按钮")
}
}
}
16.2 根据页面状态更新 UI
enum class PageState {
LOADING,
SUCCESS,
ERROR,
EMPTY
}
fun updatePageState(state: PageState) {
when (state) {
PageState.LOADING -> {
progressBar.visibility = View.VISIBLE
contentView.visibility = View.GONE
errorView.visibility = View.GONE
}
PageState.SUCCESS -> {
progressBar.visibility = View.GONE
contentView.visibility = View.VISIBLE
errorView.visibility = View.GONE
}
PageState.ERROR -> {
progressBar.visibility = View.GONE
contentView.visibility = View.GONE
errorView.visibility = View.VISIBLE
}
PageState.EMPTY -> {
progressBar.visibility = View.GONE
contentView.visibility = View.GONE
errorView.visibility = View.GONE
}
}
}
16.3 根据接口返回码处理结果
val code = 200
when (code) {
200 -> println("请求成功")
400 -> println("参数错误")
401 -> println("未登录或登录过期")
403 -> println("没有权限")
404 -> println("资源不存在")
500 -> println("服务器错误")
else -> println("未知错误")
}
17. if 和 when 怎么选择？
| 场景 | 推荐使用 |
|---|---|
| 简单的真假判断 | if |
| 两个分支判断 | if else |
| 多个范围判断 | when |
| 多个固定值匹配 | when |
| 判断枚举状态 | when |
| 判断类型 | when |
| 复杂条件组合 | if 或不带参数的 when |
简单判断：
if (isLogin) {
println("已登录")
} else {
println("未登录")
}
多个固定值匹配：
when (status) {
0 -> println("未开始")
1 -> println("进行中")
2 -> println("已完成")
else -> println("未知状态")
}
范围判断：
when (score) {
in 90..100 -> println("优秀")
in 80..89 -> println("良好")
in 60..79 -> println("及格")
else -> println("不及格")
}
18. 完整示例：登录判断
fun login(username: String, password: String) {
if (username.isBlank()) {
println("用户名不能为空")
return
}
if (password.isBlank()) {
println("密码不能为空")
return
}
if (password.length < 6) {
println("密码不能少于 6 位")
return
}
println("登录成功")
}
调用：
login("", "123456")
login("admin", "123")
login("admin", "123456")
输出结果：
用户名不能为空
密码不能少于 6 位
登录成功
这里用了多个 if 加 return 的写法，这种方式在 Android 表单校验中很常见。
19. 完整示例：根据状态更新 UI
enum class UiState {
Loading,
Success,
Error,
Empty
}
fun updateUi(state: UiState) {
when (state) {
UiState.Loading -> {
println("显示加载中")
}
UiState.Success -> {
println("显示内容")
}
UiState.Error -> {
println("显示错误页面")
}
UiState.Empty -> {
println("显示空页面")
}
}
}
调用：
updateUi(UiState.Loading)
updateUi(UiState.Success)
输出结果：
显示加载中
显示内容
20. 条件语句总结
Kotlin 中常用的条件语句如下：
| 条件语句 | 作用 |
|---|---|
if | 单条件判断 |
if else | 二选一判断 |
if else if | 多条件判断 |
when | 多分支判断，类似 Java 的 switch，但更强大 |
if 表达式 | 根据条件返回一个值 |
when 表达式 | 根据不同分支返回一个值 |
常用写法：
val result = if (score >= 60) "及格" else "不及格"
val level = when (score) {
in 90..100 -> "优秀"
in 80..89 -> "良好"
in 60..79 -> "及格"
else -> "不及格"
}
对于 Android Kotlin 开发来说：
简单判断用 if，多状态判断用 when。
尤其是处理页面状态、按钮点击、接口返回码、枚举状态时，when 会让代码更加清晰。
二、Kotlin 循环语句
在 Kotlin 中，循环语句主要用于重复执行一段代码。
比如：
打印 1 到 10
遍历数组
遍历集合
循环读取数据
重复执行某个任务
Kotlin 中常用的循环方式有：
for
while
do while
repeat
其中最常用的是 for 循环。
1. for 循环
for 循环通常用于遍历范围、数组、集合等。
基本格式：
for (变量 in 数据范围) {
循环体
}
示例：
for (i in 1..5) {
println(i)
}
输出结果：
1
2
3
4
5
这里：
1..5
表示从 1 到 5，包含 1 和 5。
2. 使用 .. 表示闭区间
Kotlin 中可以使用 .. 创建一个范围。
for (i in 1..10) {
println(i)
}
表示从 1 循环到 10，包含 10。
示例：
for (i in 1..3) {
println("第 $i 次循环")
}
输出结果：
第 1 次循环
第 2 次循环
第 3 次循环
3. 使用 until 表示左闭右开区间
until 表示不包含结束值。
for (i in 1 until 5) {
println(i)
}
输出结果：
1
2
3
4
这里不包含 5。
等价理解：
1 until 5
表示从 1 到 4。
在 Android 中遍历集合下标时经常用：
val names = listOf("张三", "李四", "王五")
for (i in 0 until names.size) {
println(names[i])
}
4. 使用 downTo 倒序循环
如果想从大到小循环，可以使用 downTo。
for (i in 5 downTo 1) {
println(i)
}
输出结果：
5
4
3
2
1
示例：
for (count in 3 downTo 1) {
println("倒计时：$count")
}
println("开始")
输出结果：
倒计时：3
倒计时：2
倒计时：1
开始
5. 使用 step 设置步长
默认情况下，循环每次递增或递减 1。
如果想改变步长，可以使用 step。
for (i in 1..10 step 2) {
println(i)
}
输出结果：
1
3
5
7
9
倒序也可以使用 step：
for (i in 10 downTo 1 step 2) {
println(i)
}
输出结果：
10
8
6
4
2
6. for 循环常见范围写法总结
| 写法 | 说明 | 示例结果 |
|---|---|---|
1..5 | 从 1 到 5，包含 5 | 1 2 3 4 5 |
1 until 5 | 从 1 到 5，不包含 5 | 1 2 3 4 |
5 downTo 1 | 从 5 倒序到 1 | 5 4 3 2 1 |
1..10 step 2 | 从 1 到 10，每次加 2 | 1 3 5 7 9 |
10 downTo 1 step 2 | 从 10 到 1，每次减 2 | 10 8 6 4 2 |
7. 遍历数组
Kotlin 中可以使用 for 遍历数组。
val names = arrayOf("张三", "李四", "王五")
for (name in names) {
println(name)
}
输出结果：
张三
李四
王五
这里的 name 会依次拿到数组中的每一个元素。
8. 遍历集合 List
Android 开发中，经常会使用 List 集合。
val languages = listOf("Kotlin", "Java", "C++")
for (language in languages) {
println(language)
}
输出结果：
Kotlin
Java
C++
这种写法比传统下标循环更简洁。
9. 遍历集合下标
如果需要使用下标，可以使用 indices。
val names = listOf("张三", "李四", "王五")
for (i in names.indices) {
println("下标：$i，姓名：${names[i]}")
}
输出结果：
下标：0，姓名：张三
下标：1，姓名：李四
下标：2，姓名：王五
这里：
names.indices
表示集合的下标范围。
如果 names 有 3 个元素，那么 names.indices 就是：
0..2
10. 同时遍历下标和元素
Kotlin 提供了 withIndex()，可以同时拿到下标和元素。
val names = listOf("张三", "李四", "王五")
for ((index, name) in names.withIndex()) {
println("下标：$index，姓名：$name")
}
输出结果：
下标：0，姓名：张三
下标：1，姓名：李四
下标：2，姓名：王五
这种写法在 Android 列表数据处理时很常用。
11. 遍历 Map
Map 是键值对集合。
val userMap = mapOf(
"name" to "张三",
"age" to "18",
"city" to "北京"
)
for ((key, value) in userMap) {
println("key：$key，value：$value")
}
输出结果：
key：name，value：张三
key：age，value：18
key：city，value：北京
这里：
(key, value)
表示同时取出 Map 中的键和值。
12. while 循环
while 循环会在条件成立时一直执行。
基本格式：
while (条件) {
循环体
}
示例：
var count = 1
while (count <= 5) {
println(count)
count++
}
输出结果：
1
2
3
4
5
执行流程：
先判断条件
条件成立，执行循环体
执行完后，再次判断条件
直到条件不成立，循环结束
13. while 循环使用场景
while 适合用于不确定循环次数，但知道结束条件的场景。
例如：
var retryCount = 0
while (retryCount < 3) {
println("第 ${retryCount + 1} 次重试")
retryCount++
}
输出结果：
第 1 次重试
第 2 次重试
第 3 次重试
Android 中可以用于模拟重试逻辑、轮询逻辑等。
14. do while 循环
do while 和 while 类似，但是它会先执行一次循环体，再判断条件。
基本格式：
do {
循环体
} while (条件)
示例：
var count = 1
do {
println(count)
count++
} while (count <= 5)
输出结果：
1
2
3
4
5
15. do while 和 while 的区别
while 是先判断，再执行。
var count = 10
while (count <= 5) {
println(count)
}
这段代码不会执行，因为一开始条件就不成立。
do while 是先执行一次，再判断。
var count = 10
do {
println(count)
} while (count <= 5)
输出结果：
10
即使条件不成立，do while 也至少会执行一次。
| 循环类型 | 判断条件时机 | 是否至少执行一次 |
|---|---|---|
while | 先判断，后执行 | 不一定 |
do while | 先执行，后判断 | 是 |
16. repeat 重复执行
Kotlin 中还提供了一个非常简洁的重复执行函数：repeat。
repeat(5) {
println("Hello Kotlin")
}
输出结果：
Hello Kotlin
Hello Kotlin
Hello Kotlin
Hello Kotlin
Hello Kotlin
repeat(5) 表示重复执行 5 次。
17. repeat 中获取下标
repeat 的代码块中可以拿到当前下标。
repeat(3) { index ->
println("当前下标：$index")
}
输出结果：
当前下标：0
当前下标：1
当前下标：2
注意：repeat 的下标从 0 开始。
如果想从 1 开始显示，可以这样写：
repeat(3) { index ->
println("第 ${index + 1} 次执行")
}
输出结果：
第 1 次执行
第 2 次执行
第 3 次执行
18. break 跳出循环
break 用来直接结束整个循环。
示例：
for (i in 1..10) {
if (i == 5) {
break
}
println(i)
}
输出结果：
1
2
3
4
当 i == 5 时，执行 break，整个循环结束。
19. continue 跳过本次循环
continue 用来跳过当前这一次循环，继续下一次循环。
示例：
for (i in 1..5) {
if (i == 3) {
continue
}
println(i)
}
输出结果：
1
2
4
5
当 i == 3 时，执行 continue，所以 3 没有被打印。
20. break 和 continue 的区别
| 关键字 | 作用 |
|---|---|
break | 直接结束整个循环 |
continue | 跳过本次循环，继续下一次循环 |
break 示例：
for (i in 1..5) {
if (i == 3) {
break
}
println(i)
}
输出结果：
1
2
continue 示例：
for (i in 1..5) {
if (i == 3) {
continue
}
println(i)
}
输出结果：
1
2
4
5
21. 嵌套循环
循环中还可以继续写循环，这叫嵌套循环。
for (i in 1..3) {
for (j in 1..3) {
println("i = $i, j = $j")
}
}
输出结果：
i = 1, j = 1
i = 1, j = 2
i = 1, j = 3
i = 2, j = 1
i = 2, j = 2
i = 2, j = 3
i = 3, j = 1
i = 3, j = 2
i = 3, j = 3
嵌套循环常用于二维数据、表格、矩阵等场景。
22. 带标签的 break
如果有嵌套循环，普通 break 只能跳出当前这一层循环。
for (i in 1..3) {
for (j in 1..3) {
if (j == 2) {
break
}
println("i = $i, j = $j")
}
}
如果想直接跳出外层循环，可以使用标签。
outer@ for (i in 1..3) {
for (j in 1..3) {
if (j == 2) {
break@outer
}
println("i = $i, j = $j")
}
}
输出结果：
i = 1, j = 1
这里：
break@outer
表示跳出名为 outer 的外层循环。
23. 带标签的 continue
标签也可以和 continue 搭配使用。
outer@ for (i in 1..3) {
for (j in 1..3) {
if (j == 2) {
continue@outer
}
println("i = $i, j = $j")
}
}
执行逻辑是：
当 j == 2 时，跳过当前外层循环的剩余部分，进入下一轮 i
输出结果：
i = 1, j = 1
i = 2, j = 1
i = 3, j = 1
24. Android 中循环的常见使用场景
24.1 遍历列表数据
val userList = listOf("张三", "李四", "王五")
for (user in userList) {
println("用户名：$user")
}
24.2 遍历控件列表
val viewList = listOf(textView1, textView2, textView3)
for (view in viewList) {
view.visibility = View.GONE
}
这个写法可以批量隐藏多个控件。
24.3 批量设置按钮点击事件
val buttons = listOf(button1, button2, button3)
for (button in buttons) {
button.setOnClickListener {
Toast.makeText(this, "按钮被点击", Toast.LENGTH_SHORT).show()
}
}
24.4 遍历数据并筛选
val names = listOf("Kotlin", "Java", "Android", "Jetpack")
for (name in names) {
if (name.length > 5) {
println(name)
}
}
输出结果：
Kotlin
Android
Jetpack
24.5 查找指定数据
val names = listOf("张三", "李四", "王五")
for (name in names) {
if (name == "李四") {
println("找到了：$name")
break
}
}
找到目标后使用 break 结束循环，避免继续无意义遍历。
24.6 表单批量校验
val inputList = listOf(username, password, phone)
for (input in inputList) {
if (input.isBlank()) {
println("存在未填写的内容")
break
}
}
25. forEach 遍历集合
Kotlin 集合还可以使用 forEach 遍历。
val names = listOf("张三", "李四", "王五")
names.forEach { name ->
println(name)
}
输出结果：
张三
李四
王五
如果 Lambda 只有一个参数，可以使用默认参数名 it：
names.forEach {
println(it)
}
26. forEachIndexed 同时获取下标和元素
如果既想拿到下标，又想拿到元素，可以使用 forEachIndexed。
val names = listOf("张三", "李四", "王五")
names.forEachIndexed { index, name ->
println("下标：$index，姓名：$name")
}
输出结果：
下标：0，姓名：张三
下标：1，姓名：李四
下标：2，姓名：王五
27. for 和 forEach 怎么选择？
| 场景 | 推荐写法 |
|---|---|
| 普通遍历 | for |
需要 break 或 continue | for |
| 简单遍历集合 | forEach |
| 需要下标和元素 | forEachIndexed 或 withIndex() |
| 逻辑较复杂 | for |
| 只做简单处理 | forEach |
需要注意：
forEach
里面不能像普通 for 一样直接使用 break 和 continue。
所以如果你需要中途结束循环，优先使用普通 for。
28. Kotlin 没有 Java 那种传统 for 循环
Java 中常见写法：
for (int i = 0; i < 10; i++) {
System.out.println(i);
}
Kotlin 中不这样写。
Kotlin 推荐使用：
for (i in 0 until 10) {
println(i)
}
或者：
repeat(10) { i ->
println(i)
}
29. 完整示例：登录表单批量校验
fun checkInputs(inputs: List<String>): Boolean {
for (input in inputs) {
if (input.isBlank()) {
return false
}
}
return true
}
fun main() {
val username = "admin"
val password = "123456"
val phone = "13800138000"
val result = checkInputs(listOf(username, password, phone))
if (result) {
println("表单校验通过")
} else {
println("存在未填写内容")
}
}
输出结果：
表单校验通过
30. 完整示例：筛选有效数据
fun main() {
val names = listOf("Kotlin", "", "Android", " ", "Jetpack")
val validNames = mutableListOf<String>()
for (name in names) {
if (name.isBlank()) {
continue
}
validNames.add(name)
}
println(validNames)
}
输出结果：
[Kotlin, Android, Jetpack]
这里：
continue
用于跳过空字符串。
31. 循环语句总结
Kotlin 中常用循环方式如下：
| 循环方式 | 作用 |
|---|---|
for | 遍历范围、数组、集合 |
while | 条件成立时重复执行 |
do while | 先执行一次，再判断条件 |
repeat | 重复执行指定次数 |
forEach | 集合遍历 |
forEachIndexed | 遍历集合时同时获取下标和元素 |
常用写法：
for (i in 1..5) {
println(i)
}
for (i in 0 until list.size) {
println(list[i])
}
for (item in list) {
println(item)
}
repeat(3) {
println("执行任务")
}
循环控制关键字：
| 关键字 | 作用 |
|---|---|
break | 结束整个循环 |
continue | 跳过本次循环 |
break@标签 | 跳出指定标签的循环 |
continue@标签 | 跳过指定标签的本轮循环 |
对于 Android Kotlin 开发来说：
遍历集合用 for 或 forEach；
需要下标用 indices、withIndex 或 forEachIndexed；
需要中途退出循环时，优先使用普通 for；
固定次数重复执行时，可以使用 repeat。
最后记住一句话：
循环的作用，就是让一段代码按照条件重复执行。
三、条件语句和循环语句综合示例
下面通过一个简单示例，把条件语句和循环语句结合起来。
需求：遍历用户名列表，过滤空数据，并判断用户名长度是否合格。
fun main() {
val userNames = listOf("admin", "", "Tom", "ZhangSan", " ")
for (name in userNames) {
if (name.isBlank()) {
println("发现空用户名，已跳过")
continue
}
if (name.length < 4) {
println("用户名 $name 长度不足")
} else {
println("用户名 $name 合格")
}
}
}
输出结果：
用户名 admin 合格
发现空用户名，已跳过
用户名 Tom 长度不足
用户名 ZhangSan 合格
发现空用户名，已跳过
这个例子中：
| 语法 | 作用 |
|---|---|
for | 遍历用户名列表 |
if | 判断用户名是否为空 |
continue | 跳过空用户名 |
if else | 判断用户名长度是否合格 |
四、最终总结
Android Kotlin 中，条件语句和循环语句是控制程序流程的基础。
条件语句主要用于判断：
满足某个条件时执行某段代码。
循环语句主要用于重复：
按照条件或次数重复执行某段代码。
开发中可以遵循以下原则：
| 场景 | 推荐写法 |
|---|---|
| 简单条件判断 | if |
| 二选一判断 | if else |
| 多条件判断 | if else if 或 when |
| 多状态判断 | when |
| 遍历数组或集合 | for |
| 固定次数重复执行 | repeat |
| 不确定循环次数 | while |
| 至少执行一次 | do while |
| 简单集合遍历 | forEach |
| 需要下标和元素 | forEachIndexed |
| 需要中途结束循环 | for + break |
| 需要跳过本次循环 | for + continue |
简单判断用 if，多状态判断用 when；遍历集合用 for 或 forEach，需要中途退出时优先使用普通 for。
掌握这些语法后，就可以更清晰地编写 Android Kotlin 中的业务逻辑、页面状态处理、表单校验和列表数据处理代码。
204
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
