How to create a tableview for this ??

Question

Hey, i have been stuck to this part for a long time and not able to find any answers, may be i can get some help from you guys.
See i have a scenario where i have different "items",out of which each will belong to a predefined category. These items have names and then different types(depend on the category), each of these types in turn have a price.
For example if I have Item1(Bottle Of Water),belongs to category1 and it has different types : 200ml ,500 ml, 1000ml with price tags of 10,20,30 respectively.
Similarly,I have Item2(Box of Butter),belongs to category2 and it has different types : 100 gm, 200 gm with price tags of 15 and 25 respectively.
Now, i want these data to be shown on a editable table,when i press on a category button,all items belonging to the category(having the same types) must be displayed, with the headings divided into :
On pressing category 1
NAME | PRICE |
| 200ml |500ml|1000ml |
| |
Bottle Of Water | 10 | 20 | 30 |
On pressing category 2
NAME | PRICE |
| 100gm | 200ml |
| |
Box Of Butter | 15 | 25 |
So i want a dyanamic table which can have dynamic nested columns.
I was trying to make a table from the class
public class ItemVO()
String itemName;
List<ItemTypeVO> type;
and My ItemTypeVO has the following attributes :
public class ItemTypeVO()
String typeName;
Integer price;
But m not able to get anywhere with it.
Many a places i have found dynamic columns with attributes like this :
public class ItemVO()
String itemName;
ItemTypeVO type;
But this doesnt suit my functionality. i guess .
Can anybody help me with what change can i make in my class, so that i can make a table and supply me with some code as well.
Thanks in advance.

Answer 1

I don't really know what you are trying to do in this Test class.
I mocked this up with the object model I suggested and a mock data access object which just hard codes a few items, and it works just fine.
Type.java
package itemtable;
public class Type {
  private final String name ;
  public Type(String name) {
    this.name = name ;
  public String getName() {
    return name ;
}Category.java
package itemtable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Category {
  private final List<Type> types ;
  private final String name ;
  public Category(String name, List<Type> types) {
    this.name = name ;
    this.types = new ArrayList<Type>();
    this.types.addAll(types);
  public List<Type> getTypes() {
    return Collections.unmodifiableList(types);
  public String getName() {
    return name ;
  @Override
  public String toString() {
    return name ;
}Item.java
package itemtable;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javafx.beans.property.DoubleProperty;
import javafx.beans.property.ReadOnlyObjectProperty;
import javafx.beans.property.SimpleDoubleProperty;
import javafx.beans.property.SimpleObjectProperty;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
public class Item {
  private final StringProperty name ;
  private final ReadOnlyObjectProperty<Category> category ;
  private final Map<Type, DoubleProperty> prices ;
  public Item(String name, Category category, Map<Type, Double> prices) {
    this.name = new SimpleStringProperty(name);
    this.category = new SimpleObjectProperty<Category>(category);
    this.prices = new HashMap<Type, DoubleProperty>();
    for (Type type : prices.keySet()) {
      validateType(type);
      this.prices.put(type, new SimpleDoubleProperty(prices.get(type)));
  public String getName() {
    return name.get();
  public Category getCategory() {
    return category.get();
  public double getPrice(Type type) {
    validateType(type);
    return prices.get(type).get();
  public void setName(String name) {
    this.name.set(name);
  public void setPrice(Type type, double price) {
    validateType(type);
    prices.get(type).set(price);
  public StringProperty nameProperty() {
    return name ;
  public ReadOnlyObjectProperty<Category> categoryProperty() {
    return category ;
  public DoubleProperty priceProperty(Type type) {
    return prices.get(type);
  private void validateType(Type type) {
    final List<Type> allowedTypes = category.get().getTypes();
    if (! allowedTypes.contains(type)) {
      throw new IllegalArgumentException("Cannot set a price for "+type.getName()+": it is not a type for the category "+category.getName());
}DAO.java
package itemtable;
import java.util.List;
public interface DAO {
  public List<Category> getCategories();
  public List<Item> getItemsByCategory(Category category);
}MockDAO.java
package itemtable;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class MockDAO implements DAO {
  private final List<Category> categories ;
  private final Map<Category, List<Item>> itemLookup ;
  public MockDAO() {
    final Type spreadType100g = new Type("100g");
    final Type spreadType200g = new Type("200g");
    final Type drinkType200ml = new Type("200ml");
    final Type drinkType500ml = new Type("500ml");
    final Type drinkType1000ml = new Type("1000ml");
    final Category spreads = new Category(
        "Spreads",
        Arrays.asList(spreadType100g, spreadType200g)
    final Category drinks = new Category(
        "Drinks",
        Arrays.asList(drinkType200ml, drinkType500ml, drinkType1000ml)
    final Map<Type, Double> waterPrices = new HashMap<Type, Double>();
    waterPrices.put(drinkType200ml, 10.0);
    waterPrices.put(drinkType500ml, 20.0);
    waterPrices.put(drinkType1000ml, 30.0);
    final Map<Type, Double> pepsiPrices = new HashMap<Type, Double>();
    pepsiPrices.put(drinkType200ml, 25.0);
    pepsiPrices.put(drinkType500ml, 45.0);
    pepsiPrices.put(drinkType1000ml, 75.0);
    final Map<Type, Double> butterPrices = new HashMap<Type, Double>();
    butterPrices.put(spreadType100g, 15.0);
    butterPrices.put(spreadType200g, 25.0);
    final Map<Type, Double> margarinePrices = new HashMap<Type, Double>();
    margarinePrices.put(spreadType100g, 12.0);
    margarinePrices.put(spreadType200g, 20.0);
    final Map<Type, Double> mayoPrices = new HashMap<Type, Double>();
    mayoPrices.put(spreadType100g, 20.0);
    mayoPrices.put(spreadType200g, 35.0);
    final Item water = new Item("Water", drinks, waterPrices);
    final Item pepsi = new Item("Pepsi", drinks, pepsiPrices);
    final Item butter = new Item("Butter", spreads, butterPrices);
    final Item margarine = new Item("Margarine", spreads, margarinePrices);
    final Item mayonnaise = new Item("Mayonnaise", spreads, mayoPrices);
    this.categories = Arrays.asList(drinks, spreads);
    this.itemLookup = new HashMap<Category, List<Item>>();
    itemLookup.put(drinks, Arrays.asList(water, pepsi));
    itemLookup.put(spreads, Arrays.asList(butter, margarine, mayonnaise));
  @Override
  public List<Category> getCategories() {
    return categories ;
  @Override
  public List<Item> getItemsByCategory(Category category) {
    return itemLookup.get(category);
}ItemTable.java
package itemtable;
import javafx.application.Application;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.scene.Scene;
import javafx.scene.control.ChoiceBox;
import javafx.scene.control.TableColumn;
import javafx.scene.control.TableColumn.CellDataFeatures;
import javafx.scene.control.TableView;
import javafx.scene.control.cell.PropertyValueFactory;
import javafx.scene.layout.BorderPane;
import javafx.stage.Stage;
import javafx.util.Callback;
public class ItemTable extends Application {
  @Override
  public void start(Stage primaryStage) {
    final DAO dao = new MockDAO();
    final ChoiceBox<Category> choiceBox = new ChoiceBox<Category>();
    choiceBox.getItems().setAll(dao.getCategories());
    final TableView<Item> table = new TableView<Item>();
    final TableColumn<Item, String> nameCol = new TableColumn<Item, String>("Name");
    nameCol.setCellValueFactory(new PropertyValueFactory<Item, String>("name"));
    final TableColumn<Item, Double> priceCol = new TableColumn<Item, Double>("Price");
    table.getColumns().addAll(nameCol, priceCol);
    choiceBox.getSelectionModel().selectedItemProperty()
        .addListener(new ChangeListener<Category>() {
          @Override
          public void changed(ObservableValue<? extends Category> observable, Category oldValue, Category newValue) {
            table.getItems().clear();
            priceCol.getColumns().clear();
            for (final Type type : newValue.getTypes()) {
              final TableColumn<Item, Number> col = new TableColumn<Item, Number>(type.getName());
              col.setCellValueFactory(new Callback<CellDataFeatures<Item, Number>, ObservableValue<Number>>() {
                @Override
                public ObservableValue<Number> call(CellDataFeatures<Item, Number> cellData) {
                  Item item = cellData.getValue();
                  if (item == null) {
                    return null;
                  } else {
                    return item.priceProperty(type);
              priceCol.getColumns().add(col);
            table.getItems().setAll(dao.getItemsByCategory(newValue));
    BorderPane root = new BorderPane();
    root.setTop(choiceBox);
    root.setCenter(table);
    Scene scene = new Scene(root, 600, 600);
    primaryStage.setScene(scene);
    primaryStage.show();
  public static void main(String[] args) {
    launch(args);
}