使用List<Interface>与LazyColumn全项重组，用实现类则智能跳过的原因？

问题现象 #

在Jetpack Compose开发中存在以下差异：

• 使用MutableList<ViewItemScratch>（接口类型）作为LazyColumn数据源时，向列表添加新元素会触发所有现有列表项重组
• 使用MutableList<TitleViewItemScratch>（具体实现类）时，仅新增项会重组，原有项会被智能跳过

示例代码 #

示例1：使用接口类型列表

val selectionState: MutableList<ViewItemScratch> = remember {
  mutableStateListOf()
}

示例2：使用具体实现类列表

val selectionState: MutableList<TitleViewItemScratch> = remember {
  mutableStateListOf()
}

核心代码定义 #

接口定义 #

interface ViewItemScratch {
  val identifier: Int
  val layoutId: Int

  @SuppressLint("NotConstructor")
  @Composable
  fun ViewItem(
    lazyItemScope: LazyItemScope? = null,
    rowScope: RowScope? = null,
    columnScope: ColumnScope? = null
  ) {
  }
}

实现类定义 #

data class TitleViewItemScratch(
  val index: Int,
  val text: StringResolver,
  val modifier: Modifier = Modifier,
  override val identifier: Int = text.hashCode()
) : ViewItemScratch {
  override val layoutId: Int
    get() = R.id.compose_view_title_view_item

  @Composable
  override fun ViewItem(
    lazyItemScope: LazyItemScope?, rowScope: RowScope?, columnScope: ColumnScope?
  ) {
    Text(
      modifier = modifier
        .fillMaxWidth()
        .wrapContentHeight()
        .padding(horizontal = 16.dp),
      text = text.resolve(),
    )
  }
}

测试用可组合函数 #

@Composable
private fun WithViewItemScratch() {
  val selectionState: MutableList<ViewItemScratch> = remember {
    mutableStateListOf()
  }
  val onButtonClick = remember {
    {
      selectionState.add(
        TitleViewItemScratch(
          index = selectionState.size + 1,
          text = UIString("Hello world #${selectionState.size + 1}"),
          identifier = selectionState.size + 1,
        )
      )
    }
  }
  Column {
    Button(onClick = {
      onButtonClick.invoke()
    }) {
      Text(text = "Add")
    }
    LazyColumn {
      items(
        items = selectionState,
        key = { viewItem: ViewItemScratch -> viewItem.identifier }
      ) { item ->
        item.ViewItem()
      }
    }
  }
}

编译器稳定性分析报告 #

接口方法的稳定性标注 #

restartable skippable fun ViewItem(
  unused stable lazyItemScope: LazyItemScope? = @static null
  unused stable rowScope: RowScope? = @static null
  unused stable columnScope: ColumnScope? = @static null
  unused <this>: ViewItemScratch
)

实现类的稳定性标注 #

stable class TitleViewItemScratch {
  stable val index: Int
  stable val text: StringResolver
  stable val color: CompassColor
  stable val typography: CompassTypography
  stable val modifier: Modifier
  stable val identifier: Int
  <runtime stability> = Stable
}

重组情况对比 #

使用List<接口>时的重组情况 #

使用具体实现类时的重组情况 #

原因解析 #

Jetpack Compose的重组跳过逻辑完全依赖于状态的稳定性推断：

1. 具体实现类的稳定性：TitleViewItemScratch是data class，所有属性都是稳定类型（Int、StringResolver、Modifier等均被Compose标记为稳定），因此编译器将其标记为stable。Compose可以通过实例的相等性判断（data class默认实现的equals）精准识别原有项是否未发生变化，从而跳过重组。
2. 接口类型的不确定性：ViewItemScratch作为接口，Compose在编译期无法确保所有实现类都是稳定的——即使当前列表中存储的是稳定的TitleViewItemScratch实例，接口类型本身无法提供稳定性保证。因此Compose会将ViewItemScratch视为不稳定类型。
3. LazyColumn的重组逻辑：当数据源是List<不稳定类型>时，Compose无法安全地假设原有项未变化，因此会触发全量重组；而当数据源是List<稳定类型>时，Compose可以利用稳定性判断，仅重组新增或发生变化的项。

内容的提问来源于stack exchange，提问作者Sagar Khurana