有没有更有效的方法来更新 Jetpack Compose Kotlin 中的数据类属性？

对于视图，建议不要实例化新对象，尤其是在onDraw多次调用的函数中。

但是，在 Jetpack Compose 中，如果没有强跳过，则不鼓励使用具有可变参数的数据类，因为如果组合发生在具有不稳定参数的范围函数中，对于数据类的可变参数，或来自外部库的不稳定类，或项目中未扩展组合编译器的其他模块，它会触发该函数的重组。

https://developer.android.com/develop/ui/compose/performance/stability#mutable-objects

@Composable
fun ContactRow(contact: Contact, modifier: Modifier = Modifier) {
   var selected by remember { mutableStateOf(false) }

   Row(modifier) {
      ContactDetails(contact)
      ToggleButton(selected, onToggled = { selected = !selected })
   }
}

在上面的函数中，如果您使用具有可变参数的数据类，当选定的 Row 发生变化时，ContactDetails 也会发生变化，即使 Contact 没有改变，因为 ContactDetails 的输入不稳定。

而且，复制汽车等对象或具有原始值的数据或包含原始值或字符串的类不会产生明显的性能开销。您可能只需要考虑数据类是否包含大数据（例如 Bitmap 或 Base64 格式的图像），即使在这种情况下也必须进行深度复制。

但是 Kotlin 的copy函数是浅拷贝，如果你不创建新的实例，它只会复制对象的引用。

class Car(
    val id: Int = 0,
    val brand: String = "",
    var model: String = "",
    val year: Int = 2020,
)


data class MyListClass(val currentCar: Car, val items: List<Car>)

    @Preview
    @Composable
    fun TestCopy() {
        var myListClass by remember {
            mutableStateOf(MyListClass(
                currentCar = Car(),
                items = List(10) {
                    Car()
                }
            ))
        }
        Button(
            onClick = {
                val temp = myListClass
    
                myListClass = myListClass.copy(
                    currentCar = Car(id = 1)
                )
    
                println("temp===myListClass ${temp === myListClass}\n" +
                        "temp car===zmyListClass car ${temp.currentCar === myListClass.currentCar}\n" +
                        "temp list===myListClass ${temp.items === myListClass.items}")
            }
        ) {
            Text("Copy...")
        }
    }

印刷

 I  temp===myListClass false
 I  temp car===zmyListClass car false
 I  tem list===myListClass true

但是，如果您仍然希望通过不创建新的持有者对象来优化它，则可以使用带有 @Stable 注释的变量，而不需要强跳过，这将阻止函数的重组（如果当另一个State或父函数的输入的更改触发父范围内的重组时它的输入没有改变）。

当你的汽车属性发生变化时触发重组，例如

使用另一个 SnapshotMutationPolicy

MutableState 的默认策略是structuralEqualityPolicy()检查value您设置的新值是否==与上一个值相同。在数据类中，equals 由主构造函数的参数决定。

@Suppress("UNCHECKED_CAST")
fun <T> structuralEqualityPolicy(): SnapshotMutationPolicy<T> =
    StructuralEqualityPolicy as SnapshotMutationPolicy<T>

private object StructuralEqualityPolicy : SnapshotMutationPolicy<Any?> {
    override fun equivalent(a: Any?, b: Any?) = a == b

    override fun toString() = "StructuralEqualityPolicy"
}

通过更改此策略，您可以触发重组，即使使用相同的对象，例如

@Stable
data class Car(
    val id: Int = 0,
    val brand: String = "",
    var model: String = "",
    val year: Int = 2020,
)

@Preview
@Composable
fun CarScreen() {
    var car by remember {
        mutableStateOf(
            value = Car(),
            policy = neverEqualPolicy()
        )
    }

    Column {
        TextField(
            value = car.brand,
            onValueChange = { newBrand ->
                car = car.copy(brand = newBrand) // Using `copy()`
            },
            label = { Text("Brand") }
        )

        TextField(
            value = car.model,
            onValueChange = { newModel ->
//                car = car.copy(model = newModel) // Using `copy()`

                car = car.apply {
                    model = newModel
                }
            },
            label = { Text("Model") }
        )

        Text("Car brand: ${car.brand}, model: ${car.model}")
    }
}

正如您所看到的，通过neverEqualPolicy()策略，您可以通过分配相同的对象来触发重组。

它适用于任何类，您可以通过将计数器值设置为相同值来触发重组。

使用具有 MutableStates 的类

这种方法在 RememberXState 类和 Google 的 Jetsnack 示例中被广泛使用。

ScrollState，jetsnack 搜索状态

@Stable
class CarUiState(
    brand: String = "",
    model: String = "",
) {

    var id: Int = 0
    var year: Int = 2020

    var brand by mutableStateOf(brand)
    var model by mutableStateOf(model)
}

@Preview
@Composable
fun CarScreen() {

    val carUiState = remember {
        CarUiState()
    }
    Column {
        TextField(
            value = carUiState.brand,
            onValueChange = { newBrand ->
                carUiState.brand = newBrand
            },
            label = { Text("Brand") }
        )

        TextField(
            value = carUiState.model,
            onValueChange = { newModel ->
                carUiState.model = newModel
            },
            label = { Text("Model") }
        )

        Text("Car brand: ${carUiState.brand}, model: ${carUiState.model}, year: ${carUiState.year}")
    }
}

您只需将您的类划分为应该触发重组的属性和不需要的其他属性，因为它们在触发重组时也会发生变化。

在 gradle 文件集中启用强跳过

composeCompiler {
    // Configure compose compiler options if required
    enableStrongSkippingMode = true
}

因此上述更改将应用​​于类、lambda 和函数

可以跳过具有不稳定参数的可组合项。

不稳定参数通过实例相等性（===）进行相等性比较

稳定参数继续与 Object.equals() 进行比较以确定是否相等

可组合函数中的所有 lambda 都会自动被记住。这意味着您不再需要将 lambda 包装在 Remember 中，以确保跳过使用 lambda 的可组合函数。

请注意评论中的建议。如果您将其更改val为var，则会破坏应用程序的功能，因为 Compose 无法观察到可变变量的变化。

data class Car(
    val id: Int = 0, var brand: String = "", val model: String = "", val year: Int = 2020
)

onValueChange = { newBrand ->
    car.brand = newBrand   // This will not work!
}

因此，当您键入时，Jetpack Compose 将不再触发重新组合，并且您将不会在 中看到任何内容TextField。

在 Jetpack Compose 中，我认为将表单的所有值存储在单个 中是绝对常见的data class。您不必担心这里的性能问题，除非您真的遇到它们。