MapTreeStructure 导出为地图

Question

以下代码旨在将树数据结构导出到Map<String, String>中，以便以后更容易操作。但有趣的是 toString() 方法完美运行，但 toMap() 方法 缺少一个父 A，子 B 。有人知道吗？

public static void main(String[] args) {

        MutableTree<String> tree = new MappedTreeStructure<String>();
        tree.add("A", "B");
        tree.add("A", "C");
        tree.add("C", "D");
        tree.add("E", "F");
        System.out.println(tree);

        Map<String, String> myMap = tree.toMap();
        if (myMap != null) {
            for (Map.Entry<String, String> entry : myMap.entrySet()) {
                System.out.println("parent: " + entry.getKey() + ", child: "
                        + entry.getValue());
            }
        }

    }

    private final Map<N, N> nodeParent = new HashMap<N, N>();
    private final LinkedHashSet<N> nodeList = new LinkedHashSet<N>();

    @Override
    public boolean add(N parent, N node) {

        boolean added = nodeList.add(node);
        nodeList.add(parent);
        if (added) {
            nodeParent.put(node, parent);
        }
        return added;
    }

    @Override
    public boolean remove(N node, boolean cascade) {
        if (!nodeList.contains(node)) {
            return false;
        }
        if (cascade) {
            for (N child : getChildren(node)) {
                remove(child, true);
            }
        } else {
            for (N child : getChildren(node)) {
                nodeParent.remove(child);
            }
        }
        nodeList.remove(node);
        return true;
    }

    @Override
    public List<N> getRoots() {
        return getChildren(null);
    }

    @Override
    public N getParent(N node) {
        return nodeParent.get(node);
    }

    @Override
    public List<N> getChildren(N node) {
        List<N> children = new LinkedList<N>();
        for (N n : nodeList) {
            N parent = nodeParent.get(n);
            if (node == null && parent == null) {
                children.add(n);
            } else if (node != null && parent != null && parent.equals(node)) {
                children.add(n);
            }
        }
        return children;
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        dumpNodeStructure(builder, null, "- ");
        return builder.toString();
    }

    @Override
    public Map<String, String> toMap() {
        Map<String, String> map = new HashMap<String, String>();
        dumpNodeToMap(map, null);
        return map;
    }

    private void dumpNodeToMap(Map<String, String> map, N node) {
        if (node != null) {
            map.put((String) getParent(node), node.toString());
        }
        for (N child : getChildren(node)) {
            dumpNodeToMap(map, child);
        }
    }

    private void dumpNodeStructure(StringBuilder builder, N node, String prefix) {

        if (node != null) {

            builder.append(prefix);
            builder.append(node.toString());
            builder.append('\n');
            prefix = "    " + prefix;
        }

        for (N child : getChildren(node)) {
            dumpNodeStructure(builder, child, prefix);
        }

    }

控制台上的输出如下：

- A
    - B
    - C
        - D
- E
    - F

parent: null, child: E
parent: A, child: C
parent: C, child: D
parent: E, child: F

作为参考，这些是正在使用的两个接口类：

public interface MutableTree <N extends Serializable> extends Tree<N> {
    public boolean add (N parent, N node);
    public boolean remove (N node, boolean cascade);
    Map<String, String> toMap();
}

和

public interface Tree <N extends Serializable> extends Serializable {
    public List<N> getRoots ();
    public N getParent (N node);
    public List<N> getChildren (N node);
}

Answer 1

您的toMap方法return是一个Map<String, String>，其键是父元素名称，其值是单个子元素。这意味着当键为 "A" 时，只能存储一个子元素，并将其设置为找到的最后一个子元素，在本例中为 "C"，覆盖 [=26] 的条目=] 指向 "B".

相反，您的 toMap 方法需要 return 一个 Map<String, List<String>> 从每个父节点（例如 "A"）映射到子节点的 List元素，例如 "B" 和 "C"。显然，如果 List 只包含一个子元素就可以了，但它必须是一个列表，以防有多个子元素。

创建 List 项而不是单个项的常用模式如下所示：

String parentNode = getParent(node).toString();
List<String> childElements = null;
if(map.contains(parentNode) {
    // List of child elements already exists, so get it from the Map.
    childElements = map.get(parentNode);
} else {
    // List of child elements does not yet exist, so create a new List
    // and add it to the Map.
    childElements = new ArrayList<>();
    map.put(parentNode, childElements);
}
childElements.add(node.toString());

MapTreeStructure 导出为地图

MapTreeStructure Export As Map

java

tree

dictionary