JavaFx - show objects in TableView containing ObservableList

Question

I have a class Person which amongst other attributes contains an ObservableList<Car>. Now I want to display the data in a TableView so that it looks like this:

First Name | Last Name | Car
-----------+-----------+---------
John       | Doe       | BMW
John       | Doe       | Audi
Walter     | Johnson   | Chrysler

How can I get JavaFX to extract the list of class Person and create a row for each item in that list?

Answer 1

The easyest way is to create a new class CarOfPerson, that contains a Car and the owner:

class CarOfPerson {
    Person myOwner;
    Car    myCar;
    public CarOfPerson(Car car, Person person) {
        myOwner = person;
        myCar = car;
    }
    public Person getOwner() { return myOwner; }
    public Car getCar() { return myCar; }
}

This class can now be used as Table item. So if you create an observable list with these instances you could set up the table as:

    TableColumn<CarOfPerson,String> c1 = new TableColumn<CarOfPerson,String>("first");
    c1.setCellValueFactory(p -> p.getValue().getOwner().firstNameProperty());
    table.getColumns().add(c1);

    TableColumn<CarOfPerson,String> c2 = new TableColumn<CarOfPerson,String>("last");
    c2.setCellValueFactory(p -> p.getValue().getOwner().lastNameProperty());
    table.getColumns().add(c2);

    TableColumn<CarOfPerson,String> c3 = new TableColumn<CarOfPerson,String>("car");
    c3.setCellValueFactory(p -> p.getValue().getCar().typeProperty());
    table.getColumns().add(c3);

The main challenge now is to either:

1. Create a list of CarOfPerson out of all Persons, but the drawback is that this required to build a potentially huge list of separate instances, difficult to keep in sync with the list of Persons if any changes are made.

2. Create a view of type ObservableList that dynamically creates the CarOfPerson objects on demand:

   ObservableList<CarOfPerson> list = new ObservableListBase<CarOfPerson>(){
       ObservableList<Person> myPersons = persons;
       boolean observed = false;
   
       @Override
       public CarOfPerson get(int index) {
           System.out.println("get "+index);
           for (Person person : myPersons) {
               if (person.getNumberOfCars() > index) return new CarOfPerson(person.getCar(index), person);
               index -= person.getNumberOfCars();
           }
           return new CarOfPerson(new Car("null"), new Person("N", "N"));
       }
   
       @Override
       public int size() {
           if (!observed) {
               myPersons.addListener((ListChangeListener.Change<? extends TableInVBox.Person> c) -> {
                   beginChange();
                   nextAdd(0, Integer.MAX_VALUE);
                   endChange();
               });
               observed = true;
           }
           int size = 0;
           for (Person person : myPersons) size += person.getNumberOfCars();
           return size;
       } 
   };
   

This will act as a potentiall huge list of observable CarOfPersons. But each of these instances will be generated only on demand and if shown in the current table ....

The observation of the myPersons will update the TableView to immediately show changes in the persons list. So adding, removing persons or names will be reflected in the table.

Of course my implementation if very inefficient, iterating through all Persons up to the proper index, but that could be optimized. Its ment as a hint.