主页 / 问题 / 1190426
Accepted
ripple
Asked:2021-10-15 02:46:07 +0000 UTC2021-10-15 02:46:07 +0000 UTC

从收藏中收集树

  • 772

如何从以下获得一棵树

文件夹结构

name       |  folderId     |  parentId
test 1     |  1            |  2
test 2     |  2            |  0 //значит это корневой уровень
name 3     |  3            |  0 //значит это корневой уровень 
name 4     |  4            |  1
name 5     |  5            |  1

对象结构

name         |  folderId   
object 1     |  1         
object 2     |  2       
object 3     |  3    
object 4     |  3         
object 5     |  3

我明白了

val folders = listOf(table1)
val objects = listOf(table2)

从这里你需要得到List<TreeItem>

test 2 -> {
    test 1 -> {     
        name 4
        name 5
    }
    object 1
}

name 3 -> {
    object 3
    object 4
    object 5
}

数据模型

sealed class TreeItem {
    class Folder(val folderInfo: TreeFolder, val childs: List<TreeItem>) : TreeItem()
    class Object(val item: Object) : TreeItem()
}

data class TreeFolder(val name: String, folderId: Long, parentId: Long)
data class Object(val name: String, folderId: Long)
java

2 个回答

  1. Best Answer

    这就是我得到树的方式

    fun getTreeObj(): Observable<List<TreeItem>> {
    return Observables.zip(
        treeFolderRepository.getTree(),
        objectRepository.getObjects()
            .toObservable()
            .distinctUntilChanged()
    ) { folders, objects -> Pair(folders, objects) }
        .observeOn(Schedulers.computation())
        .map { treeItems ->
            val objects = treeItems.second.toMutableList()
            val folders = treeItems.first
            
            if (folders.isEmpty()) {
                return@map objects.map { TreeItem.Object(item = it) }
            }

            val treeFolderMap: MutableMap<Long, TreeItem.Folder> =
                folders.map { TreeItem.Folder(folderInfo = it) }
                    .associateBy { it.folderInfo.folderId }
                    .toMutableMap()

            treeFolderMap.forEach { folder ->
                folder.value.childs.addAll(
                    objects.filter { it.first.folderId == folder.value.folderInfo.folderId }.let {
                        objects.removeAll(it)
                        it.map { TreeItem.Object(item = it) }
                    }
                )
            }

            val iterator = treeFolderMap.iterator()
            while (iterator.hasNext()){
                iterator.next().apply {
                    treeFolderMap[value.folderInfo.parentId]?.let { parentFolder ->
                        parentFolder.childs.add(value)
                        iterator.remove()
                    }
                }
            }
            return@map treeFolderMap.values.toList() as List<TreeItem>
        }
        .observeOn(AndroidSchedulers.mainThread())
}
    • 1

  2. 创建一个结构HashMap<String, TreeItem>，其中键是文件夹 ID，值是文件夹对象

    接下来，在其中添加所有文件夹。之后，循环遍历每个对象：

    1. 获取父文件夹 ID
    2. 在 HashMap 中按 ID 查找文件夹
    3. 你把当前元素作为一个孩子附加到那里，然后你遍历对象（对象）并坚持正确的父母。

    据List<TreeItem>我了解，根部的元素应该包含，你可以从一开始就声明这个对象，如果元素没有父级，那么在这里添加它。

    结果应该是这样的

    public List<TreeItem> func(List<TreeItemInfo> folders, List<TreeItemInfo> objects) {

    HashMap<String, TreeItem> foldersAndObjects =  new HashMap<>();
    List<TreeItem> root = new ArrayList<>();

    // Ложим папки в hashMap по ID
    for (TreeItemInfo folder : folders) {
        foldersAndObjects.put(folder.getId(), new TreeItem(folder));
    }

    // Устанавливаем связи родитель-ребенок для папок
    for (TreeItemInfo folder : folders) {
        String parentID = folder.parentID(); // Получаем ID родителя
        if (parentID == null) {
            // Если родителя нет ложем узел в корень
            root.add(new TreeItem(folder));
        } else {
            // Если ключ родителя есть, ищем его и присоединяем текущее значение как дочерний элемент
            foldersAndObjects.get(parentID).setChild(new TreeItem(folder));
        }
    }

    // Добавляем объекты в папки или в root
    for (TreeItemInfo object : objects) {
        String parentID = object.parentID();
        if (parentID == null) {
            root.add(new TreeItem(object));
        } else {
            foldersAndObjects.get(parentID).setChild(new TreeItem(object));
        }
    }

    // Возвращаем список корневых элементов
    return root;
}

    TreeItem- 它必须是一个具有值的结构：节点的值，到父节点和子节点的链接

    TreeItemInfo- 粗略地说，这是一个内容对象，您可以通过它获取父 ID 的信息，通过它的值可以创建一个 TreeItem 节点

    • 1

相关问题