Javafx:TreeView的域对象

我的应用程序中有三个域对象，如下所示：

public class Workflow {
  private String name;
  private List<Sheet> sheets;
}

public class Sheet {
  private String name;
  private List<Task> tasks;
}

public class Task {
  private String name;
}

到目前为止，我已经构建了一个示例，它构建的内容比我期望的要少，但它根本不是通用的和“自动化的”

public class TreeViewSample extends Application {

public static void main(String[] args) {
    launch(args);
}

@Override
public void start(Stage primaryStage) {
    primaryStage.setTitle("Tree View Sample");        

    Workflow w = setup();

    TreeItem<String> rootItem = new TreeItem<String> ("Workflow");
    rootItem.setExpanded(true);

        TreeItem<String> item = new TreeItem<String> (w.getName());
        rootItem.getChildren().add(item);
(...)


    TreeView<String> tree = new TreeView<String> (rootItem);        
    StackPane root = new StackPane();
    root.getChildren().add(tree);
    primaryStage.setScene(new Scene(root, 300, 250));
    primaryStage.show();
}

private Workflow setup(){

    Workflow wflow = new Workflow();
    wflow.setName("wflow name");
    wflow.setSheets(Arrays.asList(new Sheet("sheet name", Arrays.asList(new Task("task name")))));

    return wflow;
}

公共类TreeViewSample扩展应用程序{
公共静态void main（字符串[]args）{
发射（args）；
}
@凌驾
公共无效开始（阶段primaryStage）{
setTitle（“树视图示例”）；
工作流w=设置（）；
TreeItem rootItem=新的TreeItem（“工作流”）；
setExpanded（true）；
TreeItem item=newtreeitem（w.getName（））；
rootItem.getChildren（）.add（项）；
(...)
TreeView树=新的TreeView（rootItem）；
StackPane root=新的StackPane（）；
root.getChildren（）.add（树）；
原始阶段。设置场景（新场景（根，300250））；
primaryStage.show（）；
}
专用工作流设置（）{
工作流wflow=新工作流（）；
wflow.setName（“wflow name”）；
wflow.setSheets（Arrays.asList（新工作表（“工作表名称”），Arrays.asList（新任务（“任务名称”）））；
回流；
}

---

有人能建议我如何递归地转到我的域对象并构建树视图，如我的示例中所示吗？

您必须为所有模型（工作流、工作表、任务）创建一个通用的

模型，因为所有模型都有一个字符串属性，创建一个非常简单。假设我们有以下模型：

public class Model {

    private String name;

    public Model(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return getName();
    }
}

class Workflow {
    private String name;
    private List<Sheet> sheets = new ArrayList<>();

    public Workflow(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public List<Sheet> getSheets() {
        return sheets;
    }
}

class Sheet {
    private String name;
    private List<Task> tasks = new ArrayList<>();

    public Sheet(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public List<Task> getTasks() {
        return tasks;
    }
}

class Task {
    private String name;

    public Task(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

然后控制器类：

public class Controller implements Initializable {

    @FXML
    private TreeView<Model> treeView;

    @Override
    public void initialize(URL location, ResourceBundle resources) {
        Workflow workflow = createWorkflow(); // This just sets up the models that you are using.

        // You have to create a root in your case the "Workflow"
        TreeItem<Model> root = new TreeItem<>(new Model(workflow.getName()));
        // The foreach sheet you create a branch
        workflow.getSheets().forEach(sheet -> {
            TreeItem<Model> sheetBranch = new TreeItem<>(new Model(sheet.getName()));
            // Then you have to add each branch to the root
            root.getChildren().add(sheetBranch);
            // Then foreach sheet you create a task item
            sheet.getTasks().forEach(task -> {
                TreeItem<Model> taskItem = new TreeItem<>(new Model(task.getName()));
                // Then you have to add each task to its sheet parent
                sheetBranch.getChildren().add(taskItem);
            });
        });
        // Finally, you set the root for the TreeView. Of course this can be done right after instantiating the root.
        treeView.setRoot(root);
    }

    // ------------------- Setup the model -----------------------

    private Workflow createWorkflow() {
        Workflow workflow = new Workflow("Workflow");
        workflow.getSheets().addAll(createSheets());
        return workflow;
    }

    private List<Sheet> createSheets() {
        List<Sheet> sheets = new ArrayList<>();
        IntStream.range(1, 10).forEach(value -> sheets.add(createSheet()));
        return sheets;
    }

    private Sheet createSheet() {
        Sheet sheet = new Sheet("Sheet" + new Random().nextInt(100)); // Random added to have different names
        sheet.getTasks().addAll(createTasks());
        return sheet;
    }

    private List<Task> createTasks() {
        List<Task> tasks = new ArrayList<>();
        IntStream.range(1, 5).forEach(value -> tasks.add(createTask()));
        return tasks;
    }

    private Task createTask() {
        return new Task("Task" + new Random().nextInt(100)); // Random added to have different names
    }
}

如果你不知道树视图的深度，你可以使用递归创建所有的分支或叶子。在这种情况下，使用两个foreach比创建一个构建树结构的递归方法要简单得多。
你必须为所有模型（工作流、工作表、任务）创建一个通用的
模型，因为它们都有一个字符串属性，所以创建一个字符串属性非常简单。假设我们有以下模型：

public class Model {

    private String name;

    public Model(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return getName();
    }
}

class Workflow {
    private String name;
    private List<Sheet> sheets = new ArrayList<>();

    public Workflow(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public List<Sheet> getSheets() {
        return sheets;
    }
}

class Sheet {
    private String name;
    private List<Task> tasks = new ArrayList<>();

    public Sheet(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public List<Task> getTasks() {
        return tasks;
    }
}

class Task {
    private String name;

    public Task(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

然后控制器类：

public class Controller implements Initializable {

    @FXML
    private TreeView<Model> treeView;

    @Override
    public void initialize(URL location, ResourceBundle resources) {
        Workflow workflow = createWorkflow(); // This just sets up the models that you are using.

        // You have to create a root in your case the "Workflow"
        TreeItem<Model> root = new TreeItem<>(new Model(workflow.getName()));
        // The foreach sheet you create a branch
        workflow.getSheets().forEach(sheet -> {
            TreeItem<Model> sheetBranch = new TreeItem<>(new Model(sheet.getName()));
            // Then you have to add each branch to the root
            root.getChildren().add(sheetBranch);
            // Then foreach sheet you create a task item
            sheet.getTasks().forEach(task -> {
                TreeItem<Model> taskItem = new TreeItem<>(new Model(task.getName()));
                // Then you have to add each task to its sheet parent
                sheetBranch.getChildren().add(taskItem);
            });
        });
        // Finally, you set the root for the TreeView. Of course this can be done right after instantiating the root.
        treeView.setRoot(root);
    }

    // ------------------- Setup the model -----------------------

    private Workflow createWorkflow() {
        Workflow workflow = new Workflow("Workflow");
        workflow.getSheets().addAll(createSheets());
        return workflow;
    }

    private List<Sheet> createSheets() {
        List<Sheet> sheets = new ArrayList<>();
        IntStream.range(1, 10).forEach(value -> sheets.add(createSheet()));
        return sheets;
    }

    private Sheet createSheet() {
        Sheet sheet = new Sheet("Sheet" + new Random().nextInt(100)); // Random added to have different names
        sheet.getTasks().addAll(createTasks());
        return sheet;
    }

    private List<Task> createTasks() {
        List<Task> tasks = new ArrayList<>();
        IntStream.range(1, 5).forEach(value -> tasks.add(createTask()));
        return tasks;
    }

    private Task createTask() {
        return new Task("Task" + new Random().nextInt(100)); // Random added to have different names
    }
}

如果您不知道树视图的深度，可以使用递归创建所有的分支或叶子。在这种情况下，使用两个foreach比创建一个构建树结构的递归方法要简单得多。
缺少提供子项列表的公共超类型，您需要使用一个不同的方法/1 n包含子对象列表的每个对象的ested循环，即

private TreeItem<String> createWorkFlow(Workflow workflow) {
    TreeItem<String> item = new TreeItem<>(workflow.getName());
    for (Sheet sheet : workflow.getSheets()) {
        item.getChildren().add(createSheet(sheet));
    }
    return item;
}

private TreeItem<String> createSheet(Sheet sheet) {
    TreeItem<String> item = new TreeItem<>(sheet.getName());
    for (Task task : sheet.getTasks()) {
        item.getChildren().add(new TreeItem<>(task.getName());
    }
    return item;
}

由于缺少提供子项列表的公共超类型，您需要为每个包含子对象列表的对象使用1个不同的方法/1个嵌套循环，即

private TreeItem<String> createWorkFlow(Workflow workflow) {
    TreeItem<String> item = new TreeItem<>(workflow.getName());
    for (Sheet sheet : workflow.getSheets()) {
        item.getChildren().add(createSheet(sheet));
    }
    return item;
}

private TreeItem<String> createSheet(Sheet sheet) {
    TreeItem<String> item = new TreeItem<>(sheet.getName());
    for (Task task : sheet.getTasks()) {
        item.getChildren().add(new TreeItem<>(task.getName());
    }
    return item;
}

我已经按照你的指示做了，它也很有效，谢谢！是的，如果你喜欢递归方式，你应该使用这个答案；）我已经按照你的指示做了，它也很有效，谢谢！是的，如果你喜欢递归方式，你应该使用这个答案；）
private TreeItem<String> createWorkFlow(Workflow workflow) {
    TreeItem<String> workflowItem = new TreeItem<>(workflow.getName());
    for (Sheet sheet : workflow.getSheets()) {
        TreeItem<String> sheetItem = new TreeItem<>(sheet.getName());
        for (Task task : sheet.getTasks()) {
            sheetItem.getChildren().add(new TreeItem<>(task.getName()));
        }
        workflowItem.getChildren().add(sheetItem);
    }
    return item;
}

public interface Item<T extends Item<?>> {
    String getName();
    default List<T> getChildren() {
        return null; // default for terminal object
    }
}

public static <T extends Item<?>> TreeItem<String> createItem(Item<T> item) {
    TreeItem<String> treeItem = new TreeItem<>(item.getName());
    List<T> children = item.getChildren();
    if (children != null) {
        for (Item<?> ci : children) {
            treeItem.getChildren().add(createItem(ci));
        }
    }
    return treeItem;
}