Question

我的数据库中有一个表格如下：

依旧......

正如您所看到的，有几个根父母（没有parent_id的父母），每个类别都有n个孩子。

我想使用这个类将它转换为Java中的树结构：

private int id;
private String name;
private int parent;
private List<Category> children;

我使用此查询获取数据，我认为可以改进：

SELECT c.*, ca.name, NVL(ca.parent_id, -1) AS parent_id FROM 
( 
    SELECT id, name, parent_id FROM categories 
) ca, 
( 
    SELECT LISTAGG(id || ':' || name || ':' || DECODE(parent_id, NULL, 
    DECODE(id,    NULL, NULL, -1), parent_id), ';') 
    WITHIN GROUP (ORDER BY id) AS  children, parent_id AS id 
    FROM categories 
    GROUP BY parent_id HAVING parent_id IS NOT NULL 
) c 
WHERE c.id = ca.id

我得到每个类别（id，name和parent_id）以及带有子代的字符串。

然后我循环抛出每个ResultSet

List<Category> categories = new ArrayList<Category>();

while (rs.next()) { 
    Category c = new Category();
    c = JdbcToModel.convertToCategory(rs); //
    if (c.getParent() == -1) { // parent_id is null in database
        categories.add(c);
     else {
        categories = JdbcToModel.addCategoryToTree(categories, c);

    }
}

方法 convertToCategory ：

public static Category convertToCategory（ResultSet rs）{

Category toRet = new Category();
List<Category> children = new ArrayList<Category>();
try {       
    children = parseCategoriesFromReview(rs.getString("children"));
    toRet.setId(rs.getInt("id"));
    toRet.setName(rs.getString("name"));
    toRet.setParent(rs.getInt("parent_id"));
    toRet.setChildren(children);

} catch (Exception e) {
    e.printStackTrace();
}
return toRet;

}

解析子字符串时 parseCategoriesFromReview 方法：

public static List<Category> parseCategoriesFromReview(String categoriesString) {

        List<Category> toRet = new ArrayList<Category>();
        try {       
            if (!categoriesString.equals("::")) {

                String [] categs = categoriesString.split(";");
                for (String categ : categs) {
                    String [] category = categ.split(":");
                    Category c = new Category(Integer.parseInt(category[0]), category[1], Integer.parseInt(category[2]), new ArrayList<Category>());
                    toRet.add(c);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

        return toRet;   
    }

递归方法 addCategoryToTree ：

public static List<Category> addCategoryToTree(List<Category> categories, Category c) { 
    try {       
        for (Category ct : categories) {
            if (ct.getId() == c.getParent()) {
                ct.getChildren().add(c);
                break;
            } else {
                return addCategoryToTree(ct.getChildren(), c);
            }
        }

    } catch (Exception e) {
        e.printStackTrace();
    }
    return categories;

}

我认为最大的问题在于这个方法......我从来没有写过一个带有循环的递归方法，而且我不知道它是否正确。关键是我得到了一个树形结构，但只有几个类别。最后一棵树没有那么多。

也许我让事情变得复杂但我不知道如何以另一种方式做到这一点..

任何人都有帮助??

问候！

Answer 1

Oracle安装程序：

CREATE TABLE categories ( id, name, parent_id ) AS
SELECT  1, 'Restauracion', NULL FROM DUAL UNION ALL
SELECT  2, 'Desayuno',        1 FROM DUAL UNION ALL
SELECT  3, 'Calidad',         2 FROM DUAL UNION ALL
SELECT  4, 'Organizacion',    2 FROM DUAL UNION ALL
SELECT  5, 'Variedad',        2 FROM DUAL UNION ALL
SELECT  6, 'Personal',     NULL FROM DUAL UNION ALL
SELECT  7, 'Pisos',           6 FROM DUAL UNION ALL
SELECT  8, 'Falta de Personal', 7 FROM DUAL UNION ALL
SELECT  9, 'Trato',           7 FROM DUAL UNION ALL
SELECT 10, 'Informacion',     7 FROM DUAL UNION ALL
SELECT 11, 'Idiomas',         7 FROM DUAL UNION ALL
SELECT 12, 'Otros',           7 FROM DUAL;

<强>爪哇：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;

public class Category {
    private final String name;
    private final int id;
    private final Category parent;
    private final ArrayList<Category> children = new ArrayList<>();

    private Category(final String name, final int id, final Category parent) {
        this.name   = name;
        this.id     = id;
        this.parent = parent;
        if ( parent != null )
            parent.children.add(this);
    }

    @Override
    public String toString(){
        final StringBuffer buffer = new StringBuffer();
        buffer.append( '<' );
        buffer.append(name);
        buffer.append(':');
        buffer.append(id);
        buffer.append(':');
        buffer.append(parent == null ? "" : parent.name );
        buffer.append( '>' );
        return buffer.toString();
    }

    public String toHierarchyString(){
        return toHierarchyString(0);
    }

    private String toHierarchyString( int level ){
        final StringBuffer buffer = new StringBuffer();
        for ( int i = 0; i < level; i++ )
            buffer.append('\t');
        buffer.append( toString() );
        buffer.append( '\n' );
        for ( final Category child : children )
            buffer.append( child.toHierarchyString(level+1));
        return buffer.toString();
    }
    public static ArrayList<Category> loadCategoriesFromDatabase(){
        try{

            Class.forName("oracle.jdbc.OracleDriver");

            final Connection con = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:XE","TEST","TEST");
            final PreparedStatement st = con.prepareStatement(
                    "SELECT id, name, parent_id " +
                    "FROM  categories " +
                    "START WITH parent_id IS NULL " +
                    "CONNECT BY PRIOR id = PARENT_ID " +
                    "ORDER SIBLINGS BY name"
            );

            final ResultSet cursor = st.executeQuery();

            final HashMap<Integer,Category> categoryMap = new HashMap<>();
            final ArrayList<Category> categories = new ArrayList<>();

            while ( cursor.next() )
            {
                final String name       = cursor.getString("NAME");
                final int id            = cursor.getInt("ID");
                final Integer parent_id = cursor.getInt("PARENT_ID");
                final Category parent   = categoryMap.get( parent_id );
                final Category category = new Category( name, id, parent );
                categoryMap.put(id, category);
                if ( parent == null )
                    categories.add(category);
            }
            return categories;
        } catch(ClassNotFoundException | SQLException e) {
            System.out.println(e);
        }
        return null;
    }

    public static void main( final String[] args ){
        ArrayList<Category> categories = loadCategoriesFromDatabase();
        for ( final Category cat : categories )
            System.out.println( cat.toHierarchyString() );
    }
}

<强>输出：

<Personal:6:>
    <Pisos:7:Personal>
        <Falta de Personal:8:Pisos>
        <Idiomas:11:Pisos>
        <Informacion:10:Pisos>
        <Otros:12:Pisos>
        <Trato:9:Pisos>

<Restauracion:1:>
    <Desayuno:2:Restauracion>
        <Calidad:3:Desayuno>
        <Organizacion:4:Desayuno>
        <Variedad:5:Desayuno>

Answer 2

我相信你的问题在于对结果进行排序。您的代码假设所有子ID都具有比所有父ID更高的ID，这根本不需要。例如。如果你有一个类别（id = 5，parent = 10），那么它将递归当前树（包含类别id的0到4）。它将找不到正确的父类别，并且在这种情况下（取决于类别类中的children字段是否初始化为null或空列表）将打印异常的堆栈跟踪，或者只是迭代所有叶子类别中的空for循环，什么都不做。

要从这样的数据结构构建树，您可能需要两阶段方法。我更喜欢的那个（因为它是最简单的，虽然不是真正的高性能）将是：

初始化HashMap<Integer, List<Category>>
遍历您的数据库结果项并执行mapFromAbove.get(category.getId()).add(category)（您还需要初始化这些列表）
完成后，执行mapFromAbove.get(0)并迭代结果，对于每个结果，从相同的哈希映射中获取子项并将其添加到它们中。然后递归地做这个。

实际上很容易实现。

从表中构造树

2 个答案: