摘要:本文围绕
LazyList的“边界”展开,先从一个勾选状态滚动后消失的经典坑切入,说明 Lazy 列表只组合可视区域附近的项、项离开组合即被销毁,remember必然丢失;随后对比remember与rememberSaveable在项里的不同命运,剖析LazySaveableStateHolder这个“寄存柜”的机制与两条硬边界(Bundle类型容量约束、key必须可保存);再讲key管纵向身份连续性、contentType管横向复用池划分;进而落到最深的架构边界——项状态不属于项,业务状态应提到数据源层;最后给出“一个状态该放 Lazy 项哪一层”的六问决策框架,并配 12 道习题检验。核心结论:项是视图,不是所有者,状态应跟着实体走,而不是跟着槽位走。
目录
- 前言
- 一、Lazy 列表不是“会滚动的 Column”
- 二、
remember和rememberSaveable在项里是两种命 - 三、寄存柜也有容量:它只救“保存那一刻还看得见”的项
- 四、
key管纵向,contentType管横向 - 五、最深的边界:项状态不属于项
- 六、前瞻边界:测量也不是一次性的
- 七、决策框架:一个状态该放 Lazy 项的哪一层
- 八、习题:12 道 LazyList 状态边界检验
- 九、本节课知识点总结
- 十、下期预告
前言
第8课我们聊的是一个值能活多久,取决于它被放进了哪个存储介质。这一课要问一个更让人头疼的问题:当一个值活在列表项里,而列表项本身会被回收、复用、重新绑定,这个值到底归谁管?
先从一个几乎所有人都踩过的坑说起。
data class Task(val id: Long, val title: String)
@Composable
fun CheckableList(tasks: List<Task>) {
LazyColumn {
// 故意不提供 key,用来演示位置索引带来的问题
items(tasks) { task -> TaskRow(task) }
}
}
@Composable
private fun TaskRow(task: Task) {
var checked by remember { mutableStateOf(false) }
Row(
verticalAlignment = Alignment.CenterVertically,
modifier = Modifier
.fillMaxWidth()
.clickable { checked = !checked }
.padding(16.dp)
) {
Checkbox(checked = checked, onCheckedChange = { checked = it })
Text(task.title)
}
}
跑起来看着挺好。勾选顶部几项,滚到底部,再滚回顶部——勾选全没了。
第一反应通常是“remember 是不是有 bug”。不是。remember 工作得好好的,它只是忠实地履行了自己的契约:组合在,值就在;组合没了,值就没了。 问题在于,Lazy 列表会在你滚动的时候,主动把项的组合“弄没”。
这不是 bug,这是 Lazy 列表的生存方式。这一课要做的,就是把这种生存方式讲清楚:它为什么要回收、回收时发生了什么、rememberSaveable 能救回多少、以及为什么最终的答案往往不是“换个 API”,而是“把状态放到它该在的地方”。
一、Lazy 列表不是“会滚动的 Column”
很多人对 LazyColumn 的第一印象是“一个能滚的 Column”。这个印象是错的,而且错得挺关键。
Column 很老实:你把十个子项交给它,它就把十个都组合出来,不管这些子项在不在屏幕里。组合全在,状态也就全在。你往上滚、往下滚,它只是挪了挪位置,什么都没销毁。
LazyColumn 不是这样。它的核心思路是:屏幕上能看见的就那么几项,我为什么要组合全部? 一个项滚出“可见区域 + 预取缓冲”这个范围,它的组合就被彻底扔掉:remember 被遗忘,LaunchedEffect 被取消,DisposableEffect.onDispose 被调用,整个组合槽位被收回复用池。
注意,“扔掉”不是“暂停”,不是“藏起来”,是真的销毁。你下次滚回来,进入组合的是一个全新的组合实例,remember { mutableStateOf(false) } 会老老实实从 false 重新开始。勾选消失,根子就在这里。
为什么 Lazy 列表要这么狠?因为如果不这么干,一个一万项的列表就得组合一万个项,内存直接爆炸。回收是用“状态可能丢”换“内存不炸”,这是一笔交易,不是缺陷。
复用让这件事变得更微妙。被回收的槽位不会空着,它会分配给新进入视口的项。如果运行时不知道“这个槽位原来是谁的、现在是谁的”,它就只能靠位置索引来猜:第 3 个位置的项走了,第 3 个位置来了个新项,那就当它们是同一个组合身份的延续吧。
在静态列表里,这个猜测碰巧是对的。但一旦列表发生插入、删除、重排,位置索引就和逻辑身份对不上了。假设初始列表是 [A, B, C],用户在位置 0 勾选了 A;这时在头部插入一个新任务 N,列表变成 [N, A, B, C]。位置 0 现在是 N,运行时认为“位置 0 还是那个项”,把原来位置 0 的勾选状态交给了 N。结果就是:N 一出现就是勾选状态,A 的勾选丢了。
状态错位就是这么来的。根子不在 remember,而在“运行时靠位置猜身份”。
所以 Lazy 列表项状态问题的物理根源,一句话就能说清:状态活在组合槽位里,而组合槽位的生命周期不由项的“逻辑身份”决定,而由“是否在视口附近”和“槽位被分配给了谁”共同决定。
下面这张图把“项离开视口 → 组合被销毁 → 槽位被复用”的完整链路画出来:
flowchart TD
A["项进入可见区域 + 预取缓冲"] --> B["组合项,创建组合槽位"]
B --> C["remember 持有状态"]
C --> D{"项是否滚出可见区域?"}
D -- "否" --> C
D -- "是" --> E["dispose 组合:remember 遗忘、LaunchedEffect 取消"]
E --> F["组合槽位收回复用池"]
F --> G["槽位分配给新进入视口的项"]
G --> H{"是否有稳定 key?"}
H -- "无" --> I["按位置索引猜身份 → 状态错位"]
H -- "有" --> J["按逻辑身份追踪 → 状态跟随实体"]
要让状态跟着逻辑身份走,而不是跟着槽位走,需要两样东西:一个稳定的 key,和一个能在项离开组合后还记得住状态的机制。这两样,就是接下来两节的主角。
二、remember 和 rememberSaveable 在项里是两种命
在普通 Composable 里,remember 和 rememberSaveable 的区别是“跨配置变更和进程死亡”。但在 Lazy 项里,这个区别被一个更早发生的事件截断了:项离开组合。
remember 在项离开组合的那一刻,必然丢失。这不是“可能丢”,是“一定丢”,因为这是它的契约。所以 remember 在 Lazy 项里只适合放一种东西:项可见期间临时需要、不可见时丢了也无所谓的值。比如一个只在当前帧有效的测量结果,一个只在滚动动画进行中用的过渡值。任何“用户做了选择、希望滚回来还能看到”的状态,都不该用 remember。
那 rememberSaveable 呢?它确实改变了命运。官方文档说得很直白:列表里的有状态元素,滚出屏幕被回收时状态可能丢失,要在列表项里用 rememberSaveable 来保留它们。
@Composable
private fun TaskRow(task: Task) {
// 项被回收后,这个值会被接住,滚回来时恢复
var checked by rememberSaveable { mutableStateOf(false) }
Checkbox(checked = checked, onCheckedChange = { checked = it })
}
把 TaskRow 里的 remember 换成 rememberSaveable,勾选消失的问题就修好了。这是 codelab 里最小的修复。
但它是怎么“保留”的?这里有一个专门的机制,叫 LazySaveableStateHolder。你可以把它想象成一个临时寄存柜:项被 dispose 时,rememberSaveable 的值被从这个槽位里摘出来,存进寄存柜;项再次进入组合时,寄存柜把之前存的值还回去,rememberSaveable 的 init 不会重新跑,而是用还回来的值初始化。这个机制只对 rememberSaveable 生效,remember 不在服务范围内。同一个项里两种写法并存时,勾选滚回来还在,hover 滚回来就没了——这不是 bug,是两种契约的差别。
LazySaveableStateHolder 的存取流程可以这样理解:
sequenceDiagram
participant Item as "列表项组合"
participant Holder as "LazySaveableStateHolder"
participant Registry as "父 SaveableStateRegistry"
participant Bundle as "Bundle"
Item->>Holder: "项 dispose,rememberSaveable 值被摘出"
Holder->>Holder: "按 key 存入寄存柜"
Item->>Holder: "项重新进入组合,按 key 取回"
Holder-->>Item: "还回状态,init 不重跑"
Registry->>Holder: "performSave 触发"
Holder->>Holder: "移除已离开组合的项状态"
Holder->>Registry: "只提交当前可见项的状态"
Registry->>Bundle: "写入 Bundle"
不过,这个寄存柜有两条硬边界,越过了它就等于没存。
第一条:rememberSaveable 在项里依然受 Bundle 的类型和容量约束。 第8课讲的所有规则原封不动地适用:autoSaver 只接受原始类型和 Parcelable / Serializable;自定义 data class 得配 Saver;大对象会带来 TransactionTooLargeException 的风险。官方还专门警告过,别用 rememberSaveable 存需要长时间序列化的大量数据或复杂结构。它不是“升级版的 remember”,它还是一个受存储介质管着的保存通道。
第二条,也是更容易被忽略的一条:项的 key 本身得能被存进 Bundle。 因为 Lazy 列表要跨配置变更、跨进程死亡恢复“哪个项的状态属于哪个项”,这个对应关系得靠 key 来建立。key 本身进不了 Bundle,这个对应关系就断了。
// 错误:自定义对象没实现 Parcelable,恢复会静默失效(退化为重新初始化)
data class TaskKey(val id: Long, val source: String)
LazyColumn {
items(tasks, key = { TaskKey(it.id, it.source) }) { task ->
TaskRow(task) // 不崩溃,但恢复不了
}
}
// 修复:直接用可保存的原始类型
LazyColumn {
items(tasks, key = { it.id }) { task -> TaskRow(task) }
}
官方文档的原话是:这个 key 在 Android 上必须能通过 Bundle 保存,以便项内的 rememberSaveable 在 Activity 重建甚至项离开又返回时能够恢复。
这种失败最难查,因为你以为用了 rememberSaveable 就该恢复,结果它安安静静地什么都没做——不崩溃,不报错,就是静默失效,退化为重新初始化。这一节把第5课的组合身份和第8课的 Bundle 边界接上了:Lazy 项的 key 是一个组合身份标识,而这个标识本身,得能通过 Bundle 的旅行。
三、寄存柜也有容量:它只救“保存那一刻还看得见”的项
上一节说 LazySaveableStateHolder 是个寄存柜,能接住滚出去的项的状态。听起来挺美,但寄存柜的容量是有限的。它的源码注释写得很直白:这个实例在父 SaveableStateRegistry 触发 performSave 时,只保存当时可见的项,以节省 Android Bundle 中使用的空间,避免因 TransactionTooLargeException 而崩溃。
这句话得掰成两层读。
第一层:平时滚来滚去,它救得挺勤快。 项滚出视口、离开组合,状态被接住;滚回来,还给你。codelab 里那个勾选消失的例子,换成 rememberSaveable 就能修好,靠的就是这一层。
第二层:真到了要“存盘”的那一刻,它只救当时还看得见的项。 这个“存盘”时刻,就是 performSave 被触发的时候——大概在 onSaveInstanceState 的窗口里,也就是配置变更前或者进程可能被回收前。源码的实际做法是:先把“已经离开组合的项”的状态从寄存柜里移除,再调用父注册表保存,这样最终进入 Bundle 的就只剩当前仍在组合中(即可见)的项。
为什么这么设计?不是偷懒,是故意的。你想,一个用户滚过好几百项的列表,如果每一项的状态都存进 Bundle,那就是几百份状态。Bundle 走 Binder 事务,容量有限,这么堆下去,TransactionTooLargeException 不是“可能发生”,是“必然发生”。Lazy 列表的选择是:只保留可见项,用一部分状态的丢失,换整个列表的可恢复性。
这个取舍对“什么状态该放项里”提了一个更严格的要求:项内的 rememberSaveable 只适合放“用户滚回来还想看到”的轻量状态——勾选、展开、文本草稿。它不适合放“用户滚走之后,进程死了也必须活下来”的关键数据。后者得往上提,提到 ViewModel 或 SavedStateHandle,让它的生命周期不再被“保存那一刻是否可见”牵着走。
把“平时滚动”和“存盘时刻”两种场景放在一起对比,边界就很清楚了:
flowchart LR
subgraph S1["平时滚动:救得勤快"]
A1["项滚出视口"] --> A2["状态被寄存柜接住"]
A2 --> A3["滚回来 → 状态恢复"]
end
subgraph S2["performSave 时刻:只救可见项"]
B1["触发 performSave"] --> B2["移除已离开组合的项状态"]
B2 --> B3["只保存当前可见项进 Bundle"]
B3 --> B4["进程死亡后:仅可见项可恢复"]
end
四、key 管纵向,contentType 管横向
rememberSaveable 解决的是“离开组合后状态还在不在”,key 解决的是另一个问题:“状态跟的到底是不是同一个项”。
key 的本质,是告诉 Lazy 列表:这个项的逻辑身份是什么,而不是它在列表里排第几。 没有 key 时,身份默认是位置索引,头部插入就会让状态错位(第一节已经演示过)。有了稳定唯一的 key,运行时就能精确追踪“同一个逻辑项”在重排里的移动,把状态带给它,而不是带给它经过的位置。
LazyColumn {
items(tasks, key = { it.id }) { task -> TaskRow(task) }
}
key 的三个条件,第8课铺过,这里再强调一次,因为它们在 Lazy 项里不是建议,是正确性前提。
稳定:同一个逻辑实体,在重排里保持同一个 key。每次重组都生成随机 UUID,状态连续性就断了。唯一:同一个列表里不能有两个项用同一个 key;如果确实需要“分类 + id”这种复合身份,用组合键 "${it.category}/${it.id}"。可保存:得能进 Bundle,优先用 Int 或 Long,别用没实现 Parcelable / Serializable 的自定义数据类。
三者缺一,恢复就会以不同的方式失效。
contentType 是另一条容易被忽略的边界。它不管“这是不是同一个项”,它管“这个项该进哪个复用池”。官方性能指南说得很清楚:contentType 让 Compose 在回收同视觉类型的项时,复用项的组合和节点槽位,显著减少快速滚动时的布局膨胀开销。
想象一个混排列表,混着标题、正文、广告。这三者的内部组合结构天差地别,但如果没有 contentType,它们可能被分到同一个复用池。运行时把标题的槽位交给广告去复用时,内部组合对不上,就得全部重新组合,还可能把状态搅混。给每种结构一个 contentType,复用就只在“长得像”的项之间发生。
LazyColumn {
items(
items = feedItems,
key = { it.id },
contentType = { item ->
when (item) {
is Header -> "header"
is Post -> "post"
is Ad -> "ad"
}
}
) { item -> /* 按类型渲染 */ }
}
所以你可以这么记:key 管的是纵向的身份连续性——同一个项在时间里怎么移动;contentType 管的是横向的池子划分——不同结构的项别互相污染。两者是正交的边界,谁也替代不了谁。
key 与 contentType 的正交关系,可以用一张二维图表示:
flowchart TD
L["LazyColumn 列表"] --> K["key:纵向身份连续性"]
L --> C["contentType:横向复用池划分"]
K --> K1["稳定:重排中保持同一 key"]
K --> K2["唯一:列表内不重复"]
K --> K3["可保存:能进 Bundle"]
C --> C1["结构相同的项才互相复用"]
C --> C2["避免标题槽位交给广告"]
K1 --> R["状态跟着逻辑实体走"]
K2 --> R
K3 --> R
C1 --> P["减少重新组合与状态混淆"]
C2 --> P
五、最深的边界:项状态不属于项
前面四条都是技术边界。最深的一条,是架构性的,也是这一课标题的来源:项状态不属于项。
这句话听着有点绕,其实就是一个所有权问题。一个列表项的组合位置,是易失的——它会被回收、复用、重新分配。你把关键状态放在项的组合位置里,就等于把状态交给了一个随时会消失的容器。正确的所有权应该跟着数据源走:哪个实体拥有这个状态,状态就归哪个实体。
判断标准很朴素:如果这个项被滚出视口、滚回来,或者在列表里被挪到了别的位置,状态应该跟着“这个逻辑实体”走,还是跟着“这个屏幕位置”走?
一个特别典型的越界写法,是在项里用 remember { mutableStateOf(product.isFavorite) } 保存收藏状态。父级一重组,或者列表一重排,remember 被重置,用户眼睁睁看着收藏“跳回去”了。而且,即使换成了 rememberSaveable,业务状态也没同步回数据源,下一次从服务器刷新时仍然是旧的。
正确方向是把状态的所有权提上去:父级持有 product.id 和收藏集合,项只接收 isFavorite 和 onToggle,点击时调用 onToggle(product.id)。这时候把 remember 换成 rememberSaveable 不是正确答案——它能让状态在回收后存活,但列表数据源一变,状态的正确来源仍然是数据源,不是项里的副本。
那什么状态才适合留在项里?纯 UI 元素状态,比如这一项在列表里的展开/折叠、用户输入到一半的草稿。这些状态只和“这一项在列表里的展示形态”有关,换个位置、同一个实体带着它们走也说得通;它们是轻量的 UI 状态,Bundle 装得下,用户滚回来还想看到。这类状态留在项里,用 rememberSaveable,是正确的。
这条边界,其实就是第8课“状态恢复 vs 状态持久化”在列表场景里的延伸:rememberSaveable 在项里管UI 元素状态的临时恢复(勾选、展开、草稿),ViewModel / SavedStateHandle 管业务状态的所有权和持久化(收藏、选中、已读)。把两者混在一起,要么业务状态在滚动里丢了,要么 Bundle 被业务数据撑爆。
六、前瞻边界:测量也不是一次性的
这一课主要讲“状态在回收里的边界”,但 Lazy 列表还有一条更底层的边界,这里先埋个伏笔,第10课专门拆。
LazyColumn 内部用的是 SubcomposeLayout。标准的 Compose 流程是“先组合,再测量”,但 Lazy 列表必须反着来:它得先知道“有多少空间、哪些项可见”,才能在测量过程中临时 subcompose 需要显示的项。这意味着项的测量可能发生在组合之外、可能发生好几次、可能在帧与帧之间被打断。
这条边界会带来一堆普通 Column 里不存在的现象:LazyListState.layoutInfo 首帧可能不完整;在项里用 Modifier.onSizeChanged 读尺寸,滚动中可能反复触发;在项里根据父级约束做布局计算,可能读到过渡态的值。
这不是第9课的主题,但它提醒我们一件事:状态不只在回收里被销毁,也在测量里被反复触碰。第10课会专门讲这条线。
七、决策框架:一个状态该放 Lazy 项的哪一层
把前面的边界收成一个可以照着走的判断流程。
第一问:这个状态丢了,用户滚回来还想看到吗? 不想——用 remember,它本来就是临时的。想——往下走。
第二问:这个状态的所有权,是“屏幕位置”还是“逻辑实体”? 如果换个位置、同一个实体就该带着它走,它属于逻辑实体,提到数据源层。如果它只跟“这个位置的展示形态”有关(比如这一项在列表里的展开/折叠),可以留在项里。
第三问:留在项里的状态,需要跨配置变更和进程死亡活下来吗? 需要——用 rememberSaveable,同时接受 Bundle 的类型和容量约束。不需要——用 remember,但心里清楚它在项被回收时一定丢。
第四问:用 rememberSaveable 的状态,在 performSave 那一刻会不会已经不可见了? 如果它必须在进程死亡后活下来,就别指望项内的 rememberSaveable,因为 LazySaveableStateHolder 只保存那一刻可见的项。把它提到 SavedStateHandle 或持久化层。
第五问:key 稳定吗、唯一吗、能进 Bundle 吗? 不稳定或不唯一,状态会错位;进不了 Bundle,恢复会静默失效。两条都是正确性问题,不是优化问题。
第六问:列表里混排了不同结构的项吗? 混了就上 contentType,让复用只在结构兼容的项之间发生。
把六问收成一张可以直接照着走的决策流程图:
flowchart TD
S["一个状态该放哪一层?"] --> Q1{"丢了用户滚回来还想看到吗?"}
Q1 -- "不想" --> A1["用 remember(临时值)"]
Q1 -- "想" --> Q2{"所有权是屏幕位置还是逻辑实体?"}
Q2 -- "逻辑实体" --> A2["提到数据源层 / ViewModel"]
Q2 -- "屏幕位置" --> Q3{"需要跨配置变更和进程死亡存活吗?"}
Q3 -- "不需要" --> A3["用 remember(接受回收即丢)"]
Q3 -- "需要" --> Q4{"performSave 那一刻还可见吗?"}
Q4 -- "不一定" --> A4["提到 SavedStateHandle 或持久化层"]
Q4 -- "能保证可见" --> A5["用 rememberSaveable"]
A2 --> Q5{"key 稳定、唯一、可进 Bundle 吗?"}
A5 --> Q5
Q5 -- "否" --> A6["修正 key:正确性前提"]
Q5 -- "是" --> Q6{"混排了不同结构的项吗?"}
Q6 -- "是" --> A7["补 contentType 划分复用池"]
Q6 -- "否" --> A8["当前方案即可"]
八、习题:12 道 LazyList 状态边界检验
第 1 题(选择)
一个 LazyColumn 的项内部用 remember { mutableStateOf(false) } 保存勾选状态。用户勾选顶部项,滚动到底部再滚回顶部,勾选状态消失。根本原因是:
A. remember 的初始值写错了
B. 项滚出视口后离开组合,组合槽位被回收,remember 的值随之被遗忘
C. LazyColumn 没有正确调用 remember
D. 勾选状态需要是 Parcelable 才能保留
参考答案:B。
解读: Lazy 列表只组合可视区域附近的项。项滚出窗口时组合被 dispose,而 remember 的契约是“组合还在时值还在”,所以值被遗忘。时序是:组合被 dispose → remember 被遗忘 → 槽位回到复用池 → 滚回来时 remember 从初始值重新开始。这不是 remember 用错了,而是 Lazy 回收机制的正常后果。C 错在把锅甩给了 remember;D 错在混淆了两件事:Parcelable 是 rememberSaveable 进入 Bundle 的条件,跟 remember 丢失的根因没关系。
第 2 题(判断)
把 Lazy 项里的 remember 换成 rememberSaveable,这个项的状态就能在项滚出视口后一直保留,滚回来一定还在。
参考答案:错(有条件成立)。
解读: 平时正常滚动,rememberSaveable 确实能被 LazySaveableStateHolder 接住,滚回来恢复。但 LazySaveableStateHolder 只在父注册表触发 performSave 时保存当时仍可见的项。如果项在 performSave 那一刻已经滚出视口,它的状态进不了最终的 Bundle,进程死亡后就恢复不了。所以准确的说法是:rememberSaveable 救得了“滚出又滚回”,救不了“滚出后进程死了还想恢复”。
第 3 题(代码分析)
下面代码在列表发生头部插入后,勾选状态错位到了错误的项上。请指出原因并修复。
LazyColumn {
items(tasks) { task -> TaskItem(task) }
}
@Composable
private fun TaskItem(task: Task) {
var checked by remember { mutableStateOf(false) }
}
参考答案: 两个问题叠在一起。第一,items(tasks) 没提供 key,Lazy 列表默认按位置索引识别项。头部插入一个 N 之后,位置 0 变成 N,运行时把“原来位置 0 的状态”交给了 N,N 显示勾选,A 的勾选丢失。第二,项里用的是 remember,滚动回收时状态也会丢。
修复:用稳定唯一的 task.id 当 key,再根据状态语义决定要不要换成 rememberSaveable:
LazyColumn {
items(tasks, key = { it.id }) { task -> TaskItem(task) }
}
解读: key 解决的是“状态跟哪个逻辑实体”,remember vs rememberSaveable 解决的是“项离开组合后状态还在不在”。这是两条正交的边界,得同时处理。只加 key 不加 rememberSaveable,滚动回收照样丢;只加 rememberSaveable 不加 key,重排时状态照样错位。
第 4 题(简答)
为什么 LazySaveableStateHolder 被设计成“只保存 performSave 时可见的项”,而不是保存所有曾经可见过的项?
参考答案: 因为保存介质是 Bundle,容量有限。假设每项状态约 100 字节,300 项曾经可见就是 30KB,已经接近官方建议的 50KB 安全线;1000 项就是 100KB,TransactionTooLargeException 风险极高。源码注释说得很明白,这个设计是为了“节省 Android Bundle 中使用的空间,避免因 TransactionTooLargeException 而崩溃”。LazySaveableStateHolder 用“只保留可见项”换整个列表在恢复时的可用性——这是一条故意的容量边界,不是功能缺失。
解读: 这道题把第8课的 Bundle 容量边界和 Lazy 列表的恢复机制接上了。rememberSaveable 在项里不是“更持久的 remember”,它仍然受介质管着;Lazy 列表对这个约束的回应是缩小保存范围,而不是硬突破容量。
第 5 题(判断)
key 只要是唯一的,就一定适合用作 Lazy 项的 key。
参考答案:错。
解读: key 还得稳定和可保存到 Bundle。一个每次都生成新值的唯一 key(比如 UUID.randomUUID())会破坏状态连续性,导致每次重组都像换了一个项;一个进不了 Bundle 的 key(比如没实现 Parcelable 的自定义数据类)会让跨配置变更的恢复静默失效。唯一性只是 key 的必要条件,不是充分条件。
第 6 题(选择)
key 和 contentType 在 Lazy 列表中的分工是:
A. 两者都决定“这是不是同一个项”
B. key 决定逻辑身份和状态跟随,contentType 决定复用池的划分
C. contentType 决定逻辑身份,key 决定复用池
D. 两者都可以省略,Lazy 列表会自动推断
参考答案:B。
解读: key 管纵向的身份连续性:同一个逻辑项在重排中移动时,状态跟着它走。contentType 管横向的池子划分:结构不同的项(标题、正文、广告)不该互相复用槽位,否则会产生不必要的重新组合和状态混淆。两者处理的是不同维度的边界,互相替代不了。
第 7 题(代码分析)
一个列表项内用 remember { mutableStateOf(product.isFavorite) } 保存收藏状态。父级重组时,收藏状态被重置为 product.isFavorite 的初始值。问题在哪里?正确的方向是什么?
参考答案: 问题出在状态的所有权放错了位置。收藏状态是业务数据,所有者应该是持有 product.id 和收藏集合的数据源,不是项的组合位置。父级重组会重建项的组合,remember 跟着重置。正确方向是把收藏状态提到父级(或 ViewModel),项只接收 isFavorite 和 onToggle,状态由数据源驱动。把 remember 换成 rememberSaveable 不是正确答案——它能让状态在回收后存活,但列表数据源一变,状态的正确来源仍然是数据源,不是项里的副本。
解读: 这道题对应第五节的架构边界。“项状态不属于项”的判断标准不是“这个状态重不重要”,而是“它的所有权是屏幕位置还是逻辑实体”。业务状态归逻辑实体,就该提出去;只有纯 UI 元素状态(展开、勾选、草稿)才适合留在项里。
第 8 题(简答)
一个项内的 rememberSaveable 状态在进程死亡后没有恢复。可能的原因有哪些?请至少列出两条。
参考答案: 第一,该项在 performSave 触发时已经滚出视口、不在组合里,LazySaveableStateHolder 没保存它。第二,key 进不了 Bundle(比如自定义对象没实现 Parcelable),项状态和 key 的关联恢复静默失败。第三,rememberSaveable 保存的对象类型不在 Bundle 白名单里,又没提供 Saver,保存时被跳过。第四,组合位置在恢复后发生了结构性变化(比如项被包进了不同层级的 key(...) 里),按组合身份匹配失败。
解读: 恢复失败不一定只有一个原因。LazySaveableStateHolder 的容量边界、key 的可保存性、rememberSaveable 的类型约束、组合身份的变化,每一条都可能单独导致失败。排查时得逐条对照,不能假设“用了 rememberSaveable 就该恢复”。
第 9 题(判断)
在 LazyColumn 的项里,LaunchedEffect(Unit) 的协程会在项滚出视口时被取消,但用 rememberSaveable 保存的状态不会因此丢失。
参考答案:对。
解读: 项离开组合时,LaunchedEffect 随组合一起被取消,这是 effect 的生命周期契约(第4课)。rememberSaveable 的状态被 LazySaveableStateHolder 接住(前提是它在保存窗口内可见,或者正常滚回),不会随 effect 取消而丢失。两条生命周期是分开的:effect 跟着组合走,rememberSaveable 跟着保存通道走。
第 10 题(选择)
一个用户滚过 300 个项的长列表,每个项里都有一个 rememberSaveable 保存的文本草稿。用户滚到第 300 项时,进程被系统杀死。恢复后,最可能的情况是:
A. 300 个草稿全部恢复
B. 只有进程被杀时仍在可见区域附近的草稿恢复,其余丢失
C. 所有草稿都丢失,因为 rememberSaveable 不支持 Lazy 项
D. 恢复行为取决于草稿的文本长度
参考答案:B。
解读: LazySaveableStateHolder 只保存 performSave 那一刻可见的项。用户在第 300 项时,可见区域大概是 295 到 299,这些项的状态写入 Bundle;0 到 294 的状态先被移除,不写入。进程被杀后恢复,只有 295 到 299 的草稿还在。这正好说明:项内的 rememberSaveable 适合轻量的 UI 草稿,不适合承载“用户滚走之后仍然必须在进程死亡后存活”的关键数据;后者应该提到 SavedStateHandle 或持久化层。
第 11 题(代码分析)
下面代码为一个混排列表提供了 key,但没有提供 contentType。可能有什么问题?
LazyColumn {
items(feedItems, key = { it.id }) { item ->
when (item) {
is Header -> HeaderItem(item)
is Post -> PostItem(item)
is Ad -> AdItem(item)
}
}
}
参考答案: 问题出在复用池。没有 contentType 时,Header、Post、Ad 这三种结构完全不同的项可能被分到同一个复用池。运行时把 Header 的槽位交给 Ad 去复用时,内部组合结构不兼容,就会产生不必要的重新组合和潜在的状态混淆。为不同结构提供不同的 contentType,可以让 Compose 只在同视觉类型的项之间复用组合和节点槽位。key 保证了每个项的逻辑身份是对的,但它不保证“复用槽位时结构也是对的”——后者是 contentType 的职责。
第 12 题(综合简答)
有人说:“LazyColumn 里的 remember 老丢状态,全都换成 rememberSaveable 就行了。”评价这个说法,并说明一个更准确的项状态策略应该包含哪些层次。
参考答案: 这个说法方向对,但把问题简化成了“换个 API”。全换 rememberSaveable 会同时撞上三条边界。
第一,LazySaveableStateHolder 只保存 performSave 时可见的项,滚走的关键状态仍然可能在进程死亡后丢失。第二,rememberSaveable 受 Bundle 的类型和容量约束,业务数据和大对象不适合进这个通道。第三,业务状态的所有权本来就不属于项的组合位置,换成 rememberSaveable 只是延长了错误所有权的存活时间,没解决“数据源变化时状态该由谁驱动”的问题。
更准确的策略分三层:纯 UI 元素状态(展开、勾选、草稿)留在项内,用 rememberSaveable,并接受可见性边界;业务状态(收藏、选中、已读)提到持有实体标识的父级或 ViewModel,由数据源驱动;必须跨进程死亡存活的关键输入放在 SavedStateHandle 或持久化层,不依赖项的组合位置。同时,key 必须稳定、唯一、可保存;混排列表应该提供 contentType。
解读: 这道题把第8课的“恢复 vs 持久化”和第5课的“组合身份”收拢到 Lazy 列表的具体场景里。rememberSaveable 在项里是正确工具,但它只负责它该负责的那一层。把它当成万能替换,是用一个局部修复掩盖三个不同层次的边界问题。
九、本节课知识点总结
回收的物理边界。 Lazy 列表只组合可视区域附近的项;项离开窗口时组合被 dispose,remember 被遗忘,LaunchedEffect 被取消。状态丢失的根因是组合槽位被回收,不是 remember 用法错误。
rememberSaveable 的时间边界。 在 Lazy 项里,rememberSaveable 能接住“滚出视口、离开组合”的状态,并在滚回时恢复。但它仍然受 Bundle 的类型和容量约束;key 必须可保存到 Bundle,否则恢复静默失效。
LazySaveableStateHolder 的容量边界。 它在 performSave 之前会先移除已离开组合的项的状态,使最终保存进 Bundle 的只有当时仍可见的项,以节省 Bundle 空间、避免 TransactionTooLargeException。项内的 rememberSaveable 救得了“滚出又滚回”,救不了“滚出后进程死亡”。
身份边界。 key 决定状态跟随哪个逻辑实体,必须稳定、唯一、可保存;contentType 决定复用池的划分,让结构不同的项不互相污染。两者是正交的边界,不能互相替代。
架构边界。 项状态不属于项。纯 UI 元素状态(展开、勾选、草稿)适合留在项内用 rememberSaveable;业务状态(收藏、选中、已读)应提到数据源层,由逻辑实体所有权驱动;必须跨进程死亡存活的关键输入归 SavedStateHandle 或持久化层。
前瞻边界。 Lazy 列表的测量由 SubcomposeLayout 按需、分帧完成,项的测量可能发生在组合之外、可能多次发生。这是第10课的主题,但它提醒我们:项状态不只在回收里被销毁,也在测量里被反复触碰。
决策框架。 六问:滚回来是否应该看到、所有权是位置还是实体、是否需要跨进程存活、保存时是否可见、key 是否稳定可保存、是否混排不同结构的项。
一句话收束: 第5课回答“组合身份由什么定义”,第7课回答“在哪一层读取”,第8课回答“值能活多久、活在哪个介质里”。这一课回答的是:当一个值活在列表项的组合位置里,而组合位置本身会被回收和复用,状态的生命周期就不能再由项来定义了。 remember 在项里只能活在“项可见”的窗口里;rememberSaveable 把窗口扩展到“保存那一刻可见”;只有把状态提到逻辑实体层,才能让它的生命周期彻底脱离视口和槽位的摆布。
项是视图,不是所有者。状态应该跟着实体走,而不是跟着槽位走。
十、下期预告
第10课:LazyList 的布局与测量边界——SubcomposeLayout、LazyListState 与“为什么你的列表会在测量阶段闪烁”
第9课处理的是“项状态在回收与复用中的边界”。但 Lazy 列表还有一条更底层的边界没拆:它的布局和测量不是一次性完成的,而是按需、分帧、可中断的。
LazyColumn 内部用 SubcomposeLayout——先测量“有多少空间”,再在测量过程中临时 subcompose 需要显示的项。这意味着项的测量可能发生在组合之外、可能多次发生、可能在帧与帧之间被打断。这条边界会带来一堆普通 Column 里不存在的现象:LazyListState.layoutInfo 首帧可能不完整;在项里用 Modifier.onSizeChanged 读尺寸,滚动中可能反复触发;在项里根据父级约束做布局计算,可能读到过渡态的值。
下一课拆三件事:SubcomposeLayout 的测量周期怎么决定 Lazy 项的布局时机;LazyListState 的哪些字段是“可靠的”、哪些是“过渡的”;以及为什么“在 Lazy 项里做基于尺寸的布局决策”要特别小心阶段和时序。
第9课讲的是状态在回收中的边界,第10课讲的是测量在时间中的边界。下期见。