JFX TreeTableView текстовая фильтрация

Question

В следующем примере показан рабочий пример простой фильтрации текста для TreeTableView.

package treetableview;

import java.util.HashMap;
import java.util.Map;

import javafx.animation.KeyFrame;
import javafx.application.Application;
import javafx.beans.InvalidationListener;
import javafx.beans.Observable;
import javafx.beans.binding.ListBinding;
import javafx.beans.property.BooleanProperty;
import javafx.beans.property.ReadOnlyStringWrapper;
import javafx.beans.property.SimpleBooleanProperty;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.collections.FXCollections;
import javafx.collections.ListChangeListener;
import javafx.collections.ObservableList;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.CheckBox;
import javafx.scene.control.SelectionMode;
import javafx.scene.control.TableCell;
import javafx.scene.control.TableColumn;
import javafx.scene.control.TableView;
import javafx.scene.control.TextField;
import javafx.scene.control.TreeItem;
import javafx.scene.control.TreeTableColumn;
import javafx.scene.control.TreeTableView;
import javafx.scene.control.cell.PropertyValueFactory;
import javafx.scene.layout.HBox;
import javafx.scene.layout.StackPane;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;
import javafx.util.Callback;
import javafx.util.Duration;

@SuppressWarnings("all")
public class TreeTableViewFilterDemo extends Application {

    private TreeItem<Map<String, Object>> root;
    private TreeTableView<Map<String, Object>> tree;


    @Override
    public void start(Stage primaryStage) throws Exception {
        VBox outer = new VBox();

        TextField filter = new TextField();
        filter.textProperty().addListener((observable, oldValue, newValue) -> filterChanged(newValue));

        root = new TreeItem<>();
        tree = new TreeTableView<>(root);
        addColumn("Region", "region");
        addColumn("Type", "type");
        addColumn("Pop.", "population");
        setup();
        tree.setShowRoot(false);

        outer.getChildren().addAll(filter, tree);
        Scene scene = new Scene(outer, 640, 480);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    private void filterChanged(String filter) {
        if (filter.isEmpty()) {
            tree.setRoot(root);         
        }
        else {
            TreeItem<Map<String, Object>> filteredRoot = new TreeItem<>();
            filter(root, filter, filteredRoot);
            tree.setRoot(filteredRoot);
        }
    }


    private void filter(TreeItem<Map<String, Object>> root, String filter, TreeItem<Map<String, Object>> filteredRoot) {
        for (TreeItem<Map<String, Object>> child : root.getChildren()) {            
            TreeItem<Map<String, Object>> filteredChild = new TreeItem<>();
            filteredChild.setValue(child.getValue());
            filteredChild.setExpanded(true);
            filter(child, filter, filteredChild );
            if (!filteredChild.getChildren().isEmpty() || isMatch(filteredChild.getValue(), filter)) {
                System.out.println(filteredChild.getValue() + " matches.");
                filteredRoot.getChildren().add(filteredChild);
            }
        }
    }

    private boolean isMatch(Map<String, Object> value, String filter) {
        return value.values().stream().anyMatch((Object o) -> o.toString().contains(filter));
    }

    private void setup() {
        TreeItem<Map<String, Object>> europe = createItem(root, "Europe", "continent", 742500000L);
        createItem(europe, "Germany", "country", 80620000L);
        TreeItem<Map<String, Object>> austria = createItem(europe, "Austria", "country", 847400L);
        createItem(austria, "Tyrol", "state", 728537L);     
        TreeItem<Map<String, Object>> america = createItem(root, "America", "continent", 953700000L);
        createItem(america, "USA", "country", 318900000L);
        createItem(america, "Mexico", "country", 122300000L);       
    }

    private TreeItem<Map<String, Object>> createItem(TreeItem<Map<String, Object>> parent, String region, String type, long population) {
        TreeItem<Map<String, Object>> item = new TreeItem<>();
        Map<String, Object> value = new HashMap<>();
        value.put("region",  region);
        value.put("type", type);
        value.put("population", population);
        item.setValue(value);
        parent.getChildren().add(item);
        item.setExpanded(true);
        return item;
    }

    protected void addColumn(String label, String dataIndex) {
        TreeTableColumn<Map<String, Object>, String> column = new TreeTableColumn<>(label);
        column.setPrefWidth(150);
        column.setCellValueFactory(
            (TreeTableColumn.CellDataFeatures<Map<String, Object>, String> param) -> {
                ObservableValue<String> result = new ReadOnlyStringWrapper("");
                if (param.getValue().getValue() != null) {
                    result = new ReadOnlyStringWrapper("" + param.getValue().getValue().get(dataIndex));
                }
                return result;
            }
        );      
        tree.getColumns().add(column);
    }


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

}

Ниже приведены мои коды:

Person.java

package treetableview;

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

public class Person
{
    // Declaring the attributes page 424
    private String firstName;
    private String lastName;
    private LocalDate birthDate;

    // An enum for age categories
    public enum AgeCategory
    {
        BABY,
        CHILD,
        TEEN,
        ADULT,
        SENIOR,
        UNKNOWN
    };

    public Person(String firstName, String lastName, LocalDate birthDate)
    {
        this.firstName = firstName;
        this.lastName = lastName;
        this.birthDate = birthDate;
    }

    public String getFirstName()
    {
        return firstName;
    }

    public void setFirstName(String firstName)
    {
        this.firstName = firstName;
    }

    public String getLastName()
    {
        return lastName;
    }

    public void setLastName(String lastName)
    {
        this.lastName = lastName;
    }

    public LocalDate getBirthDate()
    {
        return birthDate;
    }

    public void setBirthDate(LocalDate birthDate)
    {
        this.birthDate = birthDate;
    }

    @Override
    public String toString()
    {
        return firstName + " " + lastName + ", " + birthDate.toString();
    }

    /* Domain specific business rules */
    public AgeCategory getAgeCategory()
    {
        if (birthDate == null)
        {
            return AgeCategory.UNKNOWN;
        }

        long years = ChronoUnit.YEARS.between(birthDate, LocalDate.now());

        if (years >= 0 && years < 2)
        {
            return AgeCategory.BABY;
        }
        else if (years >= 2 && years < 13)
        {
            return AgeCategory.CHILD;
        }
        else if (years >= 13 && years <= 19)
        {
            return AgeCategory.TEEN;
        }
        else if (years > 19 && years <= 50)
        {
            return AgeCategory.ADULT;
        }
        else if (years > 50)
        {
            return AgeCategory.SENIOR;
        }
        else
        {
            return AgeCategory.UNKNOWN;
        }
    }
}

TreeTableUtil.java

package treetableview;

import java.time.LocalDate;

import javafx.scene.control.TreeItem;
import javafx.scene.control.TreeTableColumn;
import javafx.scene.control.cell.TreeItemPropertyValueFactory;

public class TreeTableUtil
{
    @SuppressWarnings("unchecked")
    public static TreeItem<Person> getModel()
    {
        // Create all persons
        // First level
        Person person1 = new Person("FirstName1", "LastName1", LocalDate.of(1930, 1, 1));

        // Second level
        Person person2 = new Person("FirstName2", "LastName2", LocalDate.of(1956, 12, 17));
        Person person3 = new Person("FirstName3", "LastName3", LocalDate.of(1961, 3, 1));
        Person person4 = new Person("FirstName4", "LastName4", LocalDate.of(1968, 1, 12));
        Person person5 = new Person("FirstName5", "LastName5", LocalDate.of(1978, 4, 14));

        // Third level
        Person person6 = new Person("FirstName6", "LastName6", LocalDate.of(1980, 5, 10));
        Person person7 = new Person("FirstName7", "LastName7", LocalDate.of(1981, 3, 20));
        Person person8 = new Person("FirstName8", "LastName8", LocalDate.of(1982, 6, 3));
        Person person9 = new Person("FirstName9", "LastName9", LocalDate.of(1990, 8, 27));
        Person person10 = new Person("FirstName10", "LastName10", LocalDate.of(1994, 5, 15));

        // Fourth level
        Person person11 = new Person("FirstName11", "LastName11", LocalDate.of(2010, 6, 3));
        Person person12 = new Person("FirstName12", "LastName12", LocalDate.of(2012, 10, 11));
        Person person13 = new Person("FirstName13", "LastName13", LocalDate.of(2012, 10, 11));

        // Build nodes
        TreeItem<Person> person6Node = new TreeItem<>(person6);
        person6Node.getChildren().addAll(new TreeItem<>(person11), new TreeItem<>(person12));

        TreeItem<Person> person7Node = new TreeItem<>(person7);
        person7Node.getChildren().addAll(new TreeItem<>(person13));

        TreeItem<Person> person2Node = new TreeItem<>(person2);
        person2Node.getChildren().addAll(person6Node, new TreeItem<>(person8),person7Node);

        TreeItem<Person> person3Node = new TreeItem<>(person3);
        person3Node.getChildren().addAll(new TreeItem<>(person9), new TreeItem<>(person10));

        TreeItem<Person> person4Node = new TreeItem<>(person4);
        TreeItem<Person> person5Node = new TreeItem<>(person5);

        // Create the root node and add children
        TreeItem<Person> rootNode = new TreeItem<>(person1);
        rootNode.getChildren().addAll(person2Node, person3Node, person4Node, person5Node);

        return rootNode;
    }

    // Returns Person Id TreeTableColumn
    public static TreeTableColumn<Person, Integer> getIdColumn()
    {
        TreeTableColumn<Person, Integer> idColumn = new TreeTableColumn<>("Id");
        idColumn.setCellValueFactory(new TreeItemPropertyValueFactory<>("personId"));
        return idColumn;
    }

    // Returns First Name TreeTableColumn
    public static TreeTableColumn<Person, String> getFirstNameColumn()
    {
        TreeTableColumn<Person, String> firstNameCol = new TreeTableColumn<>("First Name");
        firstNameCol.setCellValueFactory(new TreeItemPropertyValueFactory<>("firstName"));
        return firstNameCol;
    }

    // Returns Last Name TreeTableColumn
    public static TreeTableColumn<Person, String> getLastNameColumn()
    {
        TreeTableColumn<Person, String> lastNameCol = new TreeTableColumn<>("Last Name");
        lastNameCol.setCellValueFactory(new TreeItemPropertyValueFactory<>("lastName"));
        return lastNameCol;
    }

    // Returns Birth Date TreeTableColumn 
    public static TreeTableColumn<Person, LocalDate> getBirthDateColumn()
    {
        TreeTableColumn<Person, LocalDate> birthDateCol = new TreeTableColumn<>("Birth Date");
        birthDateCol.setCellValueFactory(new TreeItemPropertyValueFactory<>("birthDate"));
        return birthDateCol;
    }

    // Returns Age Category TreeTableColumn
    public static TreeTableColumn<Person, Person.AgeCategory> getAgeCategoryColumn()
    {
        TreeTableColumn<Person, Person.AgeCategory> birthDateCol = new TreeTableColumn<>("Age Category");
        birthDateCol.setCellValueFactory(new TreeItemPropertyValueFactory<>("ageCategory"));
        return birthDateCol;
    }
}

TreeTableViewExample.java

package treetableview;

import java.util.Map;

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.TreeItem;
import javafx.scene.control.TreeTableView;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

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

    @Override
    public void start(Stage stage)
    {
        // Create the RootNode
        TreeItem<Person> rootNode = TreeTableUtil.getModel();
        rootNode.setExpanded(true);

        // Create a TreeTableView with model
        TreeTableView<Person> treeTable = new TreeTableView<>(rootNode);
        treeTable.setPrefWidth(400);

        // Add columns to the TreeTableView
        treeTable.getColumns().add(TreeTableUtil.getFirstNameColumn());
        treeTable.getColumns().add(TreeTableUtil.getLastNameColumn());
        treeTable.getColumns().add(TreeTableUtil.getBirthDateColumn());
        treeTable.getColumns().add(TreeTableUtil.getAgeCategoryColumn());

        // Create the VBox
        VBox root = new VBox(treeTable);

        treeTable.setTableMenuButtonVisible(true);

        // Set the Style-properties of the VBox
        root.setStyle("-fx-padding: 10;" +
                "-fx-border-style: solid inside;" +
                "-fx-border-width: 2;" +
                "-fx-border-insets: 5;" +
                "-fx-border-radius: 5;" +
                "-fx-border-color: blue;");

        // Create the Scene
        Scene scene = new Scene(root);
        // Add the Scene to the Stage
        stage.setScene(scene);
        // Set the Title
        stage.setTitle("A TreeTableView with Data");
        // Display the Stage
        stage.show();
    }
}

Первый рабочий пример с фильтрацией использует методы createItem и addColumn для создания хэш-карты всех строк "TreeItem>", но мой второй пример загружает таблицу из модели "TreeItem". Фильтр использует хэш-карту, обходной путь будет выглядеть примерно так:

private void filter(TreeItem<Person> rootNode, String filter, TreeItem<Person> filteredRoot) {
            for (TreeItem<Person> child : rootNode.getChildren()) {            
                TreeItem<Person> filteredChild = new TreeItem<Person>();            
                filteredChild.setValue(child.getValue());
                filteredChild.setExpanded(true);
                filter(child, filter, filteredChild );
                if (!filteredChild.getChildren().isEmpty() || isMatch(filteredChild.getValue(), filter)) {
                    System.out.println(filteredChild.getValue() + " matches.");
                    filteredRoot.getChildren().add(filteredChild);
                }
            }
        }
        private boolean isMatch(Person value, String filter) {
            String firstName = value.getFirstName();
            String lastName = value.getLastName();
            LocalDate birthDate = value.getBirthDate();
            AgeCategory ageCat = value.getAgeCategory();

            if (firstName.contains(filter)) {
                return true;
            }
            if (lastName.contains(filter)) {
                return true;
            }
            if (birthDate.toString().contains(filter)) {
                return true;
            }
            if (ageCat.toString().contains(filter)) {
                return true;
            }
            return false;
        }

Есть ли более элегантный способ отфильтровать это? Особенно метод isMatch, представьте таблицу с множеством столбцов.