Android 科特林转型

我有这门课

    data class IntersectionWithWorkSpaceWidgetFeed(
        @Embedded
        val workSpace: WorkSpace,
        @Embedded
        val widget: WidgetMetaData,
        @Embedded
        val feed: Feed
)

现在，这是从3列之间的3路多对多联接返回的

所以这种关系就像这个工作区与widget有多对多的关系，而widget与Feed有多对多的关系

我从DB那里得到

 List<IntersectionWithWorkSpaceWidgetFeed>

我想知道这是否可以转化成这个POJO

data class MergedData(
        @Embedded
        val workSpace: WorkSpace,
        @Embedded
        val widget: List<WidgetData>,
        @Embedded
        val feed: List<Feed>
)

数据类合并数据(
@嵌入
val工作区：工作区，
@嵌入
val小部件：列表，
@嵌入
val提要：列表
)

它维护如上所示的关系。 任何朝正确方向的轻推都将受到极大的赞赏

编辑

此数据

List<IntersectionWithWorkSpaceWidgetFeed>

列表

我是从Room数据库中获取的，但我想了解，在我使用Kotlin转换从Room接收到数据后，是否可以对其进行转换

我只是想说清楚，我不想回来

 data class MergedData(
            @Embedded
            val workSpace: WorkSpace,
            @Embedded
            val widget: List<WidgetData>,
            @Embedded
            val feed: List<Feed>
    )

数据类合并数据(
@嵌入
val工作区：工作区，
@嵌入
val小部件：列表，
@嵌入
val提要：列表
)

直接从房间开始。

假设：

data class Workspace(val id: String)
data class Widget(val id: String)
data class Feed(val id: String)

data class RawData(
    val workspace: Workspace, 
    val widget: Widget, 
    val feed: Feed
)

data class MergedData(
    val workspace: Workspace, 
    val widgets: List<Widget>, 
    val feeds: List<Feed>
)

val raw = listOf(
    RawData(workspace = Workspace("1"), widget = Widget("A"), feed = Feed("2")),
    RawData(workspace = Workspace("1"), widget = Widget("A"), feed = Feed("3")),
    RawData(workspace = Workspace("1"), widget = Widget("B"), feed = Feed("3")),
    RawData(workspace = Workspace("1"), widget = Widget("B"), feed = Feed("2"))
)

数据类工作区（valid:String）
数据类小部件（val id:String）
数据类提要（val id:字符串）
数据类RawData(
val工作区：工作区，
val小部件：小部件，
val提要：提要
)
数据类合并数据(
val工作区：工作区，
val控件：列表，
val提要：列表
)
val raw=listOf(
RawData（工作空间=工作空间（“1”）、小部件=小部件（“A”）、提要=提要（“2”），
RawData（工作空间=工作空间（“1”）、小部件=小部件（“A”）、提要=提要（“3”），
RawData（工作空间=工作空间（“1”）、小部件=小部件（“B”）、提要=提要（“3”），
RawData（工作空间=工作空间（“1”）、小部件=小部件（“B”）、提要=提要（“2”））
)

你可以这样做：

val result: MergedData = 
    raw
        // First find the distinct workspaces
        .distinctBy { it.workspace.id }

        // Transform the results into just the workspaces
        .map { it.workspace }

        // Create a map of Workspace -> List<Widget> and List<Feed>
        .associateWith { workspace ->
            val rows = raw.filter { it.workspace.id == workspace.id }

            Pair(rows.map { it.widget }, rows.map { it.feed })
        }

        // Transform the map into the target "MergedData" type
        .map { entry ->
            MergedData(
                workspace = entry.key, 
                widgets = entry.value.first, 
                feeds = entry.value.second
            )
        }

val结果：合并数据=
未经加工的
//首先找到不同的工作空间
.distinctBy{it.workspace.id}
//将结果转换为工作空间
.map{it.workspace}
//创建工作区->列表和列表的映射
.associateWith{workspace->
val rows=raw.filter{it.workspace.id==workspace.id}
成对（rows.map{it.widget}，rows.map{it.feed}）
}
//将映射转换为目标“MergedData”类型
.map{entry->
合并数据(
workspace=entry.key，
widgets=entry.value.first，
feed=entry.value.second
)
}

---

然而，这将在给定的

工作区内产生重复的
小部件
和
提要
实例，但我相信如果这确实是一个问题，您会找到解决方法。
我想这个问题与房间有关？如果是这样的话，我建议添加标签并将您的问题澄清。是的，但是，在我从数据库获取数据之后，我正在寻找转换。在获得不同的工作空间之后，我在列表中添加了小部件并创建了合并的数据对象。谢谢
val result: MergedData = 
    raw
        // First find the distinct workspaces
        .distinctBy { it.workspace.id }

        // Transform the results into just the workspaces
        .map { it.workspace }

        // Create a map of Workspace -> List<Widget> and List<Feed>
        .associateWith { workspace ->
            val rows = raw.filter { it.workspace.id == workspace.id }

            Pair(rows.map { it.widget }, rows.map { it.feed })
        }

        // Transform the map into the target "MergedData" type
        .map { entry ->
            MergedData(
                workspace = entry.key, 
                widgets = entry.value.first, 
                feeds = entry.value.second
            )
        }