TableView - How to update a running balance column after any other column in the view is re-sorted

Question

To keep this simple and to illustrate a problem that I am trying to solve let's say we have
a domain class that contains an income per day.
This class has two persistent properties - populated from a database table - date and income.
And there is one transient property - running balance - that shows the accumulated income
starting from the first record. This property is not persisted and it is used only to show
the running/accumulated income in a table view.
This domain object is shown in a table view with three columns:
     - date
     - income
     - running balance
The first two columns - date and income - are sortable. When the user clicks on the column
heading these can will be sorted in ascending or descending order. The running balance
column needs to reflect this change and be correctly updated.
So the question is : how would you implement the running balance update after the data in
the table has been updated by the user?
Take 1)
=============
The obvious approach is to use "setOnSort" method to consume the SortEvent event and re-sort the
data but the sort-event does not contain any useful information that would tell from which column
the sort event originated.
Take 2)
=============
Found a possible solution:
     - TableView.getSortOrder() returns a list that defines the order in which TableColumn instances are sorted after the user clicked one or more column headings.
     - TableColumn.getSortType() returns the sort type - ascending/descending.
     - This info can be used in the TableView.setOnSort() event handler to re-sort the data and update the balance at the same time.
Take 3)
=============
When the TableView.setOnSort() event handler is called the data is already sorted therefore the only thing that needs to be done is to update the running balance.

Answer 1

I  think I understand what you're trying to do. If I've missed it, apologies, but I think this will provide you with something you can work from anyway.
I would listen to the data instead of watching specifically for sorting. This will be much more robust if you add new functionality later (such as adding and removing rows, editing the data that's there, etc).
Specifically, for the runningBalance column, create a cellValueFactory that provides a DoubleBinding; this binding should listen for changes to the data and compute the value by running through the table's items up to the point of the item for which it's displaying the value. (Hope you can untangle that sentence.)
Example. The important part is the cellValueFactory for the cumulativeAmountCol. I guess I should mention that you shouldn't try this exact approach with very large tables as the performance might be pretty bad (computations of the order of n x m on changing data, where n is the number of rows in the table and m is the number of visible rows in the table).
import java.text.DateFormat;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
import javafx.application.Application;
import javafx.beans.Observable;
import javafx.beans.binding.DoubleBinding;
import javafx.beans.property.DoubleProperty;
import javafx.beans.property.ObjectProperty;
import javafx.beans.property.SimpleDoubleProperty;
import javafx.beans.property.SimpleObjectProperty;
import javafx.beans.value.ObservableValue;
import javafx.collections.FXCollections;
import javafx.scene.Scene;
import javafx.scene.control.TableCell;
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 CumulativeTableColumnExample extends Application {
  private final static int NUM_ITEMS = 20 ;
@Override
  public void start(Stage primaryStage) {
  final TableView<LineItem> table = new TableView<>();
  // using the extractor here makes sure the table item list fires a list changed event if any amounts change
  // this enables the cumulative amount column to keep up to date when the amount in a different row changes.
  table.setItems(FXCollections.observableList(createRandomData(), new Callback<LineItem, Observable[]>() {
      @Override
      public Observable[] call(LineItem item) {
        return new Observable[] {item.amountProperty()};
  final TableColumn<LineItem, Date> dateCol = new TableColumn<>("Date");
  final TableColumn<LineItem, Number> amountCol = new TableColumn<>("Amount");
  final TableColumn<LineItem, Number> cumulativeAmountCol = new TableColumn<>("Cumulative Amount");
  table.getColumns().addAll(Arrays.asList(dateCol, amountCol, cumulativeAmountCol));
  dateCol.setCellValueFactory(new PropertyValueFactory<LineItem, Date>("date"));
    amountCol.setCellValueFactory(new PropertyValueFactory<LineItem, Number>("amount"));
    cumulativeAmountCol.setCellValueFactory(new PropertyValueFactory<LineItem, Number>("amount"));
    cumulativeAmountCol.setSortable(false); // otherwise bad things might happen
  final DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.SHORT);
  dateCol.setCellFactory(new Callback<TableColumn<LineItem, Date>, TableCell<LineItem, Date>>() {
      @Override
      public TableCell<LineItem, Date> call(TableColumn<LineItem, Date> col) {
        return new TableCell<LineItem, Date>() {
          @Override
          public void updateItem(Date date, boolean empty) {
            super.updateItem(date, empty);
            if (empty) {
              setText(null);
            } else {
              setText(dateFormat.format(date));
  cumulativeAmountCol.setCellValueFactory(new Callback<CellDataFeatures<LineItem, Number>, ObservableValue<Number>> () {
      @Override
      public ObservableValue<Number> call(CellDataFeatures<LineItem, Number> cellData) {
        final LineItem currentItem = cellData.getValue() ;
        DoubleBinding value = new DoubleBinding() {
            super.bind(table.getItems());
          @Override
          protected double computeValue() {
            double total = 0 ;
            LineItem item = null ;
            for (Iterator<LineItem> iterator = table.getItems().iterator(); iterator.hasNext() && item != currentItem; ) {
              item = iterator.next() ;
              total = total + item.getAmount() ;
            return total ;
        return value;
    final NumberFormat currencyFormat = NumberFormat.getCurrencyInstance();
  // generics hell.. can't wait for lambdas...
  final Callback<TableColumn<LineItem, Number>, TableCell<LineItem, Number>> currencyCellFactory = new Callback<TableColumn<LineItem, Number>, TableCell<LineItem, Number>>() {
      @Override
      public TableCell<LineItem, Number> call(TableColumn<LineItem, Number> column) {
        return new TableCell<LineItem, Number>() {
          @Override
          public void updateItem(Number amount, boolean empty) {
            if (empty) {
              setText(null) ;
            } else {
              setText(currencyFormat.format(amount));
    amountCol.setCellFactory(currencyCellFactory);
    cumulativeAmountCol.setCellFactory(currencyCellFactory);
    BorderPane root = new BorderPane();
  root.setCenter(table);
  primaryStage.setScene(new Scene(root, 600, 400));
  primaryStage.show();
  public List<LineItem> createRandomData() {
    Random rng = new Random();
    List<LineItem> items = new ArrayList<>();
    for (int i=0; i<NUM_ITEMS; i++) {
      Calendar cal = Calendar.getInstance();
      cal.add(Calendar.DAY_OF_YEAR, rng.nextInt(365)-365);
      double amount = (rng.nextInt(90000)+10000)/100.0 ;
      items.add(new LineItem(cal.getTime(), amount));
    return items ;
  public static void main(String[] args) {
  launch(args);
public static class LineItem {
    private final ObjectProperty<Date> date ;
    private final DoubleProperty amount ;
    public LineItem(Date date, double amount) {
      this.date = new SimpleObjectProperty<>(this, "date", date);
      this.amount = new SimpleDoubleProperty(this, "amount", amount);
    public final ObjectProperty<Date> dateProperty() {
      return date;
    public final Date getDate() {
      return date.get();
    public final void setDate(Date date) {
      this.date.set(date);
    public final DoubleProperty amountProperty() {
      return amount ;
    public final double getAmount() {
      return amount.get();
    public final void setAmount(double amount) {
      this.amount.set(amount);