How to show/hide the thousand commas in the column of JavaFX?

I have a table in JavaFX. I want to control the show/hide of the thousand commas. Currently, I can control the color by column1.setStyle("-fx-text-fill: green"), but how can I show the thousand commas (and then hide them back in some later stage), probably via a similar approach?

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

  @Override
  public void start(Stage primaryStage) {

    TableView tableView = new TableView();

    TableColumn<Integer, Person> column1 = new TableColumn<>("Salary");
    column1.setCellValueFactory(new PropertyValueFactory("salary"));

    tableView.getColumns().add(column1);
    tableView.getItems().add(new Person(27000));
    tableView.getItems().add(new Person(48000));
    column1.setStyle("-fx-text-fill: green");	

    VBox vbox = new VBox(tableView);
    Scene scene = new Scene(vbox);
    primaryStage.setScene(scene);
    primaryStage.show();
  }

}

Person:

import javafx.beans.property.SimpleIntegerProperty;

public class Person {

    private SimpleIntegerProperty salaryProperty;

    public Person() {
    }

    public Person(int salary) {
        this.salaryProperty = new SimpleIntegerProperty(salary);

    }

    public int getSalary() {
        return salaryProperty.get();
    }

    public void setSalary(int salary) {
        this.salaryProperty = new SimpleIntegerProperty(salary);
    }
}

I think that it is not possible to do with css. You need to use some kind of NumberFormat like in this example:

App:

package formatter;

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.CheckBox;
import javafx.scene.control.TableCell;
import javafx.scene.control.TableColumn;
import javafx.scene.control.TableView;
import javafx.scene.control.cell.PropertyValueFactory;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

import java.text.NumberFormat;
import java.util.Locale;


public class App extends Application {

    @Override
    public void start(Stage primaryStage) {

        // Create the table view and its column (like you already did):
        TableView<Person> tableView = new TableView<>();
        TableColumn<Person, Integer> salaryColumn = new TableColumn<>("Salary");
        salaryColumn.setCellValueFactory(new PropertyValueFactory<>("salary"));
        tableView.getColumns().add(salaryColumn);

        // Using a check box in this example to change between formats::
        CheckBox useGroupingCheckBox = new CheckBox("use grouping");

        // Create a currency formatter with a locale which is important for internationalization:
        NumberFormat formatter = NumberFormat.getCurrencyInstance(Locale.CANADA);
        formatter.setMaximumFractionDigits(0);

        // Create a custom cell:
        salaryColumn.setCellFactory(column -> new TableCell<>() {
            @Override
            protected void updateItem(Integer item, boolean empty) {
                super.updateItem(item, empty);
                if (item == null || empty) {
                    setText("");
                } else {
                    // Use grouping when check box selected, don't when not selected:
                    formatter.setGroupingUsed(useGroupingCheckBox.isSelected());
                    setText(formatter.format(item));
                }
            }
        });

        // Refresh table on check box action:
        useGroupingCheckBox.setOnAction(event -> tableView.refresh());

        // Add some test data:
        tableView.getItems().add(new Person(27000));
        tableView.getItems().add(new Person(48000));

        // Prepare scene and stage:
        VBox vbox = new VBox(useGroupingCheckBox, tableView);
        Scene scene = new Scene(vbox);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

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

Person class:

package formatter;

import javafx.beans.property.IntegerProperty;
import javafx.beans.property.SimpleIntegerProperty;

public class Person {

    private IntegerProperty salary;

    public Person() {
        salary = new SimpleIntegerProperty();
    }

    public Person(int salary) {
        this();
        this.salary.set(salary);
    }

    public Integer getSalary() {
        return salary.get();
    }

    public IntegerProperty salaryProperty() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary.set(salary);
    }
}

Preview:

The accepted answer is just fine though a bit smelly because it requires to manually refresh the table when changing the format's property.

An alternative is

• to wrap the format - which is not observable - into something that is observable
• implement a custom cell which listens to the change/s and updates itself as needed.

An example of how to implement the first (for the grouping state) is FormattingHandler in the code below. Note that

• the wrapping property itself implements the update of the contained format
• the NumberFormat is completely hidden inside the handler: that's doing the best to not allow changes of its properties under the feet of the handler (obviously it's not entirely fool-proof because outside code can still keep a reference to the format and change it at will - it's a similar isolation level as f.i. the backing list in core ObservableList implementations)

An example of how to implement the second is FormattingCell. It takes a not-null FormattingHandler, registers a listener to the grouping property and updates itself on invalidation notification. Note that this might introduce a memory leak (even though the listener is weak!) if the observable doesn't change at all (it's a known issue in the design of weak listeners that will not be changed, unfortunately) - the only way out would be to move the listening into a custom cell skin and remove the listener in the skin's dispose.

The code (boilderplate stolen from Anko's answer

public class DynamicFormattingCellBinding extends Application {

    /**
     * Observable wrapper around NumberFormat.
     */
    public static class FormattingHandler {
        
        /*
         * Property controlling the grouping of the format.
         */
        private BooleanProperty useGrouping = new SimpleBooleanProperty(this, "useGrouping", false) {

            @Override
            protected void invalidated() {
                super.invalidated();
                groupingInvalidated();
            }
            
        };
        
        private NumberFormat formatter;
        
        public FormattingHandler(NumberFormat formatter) {
            this.formatter = formatter;
            setGrouping(formatter.isGroupingUsed());
        }
        
        public BooleanProperty groupingProperty() {
            return useGrouping;
        }
        
        public boolean isGrouping() {
            return groupingProperty().get();
        }
        
        public void setGrouping(boolean grouping) {
            groupingProperty().set(grouping);
        }
        
        public String format(Number number) {
            return formatter.format(number);
        }

        private void groupingInvalidated() {
            formatter.setGroupingUsed(isGrouping());
        }
    }
    
    public static class FormattingCell<T, S extends Number> extends TableCell<T, S> {
        
        private FormattingHandler formattingHandler;
        private InvalidationListener groupingListener = o -> updateItem(getItem(), isEmpty());

        public FormattingCell(FormattingHandler formattingHandler) {
            this.formattingHandler = Objects.requireNonNull(formattingHandler, "formatter must not be null");
            // Beware: a weak listener isn't entirely safe 
            // will introduce memory leaks if the observable doesn't change!
            formattingHandler.groupingProperty().addListener(new WeakInvalidationListener(groupingListener));
        }

        @Override
        protected void updateItem(S item, boolean empty) {
            super.updateItem(item, empty);
            if (item == null || empty) {
                setText("");
            } else {
                setText(formattingHandler.format(item));
            }
        }
        
    }
    
    @Override
    public void start(Stage primaryStage) {

        TableView<Person> tableView = new TableView<>();
        TableColumn<Person, Integer> salaryColumn = new TableColumn<>("Salary");
        salaryColumn.setCellValueFactory(cc -> cc.getValue().salaryProperty().asObject());
        tableView.getColumns().add(salaryColumn);

        // instantiate the formatting support and register bidi binding with a view element
        FormattingHandler formatter = new FormattingHandler(NumberFormat.getCurrencyInstance());
        CheckBox useGroupingCheckBox = new CheckBox("use grouping");
        useGroupingCheckBox.selectedProperty().bindBidirectional(formatter.groupingProperty());
        // install custom formatting cell
        salaryColumn.setCellFactory(column -> new FormattingCell<>(formatter));

        // Add some test data:
        tableView.getItems().add(new Person(27000));
        tableView.getItems().add(new Person(48000));

        // Prepare scene and stage:
        VBox vbox = new VBox(useGroupingCheckBox, tableView);
        Scene scene = new Scene(vbox);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

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

    private static class Person {
        // exact same as in the other answer
    }
}