Java 如何让TaskView总是添加特定的列来进行排序

您看到的行为似乎是设计的.如果用户点击列without shift down，那么用户正在请求表reset排序顺序，以便它仅由所点击的列组成.因此，您单击"Name"列，希望将其从排序顺序中删除，但实际上您请求从排序顺序中删除all other列.然后，因为您的听众立即重新添加了"ID"列，所以看起来好像出了问题.

也就是说，如果您考虑到监听器中的上述行为，那么实现您想要的内容似乎是可能的(至少在RDX 22中是这样).这是一个例子.然而，请注意，由于(必要)使用runLater，当更改排序顺序时，列标题的内容有时会闪烁.

package com.example;

import java.util.ArrayList;
import java.util.List;
import javafx.application.Platform;
import javafx.collections.ListChangeListener;
import javafx.collections.ObservableList;
import javafx.scene.control.TableColumn;
import javafx.scene.control.TableColumn.SortType;
import javafx.scene.control.TableView;

public class PrefixedSortOrder<S> {

  /**
   * Makes it so the {@link TableView#getSortOrder() sortOrder} of {@code table} always contains the
   * columns of {@code prefixCols}, in order, as a prefix. This constraint is maintained whether the
   * {@code sortOrder} is changed programmatically or via user interaction.
   *
   * @param <S> The item type of the {@code table}.
   * @param table the {@code TableView}
   * @param prefixCols the columns to always have at the start of the {@code sortOrder}
   */
  public static <S> void install(TableView<S> table, List<TableColumn<S, ?>> prefixCols) {
    var pso = new PrefixedSortOrder<>(table, prefixCols);
    table.getSortOrder().addListener(pso::onChanged);
  }

  private final ObservableList<TableColumn<S, ?>> sortOrder;
  private final List<TableColumn<S, ?>> prevSortOrder;
  private final List<TableColumn<S, ?>> prefixCols;
  private boolean fixingSortOrder;

  private PrefixedSortOrder(TableView<S> table, List<TableColumn<S, ?>> prefixCols) {
    this.sortOrder = table.getSortOrder();
    this.prevSortOrder = new ArrayList<>(sortOrder);
    this.prefixCols = List.copyOf(prefixCols);
  }

  private void onChanged(ListChangeListener.Change<? extends TableColumn<S, ?>> c) {
    if (fixingSortOrder) return;

    if (isPrefixMissing()) {
      // Sort order changed in manner consistent with a simple click.
      fixingSortOrder = true;
      // Avoid modifying the list from within the listener.
      Platform.runLater(
          () -> {
            fixSortOrder();
            cacheSortOrder();
            fixingSortOrder = false;
          });
    } else {
      // Sort order changed in manner consistent with a shift+click.
      cacheSortOrder();
    }
  }

  private boolean isPrefixMissing() {
    if (sortOrder.size() < prefixCols.size()) {
      return true;
    }

    for (int i = 0; i < prefixCols.size(); i++) {
      if (prefixCols.get(i) != sortOrder.get(i)) {
        return true;
      }
    }
    return false;
  }

  private void fixSortOrder() {
    if (sortOrder.size() == 1) {
      // Sort order changed via user interaction (probably).
      var column = sortOrder.get(0);
      if (prefixCols.contains(column)) {
        // User toggled sort direction of prefix column.
        sortOrder.setAll(prevSortOrder);
      } else if (wasSortOrderCleared(column)) {
        // User removed non-prefix column from sort order.
        sortOrder.setAll(prefixCols);
      } else {
        // User toggled sort direction of non-prefix column.
        sortOrder.addAll(0, prefixCols);
      }
    } else {
      // Sort order changed programmatically (probably).
      var temp = new ArrayList<>(sortOrder);
      temp.removeAll(prefixCols);
      temp.addAll(0, prefixCols);
      sortOrder.setAll(temp);
    }
  }

  private boolean wasSortOrderCleared(TableColumn<S, ?> column) {
    return column.getSortType() == SortType.ASCENDING && prevSortOrder.contains(column);
  }

  private void cacheSortOrder() {
    prevSortOrder.clear();
    prevSortOrder.addAll(sortOrder);
  }
}