编辑不包含字符串的树视图项目

Question

我的目标是简单地编辑树视图的单元格（为此，我阅读了 JavaFX 的文档）。

我的问题是我的树视图不包含strings，而是我自己的数据类型，即呼叫：Database。我收到错误：Database$Variable cannot be cast to core.Database.

是否可以用我自己的类型实现树视图？

这是我在 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);
    }

}

这是我的数据库 class :

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> subclass (DatabaseStructureView) 的实例，它被设置作为 FXML 的动态根，然后是您声明的 TreeView<Database> 引用：databaseStructureView.

根据您的描述，我只能假设（因为您没有创建 MCVE）您已将这两个引用分配给同一个对象，方法是将 fx:id 属性设置为根，如下所示：

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

所以这里发生的是 this（在 DatabaseStructureView 的上下文中）和 databaseStructureView 指的是同一个对象。

这是一个非常混乱的设置，您不应该这样做。（具体来说，当根也是控制器时，不要在 <fx:root ... > 上设置 fx:id。）

大致情况如下：

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

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

这会导致加载 fxml 加载程序。因为你做了 setRoot(this)，它实际上做了

Object root = treeView ;

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

来验证这一点

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

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

由于类型擦除，并且因为 FXMLLoader 中的所有赋值都是通过反射进行的，泛型类型是不可见的，所以 FXML 根具有编译时类型 TreeView<Object>和 databaseStructureView，它的编译时类型为 TreeView<Database>，两者都有运行原始 TreeView 的时间类型。所以这些反思作业都成功了。

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

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

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

这显然很令人困惑：尽管这种混乱来自于不必要的引用 databaseStructure，它实际上与当前对象相同。如果您完全删除该引用和 fx:id 属性，那么您只需将对 databaseStructureView 的任何引用替换为 this。然后会发生的是，您遇到的类型错误将在编译时检测到，而不是在运行时间（它不会让您将 Callback<TableView<Database>, TableCell<DataBase>> 设置为细胞工厂，例如，因为它现在（正确地）期望 Callback<TableView<Object>, TableCell<Object>>).

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

编辑不包含字符串的树视图项目

Edit item of treeview that don't contains String

java

treeview

javafx