JavaFX table sort after adding new entry

Question

I have a table which has an ObservableList bound to it. The table is sorted in a descending order, but whenever an object is added to the list the entry is added to the table but the sorting is not maintained.

public class ActivityLogController {

    @FXML
    private TableView<Activity> activityLogTable;

    @FXML
    private TableColumn<Activity, ActivityType> type;

    @FXML
    private TableColumn<Activity, String> activity;

    @FXML
    private TableColumn<Activity, ActivitySource> source;

    @FXML
    private TableColumn<Activity, LocalDateTime> timestamp;

    public void loadController(){
        TableRowExpanderColumn<Activity> column = new TableRowExpanderColumn<>(this::createEditor);
        setColumnProperties();
        activityLogTable.getColumns().add(0, column);
        activityLogTable.setItems(ActivityHandler.getInstance().getActivityObservableList());

        timestamp.setSortType(TableColumn.SortType.DESCENDING);
        activityLogTable.getSortOrder().add(timestamp);
        activityLogTable.sort();
    }

    private HBox createEditor(TableRowExpanderColumn.TableRowDataFeatures<Activity> param){
        HBox hBox = new HBox();
        hBox.setAlignment(Pos.BASELINE_LEFT);
        hBox.setPadding(new Insets(10, 0, 10, 125));

        Activity activity = param.getValue();
        Label label = new Label(activity.getDetails());

        hBox.getChildren().setAll(label);

        return hBox;
    }

    private void setColumnProperties(){
        type.setCellValueFactory(new PropertyValueFactory<>("type"));
        type.setCellFactory(col -> new TableCell<Activity, ActivityType>() {
            private final ImageView imageView = new ImageView();
            @Override
            protected void updateItem(ActivityType type, boolean empty) {
                super.updateItem(type, empty) ;
                if (empty) {
                    setGraphic(null);
                } else {
                    imageView.setFitHeight(16);
                    imageView.setFitWidth(16);
                    imageView.setImage(type.image);
                    setGraphic(imageView);
                    this.setAlignment(Pos.TOP_CENTER);
                }
            }
        });
        activity.setCellValueFactory((tf -> new ReadOnlyStringWrapper(tf.getValue().getActivity())));
        source.setCellValueFactory(new PropertyValueFactory<>("source"));
        timestamp.setCellValueFactory(new PropertyValueFactory<>("timeStamp"));
    }
}

public final class ActivityHandler {
    private static ActivityHandler INSTANCE;

    public static ActivityHandler getInstance() {
        if(INSTANCE == null) {
            INSTANCE = new ActivityHandler();
        }

        return INSTANCE;
    }

    public static void setInstance(ActivityHandler a){
        INSTANCE = a;
    }

    private static final String ACTIVITY_LOG = "CONFIG/activityLog.json";
    private ObservableList<Activity> activityObservableList;

    public ObservableList<Activity> getActivityObservableList() {
        return activityObservableList;
    }

    public void setActivityObservableList(ObservableList<Activity> activityObservableList) {
        this.activityObservableList = activityObservableList;
    }

    public void addActivity(Activity activity){
        LocalDateTime time = activity.getTimeStamp();
        activityObservableList.add(activity);

        activityObservableList.removeIf(a -> a.getTimeStamp().isBefore(time.minus(Period.ofDays(1))));

        System.out.println("added activity " + activity.getActivity());

        Platform.runLater(this::serializeActivityLog);
    }

    public void serializeActivityLog(){
        Gson gson = new Gson();
        try {
            Writer writer = new FileWriter(ACTIVITY_LOG);
            gson.toJson(activityObservableList, writer);
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void deserializeActivityLog(){
        Gson gson = new Gson();

        try {
            Type typeOfList = new TypeToken<ArrayList<Activity>>() { }.getType();
            ArrayList arrayList = gson.fromJson(new FileReader(ACTIVITY_LOG), typeOfList);
            if(arrayList == null){
                arrayList = new ArrayList();
            }
            activityObservableList = FXCollections.observableArrayList(arrayList);
        } catch (FileNotFoundException e) {
            serializeActivityLog();
            e.printStackTrace();
        }
    }
}

Is there a way to maintain the sorting after a new object is added to the list?