java - 编辑 TreeView 中不包含字符串的项目

Question

我的目标是简单地编辑 TreeView 的单元格(为此，我阅读了 JavaFX 的文档)。

我的问题是我的 TreeView 不包含字符串，而是我自己的数据类型，即调用:数据库。我收到错误:Database$Variable 无法转换为 core.Database。

是否可以用我自己的类型实现 TreeView ？

这是我在 James_D 的帮助下使用的代码:

public class DatabaseStructureView extends TreeView<Object> {

    private Database db;

    @FXML
    private TreeView<Database> databaseStructureView;

    public DatabaseStructureView() {
        FXMLLoader fxmlLoader = new FXMLLoader(getClass().getResource("DatabaseStructureView.fxml"));

        fxmlLoader.setRoot(this);
        fxmlLoader.setController(this);
        try {
            fxmlLoader.load();
        } catch (IOException exception) {
            throw new RuntimeException(exception);
        }

        databaseStructureView.setEditable(true);
        databaseStructureView.setCellFactory(new Callback<TreeView<Database>,TreeCell<Database>>(){
            @Override
            public TreeCell<Database> call(TreeView<Database> param) {
                return new TextFieldTreeCellImpl();
            }

        });


    }

    private final class TextFieldTreeCellImpl extends TreeCell<Database> {

        private TextField textField;

        public TextFieldTreeCellImpl() {
        }

        @Override
        public void startEdit() {
            super.startEdit();

            if (textField == null) {
                createTextField();
            }
            setText(null);
            setGraphic(textField);
            textField.selectAll();
        }

        @Override
        public void cancelEdit() {
            super.cancelEdit();
            setText(getString());
            setGraphic(getTreeItem().getGraphic());
        }

        @Override
        public void updateItem(Database item, boolean empty) {
            super.updateItem(item, empty);

            if (empty) {
                setText(null);
                setGraphic(null);
            } else {
                if (isEditing()) {
                    if (textField != null) {
                        textField.setText(getString());
                    }
                    setText(null);
                    setGraphic(textField);
                } else {
                    setText(getString());
                    setGraphic(getTreeItem().getGraphic());
                }
            }
        }

        private void createTextField() {
            textField = new TextField(getString());
            textField.setOnKeyReleased(new EventHandler<KeyEvent>() {

                @Override
                public void handle(KeyEvent t) {
                    if (t.getCode() == KeyCode.ENTER) {
                        commitEdit(getDatabase(textField.getText()));
                    } else if (t.getCode() == KeyCode.ESCAPE) {
                        cancelEdit();
                    }
                }
            });
        }

        private Database getDatabase(String text) {
            return new Database(text);
        }

        private String getString(){
            return getItem() == null ? "" : getItem().toString();
        }
    }

    public void setDatabase(Database db) {

        this.db = db;

        TreeItem<Object> dbRoot = new TreeItem<>(db);
        dbRoot.setExpanded(true);

        for (Variable var : db.getVariables()) {
            dbRoot.getChildren().add(new TreeItem<Object>(var));
        }
        setRoot(dbRoot);
    }

}

这是我的 DataBase 类:

public class Database {

public static class Variable {

    public static enum VariableType {

        NUMERIC, INTEGER, LOGIC, ORDONEE, NOMINAL, DATE
    }

    private String name;

    private VariableType type;

    private List<String> values;

    public Variable(String name) {
        this.name = name;
        values = new ArrayList<>();
    }

    private void addValue(String value) {
        values.add(value);
    }

    public String getValue(int index) {
        return values.get(index);
    }

    public void addValue(int index, String value) {
        values.add(index, value);
    }

    public VariableType getType() {
        return type;
    }

    public String getName() {
        return name;
    }

    public List<String> getValues() {
        return values;
    }

    public String calculerMinimum (){
        if(this.getType().equals(VariableType.INTEGER)){
            // Je convertit en entier les strings
            List<String> maColonneString = this.getValues();
            List<Integer> maColonneInt = new ArrayList<Integer>();
            for(int i = 0; i < maColonneString.size(); i++){
                if(!maColonneString.get(i).equals("NULL")){
                    maColonneInt.set(i, Integer.parseInt(maColonneString.get(i)));
                }
            }

            return(Integer.toString(Collections.min(maColonneInt)));
        }
        else {
            return null;
        }
    }

    public String calculerMaximum (){
        if(this.getType().equals(VariableType.INTEGER)){
            // Je convertit en entier les strings
            List<String> maColonneString = this.getValues();
            List<Integer> maColonneInt = new ArrayList<Integer>();
            for(int i = 0; i < maColonneString.size(); i++){
                if(!maColonneString.get(i).equals("NULL")){
                    maColonneInt.set(i, Integer.parseInt(maColonneString.get(i)));
                }
            }

            return(Integer.toString(Collections.max(maColonneInt)));
        }
        else {
            return null;
        }
    }

    public String calculerFrequence (String maValeurTemoin){
        List<String> maColonneString = this.getValues();
        int compteur = 0;
        for(int i = 0; i < maColonneString.size(); i++){
            if(maColonneString.get(i).equals(maValeurTemoin)){
                compteur ++;
            }
        }
        return Integer.toString(compteur);
    }

    public String calculerMoyenne (){
        if(this.getType().equals(VariableType.INTEGER)){
            List<String> maColonneString = this.getValues();
            int somme = 0;
            int valeurNull=0;
            for(int i = 0; i < maColonneString.size(); i++){
                if(!maColonneString.get(i).equals("NULL")){
                    somme += Integer.parseInt(maColonneString.get(i));
                }
                else{
                    valeurNull ++;
                }
            }
            return (Integer.toString(somme/(maColonneString.size()-valeurNull)));
        }
        else {
            return null;
        }
    }



    public String calculerVariance (){
        if(this.getType().equals(VariableType.INTEGER)){
            List<String> maColonneString = this.getValues();
            int sommeMul=0;
            int variance=0;
            int valeurNull=0;
            for(int i = 0; i < maColonneString.size(); i++){
                if(!maColonneString.get(i).equals("NULL")){
                    sommeMul += Integer.parseInt(maColonneString.get(i))*Integer.parseInt(maColonneString.get(i));
                }
                else{
                    valeurNull ++;
                }
            }
            variance = sommeMul/(maColonneString.size()-valeurNull)-Integer.parseInt(calculerMoyenne())*Integer.parseInt(calculerMoyenne());
            return Integer.toString(variance);
        }
        else {
            return null;
        }
    }

    public String calculerEcartType (){
        if(this.getType().equals(VariableType.INTEGER)){
            return (Double.toString( Math.sqrt(Integer.parseInt(calculerVariance()))));
        }
        else {
            return null;
        }
    }

    public List<String> calculerAnalyseUnivarieRestreinte (){
        if(this.getType().equals(VariableType.INTEGER)){
            List<String> analyseUniList = new ArrayList<String>();
            analyseUniList.add(calculerMinimum());
            analyseUniList.add(calculerMaximum());
            analyseUniList.add(calculerMoyenne());
            return analyseUniList;
        }
        else{
            return null;
        }
    }

    public List<String> calculerAnalyseUnivarieComplete (){
        if(this.getType().equals(VariableType.INTEGER)){
            List<String> analyseUniList = new ArrayList<String>();
            analyseUniList.add(calculerMinimum());
            analyseUniList.add(calculerMaximum());
            analyseUniList.add(calculerMoyenne());
            analyseUniList.add(calculerVariance());
            analyseUniList.add(calculerEcartType());
            return analyseUniList;
        }
        else{
            return null;
        }
    }

    public boolean rechercherValeur (String maValeurTemoin){
        List<String> maColonneString = this.getValues();
        return(maColonneString.contains(maValeurTemoin));
    }

    public void setTypeVariable (VariableType monNouveauType){
        this.type = monNouveauType;
    }

    public void setNomVariable (String monNouveauNom){
        this.name = monNouveauNom;
    }

    public void modifierValeur (String ancienneValeur, String nouvelValeur){
        List<String> maColonneString = this.getValues();
        for(int i = 0; i < maColonneString.size(); i++){
            if(maColonneString.get(i).equals(ancienneValeur)){
                this.values.set(i, nouvelValeur);
            }
        }
    }

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

}


private List<Variable> variables;

private String name;

public Database(String name) {
    this.name = name;
    variables = new ArrayList<>();
}

public void addVariable(String name) {
    variables.add(new Variable(name));
}

public String print() {
    StringBuilder sb = new StringBuilder();
    int i = 0;

    while (i != variables.get(0).values.size()) {
        for (Variable variable : variables) {
            sb.append(variable.values.get(i)).append(" ");
        }
        sb.append(System.getProperty("line.separator"));
        i++;
    }

    return sb.toString();
}

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

public Variable getVariable(Variable maVariable) {
    for (Variable variable : variables) {
        if (variable.getName().equals(maVariable.getName())) {
            return variable;
        }
    }
    return null;
}

public List<Variable> getVariables() {
    return new ArrayList<>(variables);
}

public Variable getVariable(int index) {
    return variables.get(index);
}

public boolean addVariable(Variable variableAdd) {
    return (this.variables.add(variableAdd));
}

public boolean removeVariable(Variable variableRemove) {
    return (this.variables.remove(variableRemove));
}

}

这是我收到的错误:

java.lang.ClassCastException: core.Database$Variable cannot be cast to core.Database
at components.databaseStructureView.DatabaseStructureView$TextFieldTreeCellImpl.updateItem(DatabaseStructureView.java:53)
at javafx.scene.control.TreeCell.updateItem(TreeCell.java:515)
at javafx.scene.control.TreeCell.indexChanged(TreeCell.java:473)
at javafx.scene.control.IndexedCell.updateIndex(IndexedCell.java:116)

Answer 1

您发布的代码有一个奇怪的结构:您有两个 TreeView引用， TreeView<Object> 的实例子类 ( DatabaseStructureView )，它被设置为 FXML 的动态根，然后是 TreeView<Database>您声明的引用:databaseStructureView .

根据您的描述，我只能假设(因为您没有创建 MCVE )您已通过设置 fx:id 将这两个引用分配给同一个对象。根上的属性，如下所示:

<fx:root type="TreeView" fx:id="databaseStructureView" ... >

所以这里发生的是 this (在 DatabaseStructureView 的上下文中)和 databaseStructureView引用同一个对象。

这是一个非常令人困惑的设置，您不应该这样做。 (具体来说，当根也是 Controller 时，不要在 fx:id 上设置 <fx:root ... >。)

发生的情况大致如下:

在某个地方你做类似的事情

TreeView<Object> treeView = new DatabaseStructureView<>();

这会导致 fxml 加载程序加载。因为你这样做setRoot(this) ，它有效地做到了

Object root = treeView ;

(类型为 Object 因为 FXML 实际上是无类型的)。然后因为你有 setController(this) FXMLLoader的 Controller 也设置为 treeView 。然后当它解析 FXML 时，它会看到 fx:id并且还设置 databaseStructureView至treeView 。所以你实际上有 treeView.databaseStructureView == treeView 。您可以通过添加

来验证这一点

System.out.println(this == databaseStructureView);

在FXMLLoader之后的load()方法已成功完成。

因为类型删除，并且因为 FXMLLoader 中的所有赋值是通过反射生成的，泛型类型是不可见的，因此 FXML 根的编译时类型为 TreeView<Object>和databaseStructureView ，其编译时类型为 TreeView<Database> ，两者都有原始 TreeView 的运行时类型。所以这些反射(reflection)性作业都是成功的。

但是发生的情况是，通过在 FXML 加载器中使用反射，您现在已经进行了非类型安全分配，因此所有对泛型类型的赌注都消失了。因为databaseStructureView编译时类型为 TreeView<Database> ，编译器认为可以安全地假设该树中的所有树项都必须是 TreeItem<Database> 。所以你的updateItem(...)方法需要 Database作为参数。但是，由于当前对象是 TreeView<Object> ，编译器将允许您添加任何 TreeView<Object>到树结构。但由于它们指的是同一件事，当你这样做时

dbRoot.getChildren().add(new TreeItem<Object>(var));

您正在添加 TreeView<Object>到databaseStructureView的树结构。当 TreeView 稍后检索包装的对象(实际上是 DatabaseStructure.Variable )并将其传递给 updateItem(...) 时方法时，您会收到类转换异常，因为它是错误的类型。

这显然非常令人困惑:这种困惑来自于不必要的引用 databaseStructure这与当前对象确实相同。如果您完全删除该引用，并且 fx:id属性，那么您只需替换对 databaseStructureView 的任何引用即可与 this 。然后会发生的事情是，您的类型错误将在编译时而不是在运行时被检测到(例如，它不会让您将 Callback<TableView<Database>, TableCell<DataBase>> 设置为单元工厂，因为它现在(正确地)期望Callback<TableView<Object>, TableCell<Object>>)。

阻止您做您想做的事情的根本问题是 TreeView 中的所有项目必须是同一类型。您正在尝试混合类型:一些 TreeItem包含 Database对象，其他包含 Database.Variable对象。您需要设计对象模型，以便所有内容都具有通用类型，或者将单元实现编写为 TreeCell<Object>并以某种方式找出在提交编辑时要创建的正确对象。