如何让JavaFX TreeTableView在数据变更时保持排序状态？

问题说明 #

• 使用TreeTableView展示树形数据时，存在两类数据变更场景：后台增删数据项、数据项的列展示属性变更
• 设置排序规则（点击表头或代码设置）后，新增数据或属性变更时排序状态无法维持，新元素默认追加到末尾，需手动触发排序才能恢复正确顺序

示例代码（原问题复现） #

import javafx.application.Application;
import javafx.beans.property.ReadOnlyStringProperty;
import javafx.beans.property.ReadOnlyStringWrapper;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

import java.util.Random;

public class TestApplication extends Application {
    public static void main(String[] args) {
        launch(args);
    }

    @Override
    public void start(Stage primaryStage) {
        TreeTableColumn<Entry, String> columnFirst = new TreeTableColumn<>("First");
        columnFirst.setCellValueFactory(p -> p.getValue().getValue().firstProperty());

        TreeTableColumn<Entry, String> columnSecond = new TreeTableColumn<>("Second");
        columnSecond.setCellValueFactory(p -> p.getValue().getValue().secondProperty());

        TreeTableView<Entry> treeTableView = new TreeTableView<>();
        treeTableView.getColumns().add(columnFirst);
        treeTableView.getColumns().add(columnSecond);

        Button button = new Button("Add Entry");
        button.setOnAction(event -> {
            Random random = new Random();
            String first = String.valueOf((char)(random.nextInt('Z' - 'A') + 'A'));
            String second = String.valueOf((char)(random.nextInt('Z' - 'A') + 'A'));
            Entry entry = new Entry(first, second);

            if(treeTableView.getRoot() == null) {
                treeTableView.setRoot(new TreeItem<>(entry));
                treeTableView.getRoot().setExpanded(true);
                treeTableView.getSortOrder().add(columnFirst);
            }
            else {
                treeTableView.getRoot().getChildren().add(new TreeItem<>(entry));
            }
        });

        VBox vbox = new VBox();
        vbox.getChildren().add(treeTableView);
        vbox.getChildren().add(button);

        Scene scene = new Scene(vbox);
        primaryStage.setScene(scene);
        primaryStage.setTitle("TreeTableView Sorting");
        primaryStage.show();
    }

    public static class Entry {
        private final String first;
        private final String second;

        public Entry(String first, String second) {
            this.first = first;
            this.second = second;
        }

        public ReadOnlyStringProperty firstProperty() {
            return new ReadOnlyStringWrapper(first);
        }

        public ReadOnlyStringProperty secondProperty() {
            return new ReadOnlyStringWrapper(second);
        }
    }
}

现有尝试的局限 #

TableView可通过SortedList<T>绑定比较器+设置extractor监听属性变化实现持久排序，但TreeTableView没有官方提供的类似组件；TreeItem的getChildren()返回可观察列表，但无直接的自定义排序扩展点，不想在每次数据变更时手动调用sort()方法。

可行解决方案 #

方案1：自动触发TreeTableView.sort()（简单直接） #

通过监听数据变化事件，自动调用TreeTableView的sort()方法，利用已有排序规则完成重排：

1. 修正Entry类的属性实现
   原代码中属性返回临时的ReadOnlyStringWrapper，无法监听变化，需改为实例化的属性对象：

   public static class Entry {
       private final ReadOnlyStringWrapper first = new ReadOnlyStringWrapper();
       private final ReadOnlyStringWrapper second = new ReadOnlyStringWrapper();
   
       public Entry(String first, String second) {
           this.first.set(first);
           this.second.set(second);
       }
   
       public ReadOnlyStringProperty firstProperty() {
           return first.getReadOnlyProperty();
       }
   
       public ReadOnlyStringProperty secondProperty() {
           return second.getReadOnlyProperty();
       }
   
       // 支持属性变更的setter（按需添加）
       public void setFirst(String first) {
           this.first.set(first);
       }
   
       public void setSecond(String second) {
           this.second.set(second);
       }
   }
   

2. 添加数据变更监听
   在初始化TreeTableView时，为根节点的子列表添加监听器，同时为每个新增Entry的属性添加监听，触发自动排序：

   button.setOnAction(event -> {
       Random random = new Random();
       String first = String.valueOf((char)(random.nextInt('Z' - 'A') + 'A'));
       String second = String.valueOf((char)(random.nextInt('Z' - 'A') + 'A'));
       Entry entry = new Entry(first, second);
       TreeItem<Entry> treeItem = new TreeItem<>(entry);
   
       // 监听Entry属性变化，触发排序
       entry.firstProperty().addListener((obs, oldVal, newVal) -> treeTableView.sort());
       entry.secondProperty().addListener((obs, oldVal, newVal) -> treeTableView.sort());
   
       if(treeTableView.getRoot() == null) {
           TreeItem<Entry> root = new TreeItem<>(entry);
           root.setExpanded(true);
           treeTableView.setRoot(root);
           treeTableView.getSortOrder().add(columnFirst);
   
           // 监听根节点子列表变化，触发排序
           root.getChildren().addListener((ListChangeListener<TreeItem<Entry>>) c -> {
               while (c.next()) {
                   if (c.wasAdded() || c.wasRemoved()) {
                       treeTableView.sort();
                   }
               }
           });
       } else {
           treeTableView.getRoot().getChildren().add(treeItem);
       }
   });
   

方案2：自定义SortedTreeItem（封装排序逻辑） #

创建自定义TreeItem子类，内部维护排序规则，自动处理子项增减和属性变化后的排序：

1. 实现SortedTreeItem

   public class SortedTreeItem<T> extends TreeItem<T> {
       private final Comparator<TreeItem<T>> comparator;
       private final InvalidationListener propertyChangeListener = obs -> resortChildren();
   
       public SortedTreeItem(T value, Comparator<TreeItem<T>> comparator) {
           super(value);
           this.comparator = comparator;
           // 监听子列表变化
           getChildren().addListener((ListChangeListener<TreeItem<T>>) c -> resortChildren());
       }
   
       private void resortChildren() {
           getChildren().sort(comparator);
       }
   
       @Override
       public boolean addChildren(TreeItem<T>... items) {
           boolean added = super.addChildren(items);
           // 监听每个子项的属性变化（假设T为Entry，可根据实际类型调整）
           for (TreeItem<T> item : items) {
               if (item.getValue() instanceof Entry entry) {
                   entry.firstProperty().addListener(propertyChangeListener);
                   entry.secondProperty().addListener(propertyChangeListener);
               }
           }
           resortChildren();
           return added;
       }
   }
   

2. 使用SortedTreeItem

   // 创建排序比较器，关联列的排序规则
   Comparator<TreeItem<Entry>> columnFirstComparator = (item1, item2) -> {
       String val1 = item1.getValue().firstProperty().get();
       String val2 = item2.getValue().firstProperty().get();
       return columnFirst.getSortType() == SortType.ASCENDING 
               ? val1.compareTo(val2) 
               : val2.compareTo(val1);
   };
   
   // 监听列排序方向变化，触发重排
   columnFirst.sortTypeProperty().addListener(obs -> {
       if (treeTableView.getRoot() instanceof SortedTreeItem) {
           ((SortedTreeItem<Entry>) treeTableView.getRoot()).resortChildren();
       }
   });
   
   button.setOnAction(event -> {
       Random random = new Random();
       String first = String.valueOf((char)(random.nextInt('Z' - 'A') + 'A'));
       String second = String.valueOf((char)(random.nextInt('Z' - 'A') + 'A'));
       Entry entry = new Entry(first, second);
   
       if(treeTableView.getRoot() == null) {
           SortedTreeItem<Entry> root = new SortedTreeItem<>(entry, columnFirstComparator);
           root.setExpanded(true);
           treeTableView.setRoot(root);
           treeTableView.getSortOrder().add(columnFirst);
       } else {
           ((SortedTreeItem<Entry>) treeTableView.getRoot()).addChildren(new TreeItem<>(entry));
       }
   });
   

说明 #

两种方案均无需手动在每次数据变更时调用sort()：

• 方案1实现简单，依赖TreeTableView自身的排序逻辑，适合快速改造现有代码
• 方案2封装性更强，将排序逻辑内聚到TreeItem中，适合复杂树形结构或多列排序场景

内容的提问来源于stack exchange，提问作者Stefan Pfeifer