Android 在 compose 中做可变状态堆栈

是的，您可以彼此堆叠MuableState，并且读取State的作用域将重新组合，无论它是在哪种数据 struct 中，除非您将使用SnapshotStateMap丢失LinkedHashMap的排序，但您可以通过索引或排序参数进行排序.

你可以添加用户，为所选用户设置消息，或从 map 中删除用户，如下面的gif所示，重组将生效.

我做了一个样品来展示你的建议是有效的.

@Preview
@Composable
private fun TestNestedStructure() {
    val map = remember {
        mutableStateMapOf<User, SnapshotStateList<Message>>()
    }

    var user by remember {
        mutableStateOf<User?>(null)
    }

    var userName by remember {
        mutableStateOf("")
    }

    var message by remember {
        mutableStateOf("")
    }

    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(top = 20.dp)
    ) {
        Row(verticalAlignment = Alignment.CenterVertically) {
            OutlinedTextField(
                modifier = Modifier.weight(1f),
                value = userName,
                onValueChange = {
                    userName = it
                }
            )

            Button(onClick = {
                map[User(userName)] = mutableStateListOf()
            }) {
                Text(text = "Add User")
            }
        }

        Row(verticalAlignment = Alignment.CenterVertically) {
            OutlinedTextField(
                modifier = Modifier.weight(1f),
                value = message,
                onValueChange = {
                    message = it
                }
            )

            Button(onClick = {
                user?.let {
                    map[it]?.run {
                        add(Message(text = message))
                    }
                }
            }) {
                Text(text = "Add Message")
            }
        }

        LazyColumn(
            modifier = Modifier.fillMaxSize(),
            verticalArrangement = Arrangement.spacedBy(8.dp),
            contentPadding = PaddingValues(16.dp)
        ) {

            val users = map.keys.toList()

            items(
                items = users,
                key = { item ->
                    item.uuid
                }
            ) { currentUser: User ->
                Column(
                    modifier = Modifier
                        .shadow(2.dp)
                        .border(2.dp, getRandomColor())
                        .background(Color.White)
                        .fillMaxWidth()
                        .clickable {
                            user = currentUser
                        }
                        .padding(8.dp)
                ) {
                    Row {
                        Text(
                            modifier = Modifier.weight(1f),
                            text = currentUser.name
                        )
                        IconButton(onClick = {
                            map.remove(currentUser)
                        }) {
                            Icon(imageVector = Icons.Default.Remove, contentDescription = "remove")
                        }
                    }
                    map[currentUser]?.forEach { message ->
                        Text(
                            modifier = Modifier.padding(start = 10.dp),
                            text = message.text
                        )
                    }
                }
            }
        }
    }
}

数据类

data class Message(val text: String)

data class User(val name: String, val uuid: UUID = UUID.randomUUID())

还添加了边框，以查看每次重组时 colored颜色 随机变化的重组

fun getRandomColor() =  Color(
    red = Random.nextInt(256),
    green = Random.nextInt(256),
    blue = Random.nextInt(256),
    alpha = 255
)