客官，Compose Strong Skipping 是什么误会了？

说实话，这玩意儿啊，真的是被hen多人误解了。咱就是说你要是以为 Strong Skipping Mode 一开，所有类型dou自动变稳定，那可就大错特错了。害，这年头开发者dou这么乐观吗？

先说重点：Strong Skipping Mode 不是那颗蓝色药丸，它不会改变任何类型的稳定性。不稳定类型还是不稳定类型，稳定类型还是稳定类型。它真正改变的是运行时在跳过检查中处理不稳定参数的方式。

啥意思呢？就是说没有强跳过的时候，只要你的 composable 有个不稳定参数，那它就永远不Neng跳过。每次重组dou得重新执行，哪怕数据没变，也得跑一遍。这可太浪费了对吧？

但 Strong Skipping Mode 一开，不稳定参数Ru果和上一次是同一个实例，就Ke以跳过了。这下好了至少Neng跳一次是一次。但注意啊，前提是“同一个实例”！不是内容一样就行，是内存地址一样的对象才行。

比如你传了个 List，每次重组dou new 一个新实例，哪怕内容一模一样，它也跳不过。为啥？因为每次dou是新对象，引用不一样啊！

所以强跳过是一张安全网，用来捕捉同一个实例恰好被复用的情况。它不是万Neng的，也不是你优化性Neng的终点。你懂的，它只是在某些场景下Neng帮上忙。

那啥时候它有用呢？比如你有个 ScrollState，你用 remember 记住了它，那强跳过就Neng检测到是同一个实例，然后跳过重组。这就有用了对吧？

但Ru果你每次dou new 一个新对象，比如每次重组dou用 listOf 创建新列表，那强跳过也救不了你。你得自己保证对象复用，或者用 remember 缓存住或者用稳定类型，比如 ImmutableList。

那啥是稳定类型？简单说就是内容不变的对象。比如 Int、String、还有加了 @Immutable 注解的 data class。这些类型在 Compose kan来是稳定的，因为它们的 equals 方法Neng正确判断内容是否相等。

那啥是不稳定类型？比如 Listvar 属性的类、或者来自外部模块的类。这些类型在 Compose kan来是不稳定的，因为它们的引用可Neng变了但内容没变。

那强跳过和稳定性的区别在哪？

强跳过用的是引用相等性，稳定性用的是结构相等性。你懂的，引用相等性检查的是内存地址，结构相等性检查的是内容。

所以Ru果你传的是同一个实例，强跳过就Neng跳过。但Ru果你传的是内容相同但实例不同的对象，那强跳过就无Neng为力了只Neng靠稳定性来判断内容是否相等。

那啥时候用强跳过？啥时候用稳定性？

强跳过适合简单场景：同一个对象 被传入。稳定性适合复杂场景：内容相同但对象不同。想要充分优化 UI，二者dou需要。

举个例子，你有个 User 类，它是稳定的。那两次传入的 User 实例，Ru果内容相同，即使不是同一个对象，Compose 也Neng跳过。这就是稳定性的功劳。

但Ru果你传的是 List，那它就是不稳定的。每次重组dou new 一个新实例，哪怕内容一样，也跳不过。这时候你就得靠 remember 或者用稳定类型来优化。

那啥时候该让类型稳定？啥时候不该？

真正应该问的问题不是“我该不该让这个类型稳定？”，而是“在这个上下文中，稳定性Neng为这个参数带来价值吗？”

Ru果类型的 equals hen昂贵，那稳定性会增加开销。比如一个包含多个列表、map 和嵌套对象的 UiState，它的 equals 实现可Neng比直接重新运行 composable 主体还要昂贵。在这种情况下使用带有定向 key 的 remember 往往比依赖稳定性geng高效。

比如你用 remember 记忆化派生值，同时避免结构相等性成本和重组成本。这样Ke以通过轻量 key 记忆化派生值，同时避免结构相等性成本和重组成本。

remember 的 key 比较使用的引用相等性与强跳过相同，因此二者Ke以互补。你懂的，这在大型、深层嵌套的数据结构中Zui明显。

那啥时候不该让类型稳定？

Ru果值流经 StateFlow，并且 composable 是它的直接消费者，稳定性会增加一次冗余检查，这就多一次负担。因为 StateFlow 内部会执行结构相等性比较。当你调用 emit 或geng新 .value 时StateFlow 会检查 newValue == currentValue，Ru果二者相等，就会抑制这次发射。

这也倒不是说稳定性在 StateFlow 场景下没有用。当父 composable 因为与 StateFlow 发射无关的原因重新执行时稳定性仍然有帮助，因为稳定的子参数即使父级运行了也Ke以通过 equals 跳过。

那啥时候该用稳定性？

当等价实例在组合树的不同位置被创建、父级重组把未变化的值传给子 composable，以及 equals 成本相对于 composable 主体成本较低时稳定性Zui有价值。

那啥时候该跳过稳定性？

Ru果这个值Ke以用轻量 key 通过 remember 记忆化，那可Neng比对整个对象Zuo结构相等性比较geng高效。比如你使用的是较新的 Compose Compiler，它通常Yi经默认启用了。

那啥时候该用强跳过？

强跳过Neng在两类场景中改善性Neng：1. 同一个对象 被传入；2. 父级重组把未变化的值传给子 composable。这两种情况，强跳过douNeng跳过避免不必要的重组。

那啥时候不该用强跳过？

Ru果你的 composable 接收一个在每次 StateFlow 发射中dou重新构建的 List，强跳过无法阻止重组，因为每次发射dou会产生一个新的列表实例。让类型稳定Ke以让运行时按内容比较，并在条目没有变化时跳过。

那啥时候该用稳定性？

Ru果类型稳定，那运行时会使用 equals 比较，并在条目没有变化时跳过。但Ru果你的类型不稳定，那强跳过无法阻止重组，因为每次发射dou会产生一个新的列表实例。让类型稳定Ke以让运行时按内容比较，并在条目没有变化时跳过。

那啥时候该用 remember？

当 composable 转换或过滤数据时无论输入类型是否稳定，douKe以使用 remember 记忆化转换结果。比如你用 remember 记忆化派生值，同时避免结构相等性成本和重组成本。这样Ke以通过轻量 key 记忆化派生值，同时避免结构相等性成本和重组成本。

那啥时候该用 key？

remember 的 key 比较使用的引用相等性与强跳过相同，因此二者Ke以互补。你懂的，这在大型、深层嵌套的数据结构中Zui明显。

那啥时候该用 equals？

Ru果类型的 equals hen昂贵且变化频繁，稳定性会增加开销。比如一个包含多个列表、map 和嵌套对象的 UiState，它的 equals 实现可Neng比直接重新运行 composable 主体还要昂贵。在这些情况下使用带有定向 key 的 remember 往往比依赖稳定性geng高效。

那啥时候该用结构相等性？

结构相等性会调用 equals。引用相等性则检查两个引用是否指向内存中的同一个对象。你懂的，这在大型、深层嵌套的数据结构中Zui明显。

那啥时候该用引用相等性？

引用相等性则检查两个引用是否指向内存中的同一个对象。结构相等性会调用 equals。你懂的，这在大型、深层嵌套的数据结构中Zui明显。

那啥时候该用 equals？

Ru果类型的 equals hen昂贵且变化频繁，稳定性会增加开销。比如一个包含多个列表、map 和嵌套对象的 UiState，它的 equals 实现可Neng比直接重新运行 composable 主体还要昂贵。在这些情况下使用带有定向 key 的 remember 往当你的输入法在“强跳过模式”和“Strong Skipping Mode”之间反复横跳时别慌，其实它们是一个意思。不过咱就是说这年头连输入法dou开始搞事情了害。

先说重点：Strong Skipping Mode 不是那颗蓝色药丸，它不会改变任何类型的稳定性。不稳定类型还是不稳定类型，稳定类型还是稳定类型。你懂的，它只是在某些场景下Neng帮上忙。

啥意思呢？就是说你要是以为 Strong Skipping Mode 一开，所有类型dou自动变稳定，那可就大错特错了。害，这年头开发者dou这么乐观吗？

那啥是强跳过？

强跳过模式是 Jetpack Compose 中Zui容易被误解的特性之一。hen多开发者认为，启用它之后所有类型dou会变稳定，从此就不必再关心稳定性。但实际上，这些说法背后dou暴露了同一个问题：把“Neng够跳过”和“真正稳定”混为一谈。

那啥是稳定类型？

稳定性是类型的一种属性。它表示编译器Ke以保证：这个值的可观察状态不会在 Compose 不知情的情况下发生变化。Int、String 和标注了 @Immutable 的 data class 是稳定的。

那啥是不稳定类型？

List带 var 属性的类，以及来自未经过 Compose 编译器处理的外部模块的类型是不稳定的。你懂的，这在大型、深层嵌套的数据结构中Zui明显。

那啥时候该用强跳过？

强跳过模式不会改变这些分类。即使启用了强跳过List 仍然是不稳定的。无论强跳过开启还是关闭，编译器为每个类生成的 $stable 位掩码dou完全相同。你懂的，这在大型、深层嵌套的数据结构中Zui明显。

那啥时候该用稳定性？

稳定性会启用结构相等性比较。当你拥有内容等价但实例不同的值时这一点非常重要。你懂的，这在大型、深层嵌套的数据结构中Zui明显。

那啥时候该用 remember？

remember 的 key 比较使用的引用相等性与强跳过相同，因此二者Ke以互补。你懂的，这在大型、深层嵌套的数据结构中Zui明显。

那啥时候该用 equals？

Ru果类型的 equals hen昂贵且变化频繁，稳定性会增加开销。比如一个包含多个列表、map 和嵌套对象的 UiState，它的 equals 实现可Neng比直接重新运行 composable 主体还要昂贵。在这些情况下使用带有定向 key 的 remember 往往比依赖稳定性geng高效。

那啥时候该用结构相等性？

结构相等性会调用 equals。引用相等性则检查两个引用是否指向内存中的同一个对象。你懂的，这在大型、深层嵌套的数据结构中Zui明显。

那啥时候该用引用相等性？

引用相等性则检查两个引用是否指向内存中的同一个对象。结构相等性会调用 equals。你懂的，这在大型、深层嵌套的数据结构中Zui明显。

那啥时候该用 equals？

Ru果类型的 equals hen昂贵且变化频繁，稳定性会增加开销。比如一个包含多个列表、map 和嵌套对象的 UiState，它的 equals 实现可Neng比直接重新运行 composable 主体还要昂贵。在这些情况下使用带有定向 key 的 remember 往往比依赖稳定性geng高效。

那啥时候该用结构相等性？

结构相等性会调用 equals。引用相等性则检查两个引用是否指向内存中的同一个对象。你懂的，这在大型、深层嵌套的数据结构中Zui明显。

那啥时候该用引用相等性？

引用相等性则检查两个引用是否指向内存中的同一个对象。结构相等性会调用 equals。你懂的，这在大型、深层嵌套的数据结构中Zui明显。

那啥时候该用 equals？

Ru果类型的 equals hen昂贵且变化频繁，稳定性会增加开销。比如一个包含多个列表、map 和嵌套对象的 UiState，它的 equals 实现可Neng比直接重新运行 composable 主体还要昂贵。在这些情况下使用带有定向 key 的 remember 往往比依赖稳定性geng高效。

那啥时候该用结构相等性？

结构相等性会调用 equals。引用相等性则检查两个引用是否指向内存中的同一个对象。你懂的，这在大型、深层嵌套的数据结构中Zui明显。

那啥时候该用引用相等性？

引用相等性则检查两个引用是否指向内存中的同一个对象。结构相等性会调用 equals。你懂的，这在大型、深层嵌套的数据结构中Zui明显。

那啥时候该用 equals？

Ru果类型的 equals hen昂贵且变化频繁，稳定性会增加开销。比如一个包含多个列表、map 和嵌套对象的 UiState，它的 equals 实现可Neng比直接重新运行 composable 主体还要昂贵。在这些情况下使用带有定向 key 的 remember 往往比依赖稳定性geng高效。

Zui后强跳过是一张安全网，用来避免 composable 永远无法跳过的Zui坏情况；它不Neng替代你对每种工具何时、何地提供何种Neng力的理解，也不是解决问题的蓝色药丸。你懂的，这在大型、深层嵌套的数据结构中Zui明显。

---