Cannot display data in JavaFX TableView when using Properties

Question

I have read several threads on using Properties to display data in a JavaFX TableView and I can get all of these to work. Up until now I have been displaying data without problem in my TableView without Properties. However, moving forward I think I need to start using Properties, particularly as I want my TableView to be editable. I suspect that the problem is because all the examples I have seen use one object to display 1 row of data, whereas in my model I have one object (a Field object) per cell, though I can't think why this should be a problem.

Below is a VERY cut-down version of my Field class, enough for this test, but not enough to show its real use. I also have a test class TableViewDemo. Any help with this irksome problem would be much appreciated. Either it will be a silly mistake, or a fundamental problem with my design.

package javafxtest;
import java.sql.SQLException;
import javafx.beans.property.SimpleObjectProperty;

public class Field {

    private final SimpleObjectProperty objectValue; //All the data is stored as an object, then cast to appropriate data type

    public Field(Object objValue) throws SQLException {
        if (objValue == null) {
            throw new SQLException("Field value is null");
        }
        this.objectValue = new SimpleObjectProperty(objValue);
    }

    public final String getStringValue() {
        return (String) this.objectValue.get();
    }

    public final int getIntValue() {
        return (Integer) this.objectValue.get();
    }

    public final double getDoubleValue() {
        return (Double) this.objectValue.get();
    }

    public final boolean getBooleanValue() {
        return (Boolean) this.objectValue.get();
    }
}

package javafxtest;

import java.sql.SQLException;
import javafx.application.Application;
import static javafx.application.Application.launch;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.TableColumn;
import javafx.scene.control.TableView;
import javafx.scene.control.cell.PropertyValueFactory;
import javafx.scene.layout.FlowPane;
import javafx.stage.Stage;

public class TableViewDemo extends Application {

    @Override
    public void start(Stage myStage) {
        // Set up the stage
        myStage.setTitle("Demonstrate TableView");
        FlowPane rootNode = new FlowPane(10, 10);
        rootNode.setAlignment(Pos.CENTER);
        Scene myScene = new Scene(rootNode, 600, 450);
        myStage.setScene(myScene);

        //Set up some test data - 4 rows of 4 columns
        ObservableList<Field[]> dataModel = FXCollections.observableArrayList();
        ObservableList<Field[]> dataModel2 = FXCollections.observableArrayList();
        Field[] fields1;
        Field[] fields2;
        Field[] fields3;
        Field[] fields4;
        try {
            fields1 = new Field[4];
            fields1[0] = new Field("R1C1");
            fields1[1] = new Field(25);
            fields1[2] = new Field(100.00);
            fields1[3] = new Field(true);

            fields2 = new Field[4];
            fields2[0] = new Field("R2C1");
            fields2[1] = new Field(30);
            fields2[2] = new Field(150.00);
            fields2[3] = new Field(false);

            fields3 = new Field[4];
            fields3[0] = new Field("R3C1");
            fields3[1] = new Field(397);
            fields3[2] = new Field(1005.99);
            fields3[3] = new Field(true);

            fields4 = new Field[4];
            fields4[0] = new Field("R4C1");
            fields4[1] = new Field(1085);
            fields4[2] = new Field(1.00);
            fields4[3] = new Field(false);

            //Add the data to the dataModel
            dataModel.addAll(fields1, fields2, fields3, fields4);

            //Set up the columns ===== This is where the likely problem is, or at least part of the problem ====
            TableColumn<Field[], String> colString = new TableColumn<>("String");
            colString.setCellValueFactory(new PropertyValueFactory<>("stringValue"));
            colString.setPrefWidth(150);

            TableColumn<Field[], Integer> colInt = new TableColumn<>("int");
            colInt.setCellValueFactory(new PropertyValueFactory<>("intValue"));
            colInt.setPrefWidth(100);

            TableColumn<Field[], Double> colDouble = new TableColumn<>("double");
            colDouble.setCellValueFactory(new PropertyValueFactory<>("doubleValue"));
            colDouble.setPrefWidth(100);

            TableColumn<Field[], Boolean> colBoolean = new TableColumn<>("boolean");
            colBoolean.setCellValueFactory(new PropertyValueFactory<>("booleanValue"));
            colBoolean.setPrefWidth(75);

            //Set up the TableView - it takes an Array of Field objects. Add the data and columns to it
            TableView<Field[]> tableView = new TableView<Field[]>();
            tableView.setItems(dataModel);
            tableView.getColumns().addAll(colString, colInt, colDouble, colBoolean);

            //Print out the datamodel
            dataModel2 = tableView.getItems();
            for (int i = 0; i < dataModel2.size(); i++) {
                Field[] fields = new Field[4];
                fields = dataModel2.get(i);
                for (int j = 0; j < fields.length; j++) {
                    Field field = fields[j];
                    switch (j) {
                        case 0: //Column is a String data type
                            System.out.println(field.getStringValue());
                            break;
                        case 1:  //Column is a int data type
                            System.out.println(field.getIntValue());
                            break;
                        case 2:  //Column is a double data type
                            System.out.println(field.getDoubleValue());
                            break;
                        case 3:  //Column is a boolean data type
                            System.out.println(field.getBooleanValue());
                            break;
                        default:
                            break;
                    }
                }
            }

            // Set the tableView size
            tableView.setPrefWidth(500);
            tableView.setPrefHeight(300);

            rootNode.getChildren().add(tableView);
        } catch (SQLException e) {
            System.out.println(e.getLocalizedMessage());
        }
        myStage.show();
    }

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

This is what I currently use to populate a cell with a String value:

    final int x = i;
    tableColumn<Field[], String> columnString = (TableColumn<Field[], String>) this.columnModel.get(i);
    columnString.setCellValueFactory((TableColumn.CellDataFeatures<Field[], String> fieldArray) -> {
        Field arrayField = fieldArray.getValue()[x];
        return new ReadOnlyObjectWrapper(arrayField.getStringValue());
    });

James_D · Accepted Answer · 2018-04-18 01:58:24Z

1

This simply isn't the way PropertyValueFactory works. From the documentation:

An example of how to use this class is:
TableColumn<Person,String> firstNameCol = new TableColumn<Person,String>("First Name");
firstNameCol.setCellValueFactory(new PropertyValueFactory<Person,String>("firstName"));
In this example, Person is the class type of the TableView items list. The class Person must be declared public. PropertyValueFactory uses the constructor argument, "firstName", to assume that Person has a public method firstNameProperty with no formal parameters and a return type of ObservableValue<String>.

If such a method exists, then it is invoked, and additionally assumed to return an instance of Property<String>. The return value is used to populate the TableCell. In addition, the TableView adds an observer to the return value, such that any changes fired will be observed by the TableView, resulting in the cell immediately updating.

If no such method exists, then PropertyValueFactory assumes that Person has a public method getFirstName or isFirstName with no formal parameters and a return type of String. If such a method exists, then it is invoked, and its return value is wrapped in a ReadOnlyObjectWrapper and returned to the TableCell.

So, basically, the PropertyValueFactory retrieves the object representing the row, and uses reflection to look for a method xxxProperty(), where xxx is the property name assigned to the PropertyValueFactory. If no such method exists, then as a fall-back it looks for a method getXxx() instead, and wraps the result, if it exists, in a ReadOnlyObjectWrapper.

In your case, the value representing the row is a Field[], i.e. the object is an array of Fields. An array does not have a stringValueProperty() or getStringValue() method (etc), so this fails. (The individual elements of the array have those methods, of course, but the PropertyValueFactory isn't going to look at the array elements, it's just going to look at the value for the row, i.e. the array itself.)

It's hard to know how to "solve" this problem, as there's no really obvious reason you'd want to approach things this way anyway. You could, of course, just do

colString.setCellValueFactory(cellData -> 
    new SimpleStringProperty(cellData.getValue()[0].getStringValue()));

etc., but at that point it's not clear why you wouldn't just define a class with four regular fields - or even just use an Object[] and get rid of your Field class - anyway.

edited Apr 18, 2018 at 1:58

answered Apr 17, 2018 at 17:48

James_D

211k16 gold badges312 silver badges345 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

StuartM Over a year ago

Thanks James, I suspected that there may be a fundamental problem. I have amended my question to show what I currently use to populate the cell.

StuartM Over a year ago

The problem that I have is that I have a Swing application that I developed a few years ago that I am trying to port to JavaFX. The model is very generic in nature and has served my purpose very well, but I am now coming across the downside to the generic-ness. If the only way to make a table editable is to use properties I think I will have to forgo the benefits of editable tables, because I complete rewrite at this stage is a non-starter. Is there a way to make a table editable without properties, even if it is not as simple as with properties?

James_D Over a year ago

@StuartM Why not just make a TableView<List<ObjectProperty<Object>>>, or something similar? The cell value factory for column i would just be cellData -> cellData.getValue().get(i). Presumably somewhere at runtime you know the actual type for each column, so you set the converter for a TextFieldTableCell according to that type. Again, it's not really clear what you're trying to do with the code you posted.

Collectives™ on Stack Overflow

Cannot display data in JavaFX TableView when using Properties

1 Answer 1

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related