一、先统一核心前提
所有写法都依赖：
remember：缓存状态，避免重组时重新创建；mutableStateOf(default)：创建可观察的MutableState<T>对象（核心是value属性，读写时会触发 Compose 重组监听）。
二、三种写法的详细对比
| 写法 | 语法本质 | 读写方式 | 适用场景 | 优点 | 缺点 |
|---|---|---|---|---|---|
val state = remember { mutableStateOf(default) } | 直接持有 MutableState 对象（不可变引用，对象内部可变） | 读：state.value写：state.value = 新值 | 需明确暴露「状态对象」的场景（如封装到 ViewModel/StateHolder） | 语义清晰，能直接操作 MutableState对象 | 读写需写 .value，稍繁琐 |
var value by remember { mutableStateOf(default) } | Kotlin 「委托语法」（通过 State委托简化 .value 读写） | 读：value写：value = 新值 | 组件内简单状态（如开关、计数、输入框文本） | 语法最简洁，读写像普通变量 | 只能在 Composable 中用（依赖委托），无法直接传递「修改状态的方法」 |
val (value, setValue) = remember { mutableStateOf(default) } | Kotlin 「解构声明」（把 MutableState 拆成「读值 + 设值」两个变量） | 读：value（等价于 state.value）写：setValue(新值)（等价于 state.value = 新值） | 需将「读 / 写分离」的场景（如状态提升、传递给子组件） | 读写分离，适合单向数据流（子组件只调 setValue 改状态） | 语法稍抽象，新手易看不懂 |
三、逐行拆解（重点讲第三种）
1. 第一种：直接持有 MutableState 对象
// 示例：计数状态
val countState = remember { mutableStateOf(0) }
Column {
// 读值
Text("计数：${countState.value}")
// 写值
Button(onClick = { countState.value++ }) { Text("+1") }
}
-
核心：
countState是「不可变的引用」（val），但指向的MutableState对象内部的value是可变的； -
场景：比如在 ViewModel 中封装状态时，通常用这种方式（因为 ViewModel 中不推荐用委托语法）：
class MainViewModel : ViewModel() {
// ViewModel 中推荐这种写法，而非委托
val countState = mutableStateOf(0)
fun increment() { countState.value++ }
}
2. 第二种：委托语法（最常用）
// 示例：计数状态
var count by remember { mutableStateOf(0) }
// 读值（无需 .value）
Text("计数：$count")
// 写值（无需 .value）
Button(onClick = { count++ }) { Text("+1") }
-
核心：
by是 Kotlin 的「属性委托」，Compose 帮我们重写了get()和set()：- 读
count→ 实际调用mutableStateOf(0).value； - 写
count = 新值→ 实际调用mutableStateOf(0).value = 新值；
- 读
-
前提：需导入委托相关的包（Android Studio 会自动提示）：
kotlin
import androidx.compose.runtime.getValue import androidx.compose.runtime.setValue -
场景：组件内简单状态（如弹窗显隐、输入框文本），语法最简洁。
3. 第三种：解构声明（重点拆解）
先看完整示例：
// 示例：计数状态
val (count, setCount) = remember { mutableStateOf(0) }
// 读值（直接用 count）
Text("计数：$count")
// 写值（调用 setCount 方法）
Button(onClick = { setCount(count + 1) }) { Text("+1") }
为什么能解构？—— MutableState 的底层支持
Compose 的 MutableState 接口实现了 Kotlin 的「解构声明」约定：
-
Kotlin 规定：如果一个类定义了
component1()、component2()方法，就能被解构为多个变量； -
MutableState的默认实现（SnapshotMutableState）中：component1()→ 返回value（读值）；component2()→ 返回一个 lambda：{ newVal -> value = newVal }（设值）。
用伪代码模拟这个逻辑：
// 模拟 MutableState 的解构逻辑
class MyMutableState<T>(var value: T) {
// component1：返回当前值（读）
operator fun component1(): T = value
// component2：返回一个函数，用于修改值（写）
operator fun component2(): (T) -> Unit = { newValue -> value = newValue }
}
// 解构使用
val myState = MyMutableState(0)
val (value, setValue) = myState // 等价于：
// val value = myState.component1()
// val setValue = myState.component2()
// 写值：调用 setValue → 实际修改 myState.value
setValue(1)
println(myState.value) // 输出 1
第三种写法的核心场景：状态提升
解构的最大价值是「读写分离」，适合状态提升（子组件只需要「读值」和「修改值的方法」，不需要持有整个状态对象）：
// 子组件：只接收 读值 + 设值方法，无状态
@Composable
fun CounterButton(count: Int, onCountChange: (Int) -> Unit) {
Button(onClick = { onCountChange(count + 1) }) {
Text("计数：$count")
}
}
// 父组件：持有状态，解构后传递给子组件
@Composable
fun ParentComponent() {
val (count, setCount) = remember { mutableStateOf(0) }
// 传递 读值（count） + 设值方法（setCount）
CounterButton(count = count, onCountChange = setCount)
}
这种写法比委托更清晰：子组件只依赖「纯值」和「纯函数」，完全无状态，符合 Compose 「单向数据流」的最佳实践。
四、选型建议（新手直接记）
- 组件内简单状态 → 用第二种（
var value by remember { mutableStateOf(default) }）：比如var isShowDialog by remember { mutableStateOf(false) }，语法最简洁； - ViewModel/StateHolder 封装状态 → 用第一种（
val state = mutableStateOf(default)）：避免在非 Composable 环境中用委托，语义更清晰； - 状态提升 / 读写分离 → 用第三种（
val (value, setValue) = remember { ... }）：子组件只接收「读值」和「设值方法」，解耦更彻底。
总结
- 三种写法核心都是
MutableState，区别仅在于语法糖（委托 / 解构），底层重组逻辑完全一致； - 第二种（委托）是新手最常用的简洁写法，第三种（解构）是「状态提升」的优雅写法；
- 第三种的本质是 Kotlin 解构声明：
component1()读值、component2()返回设值函数，核心价值是读写分离。
