从JavaFX动态填充fxml中的TreeTableView

我想动态填充TreeTableView。我已经用Scenebuilder创建了视图。在MyController中，我有一个Draw按钮，它通过点击调用一个方法，使树成为可编辑的。我有参考资料。单击按钮时，仅显示列。应该显示treecolumn的第一列不显示任何内容，列下也没有其他值。树表视图在我单独使用并将其添加到场景中时有效，但现在我想使用这些值填充场景生成器生成的树表。还有一件事我想不出来。当注释out

treeTable=new TreeTableView（root）时，列设置正确在树型注释下！否则，列也不会显示。

这就是我想看到的：

包装控制器；
导入java.net.URL；
导入java.util.ArrayList；
导入java.util.array；
导入java.util.HashSet；
导入java.util.List；
导入java.util.ResourceBundle；
导入java.util.Set；
导入java.util.TreeMap；
导入java.util.Map.Entry；
导入java.util.stream.collector；
导入model.DataConstructor；
导入javafx.beans.property.ReadOnlyObjectWrapper；
导入javafx.beans.property.ReadOnlyStringWrapper；
导入javafx.beans.value.observeValue；
导入javafx.event.ActionEvent；
导入javafx.fxml.fxml；
导入javafx.fxml.Initializable；
导入javafx.scene.control.Label；
导入javafx.scene.control.Tooltip；
导入javafx.scene.control.TreeItem；
导入javafx.scene.control.TreeTableCell；
导入javafx.scene.control.TreeTableColumn；
导入javafx.scene.control.TreeTableView；
导入javafx.scene.control.TreeTableColumn.CellDataFeatures；
导入javafx.util.Callback；
公共类MainController实现可初始化{
私有TreeItem root=新TreeItem（“函数”）；
私有DataConstructor dc=新DataConstructor（）；
@FXML
私有树表查看树表；
@凌驾
公共void初始化（URL位置、ResourceBundle资源）{
//TODO自动生成的方法存根
}
public void testDraw（ActionEvent事件）{
绘图台（）；
}
私有void drawTable（）{
root.setExpanded（true）；
Set combinedKeys=newhashset（dc.getCombiFunc（）.keySet（））；
Set funcAllKeys=newhashset（dc.getSortedfuncAll（）.keySet（））；
removeAll（dc.getCombiFunc（）.keySet（））；
for（列表值：dc.getCombiFunc（）.values（））{
funcAllKeys.removeAll（值）；
}
for（字符串值：funcAllKeys）{
ArrayList tempNameId=新的ArrayList（）；
add（dc.getSortedfuncAll（）.get（valueremained））；
//不在组合函数中的所有元素（它们都是
//孤儿）
root.getChildren（）；
}
Set keyFromcombined=new HashSet（）；
List valueOfCombined=new ArrayList（）；
对于（条目ent:dc.getCombiFunc（）.entrySet（））{
valueOfCombined.add（ent.getValue（）.get（0））；
}
List rootKeyList=new ArrayList（）；
for（字符串键：组合键）{
如果（！valueOfCombined.contains（（键）））{
添加（dc.getFuncAll（）.get（key））；
rootKeyList.add（key）；
}
}
String[]rootKeys=rootKeyList.toArray（新字符串[rootKeyList.size（）]）；
////树表////////////////////////////
树表=新树表视图（根）；
stream（rootKeys）.forEach(
rootKey->root.getChildren（）.add(
createTreeItem（dc.getCombiFunc（），rootKey））；
////第一列/////////////////////////
TreeTableColumn firstColumn=新的TreeTableColumn（“”）；
treeTable.getColumns（）.add（firstColumn）；//树列
第一列
.setCellValueFactory（新回调（）{
公共价值呼叫(
celldatap）{
返回新的ReadOnlyStringWrapper（p.getValue（））
.getValue（））；
}
});
/////Rest列////////////////////////
对于（条目ent:dc.getSortedAssignedOrg（）.entrySet（））{
TreeTableColumn=新的TreeTableColumn（）；
Label Label=新标签（ent.getValue（））；
col.setGraphic（标签）；
label.setTooltip（新工具提示（label.getText（））；//列的工具提示
//标题
列设置宽度（45）；
//细胞价值工厂////////////////////////
col.setCellValueFactory（新回调（）{
@凌驾
公共价值呼叫(
CellDataFeatures（参数）{
树映射温度=（树映射）dc
.getFuncTypeOrg（）.clone（）；
ArrayList结果=新建ArrayList（）；
对于（int i=0；i6）{
result.add（1，list.get（list.size（）-1））；//颜色
package controller;

import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.TreeMap;
import java.util.Map.Entry;
import java.util.stream.Collectors;

import model.DataConstructor;
import javafx.beans.property.ReadOnlyObjectWrapper;
import javafx.beans.property.ReadOnlyStringWrapper;
import javafx.beans.value.ObservableValue;
import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;

import javafx.scene.control.Label;
import javafx.scene.control.Tooltip;
import javafx.scene.control.TreeItem;
import javafx.scene.control.TreeTableCell;
import javafx.scene.control.TreeTableColumn;
import javafx.scene.control.TreeTableView;
import javafx.scene.control.TreeTableColumn.CellDataFeatures;
import javafx.util.Callback;

public class MainController implements Initializable {



private TreeItem<String> root = new TreeItem<>("Functions");
private DataConstructor dc = new DataConstructor();

@FXML
private TreeTableView<String> treeTable;

@Override
public void initialize(URL location, ResourceBundle resources) {
    // TODO Auto-generated method stub

}

public void testDraw(ActionEvent event) {

    drawTable();
}

private void drawTable() {

    root.setExpanded(true);
    Set<String> combinedKeys = new HashSet<>(dc.getCombiFunc().keySet());
    Set<String> funcAllKeys = new HashSet<>(dc.getSortedfuncAll().keySet());
    funcAllKeys.removeAll(dc.getCombiFunc().keySet());
    for (List<String> value : dc.getCombiFunc().values()) {
        funcAllKeys.removeAll(value);
    }
    for (String valueremained : funcAllKeys) {
        ArrayList<String> tempNameId = new ArrayList<>();
        tempNameId.add(dc.getSortedfuncAll().get(valueremained));
        // all elements which are not in combined functions (They are all
        // orphan)
        root.getChildren().add(new TreeItem<String>(tempNameId.get(0)));
    }
    Set<String> keyFromcombined = new HashSet<>();
    List<String> valueOfCombined = new ArrayList<String>();
    for (Entry<String, List<String>> ent : dc.getCombiFunc().entrySet()) {
        valueOfCombined.add(ent.getValue().get(0));
    }
    List<String> rootKeyList = new ArrayList<>();
    for (String key : combinedKeys) {

        if (!valueOfCombined.contains((key))) {

            keyFromcombined.add(dc.getFuncAll().get(key));
            rootKeyList.add(key);
        }
    }
    String[] rootKeys = rootKeyList.toArray(new String[rootKeyList.size()]);

    // ////////////////treetable////////////////////////////

    treeTable = new TreeTableView<>(root);

    Arrays.stream(rootKeys).forEach(
            rootKey -> root.getChildren().add(
                    createTreeItem(dc.getCombiFunc(), rootKey)));

    // ////////////////First column/////////////////////////

    TreeTableColumn<String, String> firstColumn = new TreeTableColumn<>("");
    treeTable.getColumns().add(firstColumn);// Tree column
    firstColumn
            .setCellValueFactory(new Callback<CellDataFeatures<String, String>, ObservableValue<String>>() {
                public ObservableValue<String> call(
                        CellDataFeatures<String, String> p) {
                    return new ReadOnlyStringWrapper(p.getValue()
                            .getValue());
                }
            });

    // //////////////////Rest Columns////////////////////////

    for (Entry<String, String> ent : dc.getSortedAssignedOrg().entrySet()) {

        TreeTableColumn<String, ArrayList<String>> col = new TreeTableColumn<>();
        Label label = new Label(ent.getValue());
        col.setGraphic(label);
        label.setTooltip(new Tooltip(label.getText()));// tooltip for column
                                                        // headers
        col.setPrefWidth(45);
        //cell Value Factory////////////////////////
        col.setCellValueFactory(new Callback<TreeTableColumn.CellDataFeatures<String, ArrayList<String>>, ObservableValue<ArrayList<String>>>() {
            @Override
            public ObservableValue<ArrayList<String>> call(
                    CellDataFeatures<String, ArrayList<String>> param) {
                TreeMap<String, List<String>> temp = (TreeMap<String, List<String>>) dc
                        .getFuncTypeOrg().clone();
                ArrayList<String> result = new ArrayList<>();
                for (int i = 0; i < dc.getFuncTypeOrg().size(); i++) {
                    List<String> list = temp.firstEntry().getValue();
                    String key = temp.firstEntry().getKey();
                    // root.getChildren();
                    if (list.get(1).equals(param.getValue().getValue())
                            && list.get(5).equals(label.getText())) {
                        result.add(0, list.get(2));// weight
                        // //////////////org combi TODO
                        for (Entry<String, Set<String>> ent : dc
                                .getCombiOrg().entrySet()) {
                            if (ent.getKey().contains(col.getText()))
                                for (Set<String> value : dc.getCombiOrg()
                                        .values()) {
                                    if (value.contains(col.getText()))
                                        System.out.println(col.getText());
                                }
                        }
                        // ///////////////org combi
                        if (list.size() > 6) {
                            result.add(1, list.get(list.size() - 1));// color
                            result.add(2, list.get(6));// App component
                        }

                        else
                            result.add("white");
                        result.add("noOrg");

                    } else {
                        temp.remove(key);
                    }

                }

                return new ReadOnlyObjectWrapper<ArrayList<String>>(result);
            }
        });

        // //////////////cellfactory/////////////////////////
        col.setCellFactory(new Callback<TreeTableColumn<String, ArrayList<String>>, TreeTableCell<String, ArrayList<String>>>() {
            @Override
            public TreeTableCell<String, ArrayList<String>> call(
                    TreeTableColumn<String, ArrayList<String>> param) {
                return new TreeTableCell<String, ArrayList<String>>() {
                    public void updateItem(ArrayList<String> item,
                            boolean empty) {
                        super.updateItem(item, empty);

                        if (item == null || empty) {
                            setStyle("");
                            setText("");
                        } else if (item.contains("Green")) {
                            float weightInt = Float.parseFloat(item.get(0));
                            float res = weightInt * 1;
                            String resString = Float.toString(res);
                            this.setStyle("-fx-background-color:green");
                            setTooltip(new Tooltip(item.get(2)));
                            setText(resString);
                        } else if (item.contains("yellow")) {
                            this.setStyle("-fx-background-color:yellow");
                            setTooltip(new Tooltip(item.get(2)));
                            setText("0");
                        } else if (item.contains("white")) {
                            setText("DD");
                        }
                    }
                };
            };

        });

        treeTable.getColumns().add(col);
    }
    // end for col


treeTable.setPrefWidth(1200);
treeTable.setPrefHeight(500);
    treeTable.setShowRoot(false);
    treeTable.setTableMenuButtonVisible(true);
}

/**
 * Create a TreeItem for a TreeView from a set of data given the data and an
 * identified root within the data.
 */
private TreeItem<String> createTreeItem(TreeMap<String, List<String>> data,
        String rootKey) {
    TreeItem<String> item = new TreeItem<>();
    item.setValue(rootKey);
    item.setExpanded(true);

    List<String> childData = data.get(rootKey);
    if (childData != null) {
        childData.stream().map(child -> createTreeItem(data, child))
                .collect(Collectors.toCollection(item::getChildren));
    }

    String valueName = item.getValue();
    //String sorteV = dc.getSortedfuncAll().get(valueName);
    item.setValue((dc.getSortedfuncAll().get(valueName)));
    return item;
}

treeTable = new TreeTableView<>(root);

treeTable.setRoot(root);